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
Comentários
Postar um comentário