Introdução ao Python

Propriedades

Python é fortemente tipado (isto é, tipos são aplicados), dinamicamente, implicitamente digitado (ou seja, você não precisa declarar variáveis), case sensitive (ou seja, var e VAR são duas variáveis diferentes) e orientado a objeto (ou seja, tudo é um objeto) .

 Conseguindo ajuda

A ajuda no Python está sempre disponível diretamente no intérprete. Se você quiser saber como um objeto funciona, tudo o que você precisa fazer é chamar help (<object>)! Também são úteis o dir (), que mostra todos os métodos do objeto, e <object> .__ doc__, que mostra sua string de documentação:

>>> help(5)

Ajuda no objeto int:

(etc etc)

>>> dir(5)

['__abs__', '__adiciona __', ...]

>>> abs.__doc__

'abs(número) -> número

Retorna o valor absoluto do argumento.

Sintaxe

O Python não possui caracteres de terminação de instrução obrigatórios e os blocos são especificados por recuo. Recuar para iniciar um bloco, deduzido para terminar um. Instruções que esperam que um nível de recuo termine em dois pontos (:). Os comentários começam com o sinal de libra (#) e são sequências de linha única e multi-linha são usados para comentários de várias linhas. Valores são atribuídos (na verdade, objetos são vinculados a nomes) com o sinal de igual ("="), e o teste de igualdade é feito usando dois sinais de igual ("=="). Você pode incrementar / decrementar valores usando os operadores + = e - = respectivamente pelo valor da mão direita. Isso funciona em muitos tipos de dados, cadeias de caracteres incluídas. Você também pode usar várias variáveis em uma linha. Por exemplo:

>>> myvar = 3

>>> myvar += 2

>>> myvar

5

>>> myvar -= 1

>>> myvar

4

""" Este é um comentário.

As seguintes linhas concatenam as duas strings. "" "

>>> mystring = "Hello"

>>> mystring += " world."

>>> print(mystring)

Hello world.

# Isso troca as variáveis em uma linha (!).

# Não viola a digitação forte porque os valores não são

# na verdade sendo atribuído, mas novos objetos são obrigados a

# os nomes antigos.

>>> myvar, mystring = mystring, myvar

Estrutura de dados

 As estruturas de dados disponíveis em python são listas, tuplas e dicionários. Conjuntos estão disponíveis na biblioteca de conjuntos (mas estão embutidos no Python 2.5 e posterior). As listas são como matrizes unidimensionais (mas você também pode ter listas de outras listas), dicionários são matrizes associativas (também conhecidas como tabelas hash) e tuplas são matrizes unidimensionais imutáveis (“matrizes” Python podem ser de qualquer tipo, então você pode misture, por exemplo, inteiros, strings, etc em listas / dicionários / tuplas). O índice do primeiro item em todos os tipos de matriz é 0. Os números negativos contam desde o final até o início, -1 é o último item. Variáveis podem apontar para funções. O uso é o seguinte:

>>> sample = [1, ["another", "list"], ("a", "tuple")]

>>> mylist = ["List item 1", 2, 3.14]

>>> mylist[0] = "List item 1 again" # Nós estamos mudando 1 item

>>> mylist[-1] = 3.21 # A gente se refere ao último item

>>> mydict = {"Key 1": "Value 1", 2: 3, "pi": 3.14}

>>> mydict["pi"] = 3.15 # Muda os valores do dicionário

>>> mytuple = (1, 2, 3)

>>> myfunction = len

>>> print(myfunction(mylist))

3

Você pode acessar os intervalos de array usando dois pontos (:). Deixar o índice inicial vazio assume o primeiro item, deixando o índice final assumindo o último item. A indexação é inclusiva-exclusiva, portanto especificar [2:10] retornará itens [2] (o terceiro item, por causa da indexação 0) a [9] (o décimo item), inclusive (8 itens). 
Índices negativos contam do último item para trás (assim -1 é o último item) assim:

>>> mylist = ["List item 1", 2, 3.14]

>>> print(mylist[:])

['Lista item 1', 2, 3.1400000000000001]

>>> print(mylist[0:2])

['Lista item 1', 2]

>>> print(mylist[-3:-1])

['Lista item 1', 2]

>>> print(mylist[1:])

[2, 3.14]

# Adicionando um terceiro parâmetro, "step" vai fazer Python entrar

# N incrementos de item, em vez de 1.

# Por exemplo, isso retornará o primeiro item, depois o terceiro e

# retorna isso (assim, os itens 0 e 2 na indexação 0).

>>> print(mylist[::2])

['Lista item 1', 3.14]

Strings

Suas strings podem usar aspas simples ou duplas, e você pode ter aspas de um tipo dentro de uma string que usa o outro tipo (ou seja, "Ele disse 'oi'." É válido). As cadeias de caracteres multilinhas são colocadas entre aspas duplas (ou simples) _ ("" "). Seqüências de caracteres Python são sempre Unicode, mas há outro tipo de seqüência de caracteres que é bytes puro. Esses são chamados bytestrings e são representados com o prefixo b, por exemplo b'Hello \ xce \ xb1 '. . Para preencher uma string com valores, você usa o operador% (modulo) e uma tupla. Cada% s é substituído por um item da tupla, da esquerda para a direita, e você também pode usar as substituições do dicionário, da seguinte forma: “

>>> print("Name: %s\

Number: %s\

String: %s" % (myclass.name, 3, 3 * "-"))

Name: Stavros

Number: 3

String: ---

strString = """Aqui tem uma

string."""

 # ADVERTÊNCIA: Preste atenção nos tracques em "% (tecla) s".

>>> print("Isso %(verbo)s a %(substantivo)s." % {"substantivo ": "

testa", " verbo": "é"})

This is a test.

>>> name = "Gabriel"

>>> "Hello, {}!".format(name)

Oi,Gabriel!

>>> print(f"Hello, {name}!")

Oi,Gabriel!

Declarações de controle de fluxo

 As instruções de controle de fluxo são if, for e while. Não há troca; em vez disso, use if. Use para enumerar os membros de uma lista. Obter

rangelist = range(10)

>>> print(rangelist)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

for number in rangelist:

    # Checar se o número é um dos

    # Números na tuple.

    if number in (3, 4, 7, 9):

        # "Break" termina a um for loop sem

        # executar a cláusula "else".

        break

    else:

        # "Continue" inicia a próxima iteração

         # do loop. É um pouco inútil aqui

         # como é a última declaração do loop.

        continue

else:

    # The "else" clause # A cláusula "else" é opcional e é

     # executado apenas se o loop não "quebrar".

    pass # Não faz nada

if rangelist[1] == 2:

    print("O segundo item (listas são baseadas a partir de 0) é 2")

elif rangelist[1] == 3:

    print("The second item (listas são baseadas a partir de  0) é 3")

else:

    print("Sei lá")

while rangelist[1] == 1:

    pass

Funções

 Funções são declaradas com a palavra-chave def. Argumentos opcionais são definidos na declaração de função após os argumentos obrigatórios ao serem atribuídos um valor padrão. Para argumentos nomeados, o nome do argumento é atribuído a um valor. As funções podem retornar uma tupla (e, usando a descompactação de tupla, você pode efetivamente retornar vários valores). Funções lambda são funções ad hoc que são compostas por uma única instrução. Os parâmetros são passados por referência, mas os tipos imutáveis (tuplas, ints, strings, etc) não podem ser alterados no chamador pelo receptor. Isso ocorre porque somente a localização da memória do item é passada e a vinculação de outro objeto a uma variável descarta a antiga, de modo que os tipos imutáveis são substituídos. Por exemplo:

# O mesmo que def funcvar(x): return x + 1

funcvar = lambda x: x + 1

>>> print(funcvar(1))

2

# um_int e uma_string são opcionais, eles tem valores padrão

#

se um não é passado (2 e "Uma string",respectivamente).

def passing_example(a_list, an_int=2, a_string="Padrão string"):

    a_list.append("A new item")

    an_int = 4

    return a_list, an_int, a_string

>>> my_list = [1, 2, 3]

>>> my_int = 10

>>> print(passing_example(my_list, my_int))

([1, 2, 3, 'Novo item'], 4, "A default string")

>>> my_list

[1, 2, 3, 'Um novo item']

>>> my_int

10

Classes

O Python suporta uma forma limitada de herança múltipla em classes. Variáveis e métodos privados podem ser declarados (por convenção, isso não é imposto pela linguagem), adicionando pelo menos dois sublinhados e no máximo um sublinhado (por exemplo, __spam). Também podemos vincular nomes arbitrários a instâncias de classes. Um exemplo segue:

class MyClass(object):

    common = 10

    def __init__(self):

        self.myvariable = 3

    def myfunction(self, arg1, arg2):

        return self.myvariable

     # Esta é a instanciação de classe

>>> classinstance = MyClass()

>>> classinstance.myfunction(1, 2)

3

# Essa varia´vel é compartilhada por todas instâncias

>>> classinstance2 = MyClass()

>>> classinstance.common

10

>>> classinstance2.common

10

# Note como nós usamos o nome da classe

# ao invés de uma instância.

>>> MyClass.common = 30

>>> classinstance.common

30

>>> classinstance2.common

30

# Isso não atualizará a variável na classe,

# em vez disso, ligará um novo objeto ao antigo

# nome variável.

>>> classinstance.common = 10

>>> classinstance.common

10

>>> classinstance2.common

30

>>> MyClass.common = 50

# Isso não mudou, porque "comum" é

# agora uma variável de instância.

>>> classinstance.common

10

>>> classinstance2.common

50

# Esta classe é herdada do MyClass. O exemplo

# classe acima herda de "objeto", o que faz

# o que é chamado de "classe de novo estilo".

# A herança múltipla é declarada como:

# class OtherClass (MyClass1, MyClass2, MyClassN)

class OtherClass(MyClass):

    # O argumento "self" é passado automaticamente

     # e refere-se à instância da classe, para que você possa definir

     # variáveis de instância como acima, mas de dentro da classe.

    def __init__(self, arg1):

        self.myvariable = 3

        print(arg1)

>>> classinstance = OtherClass("hello")

hello

>>> classinstance.myfunction(1, 2)

3

# Esta classe não possui um membro .test, mas

# podemos adicionar um à instância de qualquer maneira. Nota

# que isto seja apenas um membro da instância de classe.

>>> classinstance.test = 10

>>> classinstance.test

10

Exceções

Exceções são tratadas com try-except [exceptionname] blocks:

def some_function():

    try:

        # Divisão por zero gera uma exceção

        10 / 0

    except ZeroDivisionError:

        print("Oops, invalido.")

    else:

        # Exceções não ocorrem, Somos bons.

        pass

    finally:

        # Isso é executado depois que o bloco de código é executado

         # e todas as exceções foram tratadas, mesmo

         # se uma nova exceção for levantada durante o manuseio.

        print("Nós estamos cheios w.")

>>> some_function()

Oops, invalido.

Nós Acabamos com isso.

Importando

 Bibliotecas externas são usadas com a palavra-chave import [libname]. Você também pode usar a partir de [libname] import [funcname] para funções individuais. Aqui está um exemplo::

import random

from time import clock

randomint = random.randint(1, 100)

>>> print(randomint)

64

Arquivo I/O

O Python tem uma grande variedade de bibliotecas embutidas. Como exemplo, aqui está como a serialização (conversão de estruturas de dados para strings usando a biblioteca de pickles) com arquivo de E / S é usada:

import pickle

mylist = ["This", "is", 4, 13327]

# Abra o arquivo C: \\ binary.dat para gravação. A letra r antes do

# filename string é usada para evitar a saída de barra invertida.

myfile = open(r"C:\\binary.dat", "wb")

pickle.dump(mylist, myfile)

myfile.close()

myfile = open(r"C:\\text.txt", "w")

myfile.write("Aqui tem uma simples string")

myfile.close()

myfile = open(r"C:\\text.txt")

>>> print(myfile.read())

'This is a sample string'

myfile.close()

# Abra o arquivo para ler.

myfile = open(r"C:\\binary.dat", "rb")

loadedlist = pickle.load(myfile)

myfile.close()

>>> print(loadedlist)

['Isso', 'é', 4, 13327]

Diversos

• Condições podem ser encadeadas: 1 <a <3 verifica se a é menor que 3 e maior que 1.
• o Você pode usar del para excluir variáveis ou itens em matrizes.
• A Compreensão de lista fornece uma maneira poderosa de criar e manipular listas. Eles consistem em uma expressão seguida por uma cláusula for seguida por zero ou mais se ou por cláusulas, da seguinte forma:

>>> lst2 = [3, 4, 5]

>>> print([x * y for x in lst1 for y in lst2])

[3, 4, 5, 6, 8, 10, 9, 12, 15]

>>> print([x for x in lst1 if 4 > x > 1])

[2, 3]

# Verifique se uma condição é verdadeira para qualquer item.

# "any" retorna true se algum item na lista for verdadeiro.

>>> any([i % 3 for i in [3, 3, 4, 4, 3]])

True

# Isso é porque 4 % 3 = 1, e 1 é verdade , então any()

# returns.

# Checa para quantos itens a condição é verdade.

>>> sum(1 for i in [3, 3, 4, 4, 3] if i == 4)

2

>>> del lst1[0]

>>> print(lst1)

[2, 3]

>>> del lst1

o    As variáveis globais  são declaradas fora das funções e podem ser lidas sem quaisquer declarações especiais, mas se você quiser escrever nelas você deve declará-las no início da função com a palavra-chave global, caso contrário o Python ligará esse objeto a um novo local variável (cuidado com isso, é uma pequena captura que pode te pegar se você não souber). Por exemplo:

number = 5

def myfunc():

    # Isso imprime 5.

    print(number)

def anotherfunc():

     # Isso gera uma exceção porque a variável não tem

     # foi ligado antes de imprimir. Python sabe que é um

     # objeto será vinculado a ele mais tarde e cria um novo local

     # objeto em vez de acessar o global.

    print(number)

    number = 3

def yetanotherfunc():

    global number

    # Isso  mudará corretamente o global.

    number = 3