Python Instantâneo

por Magnus Lie Hetland

Este é um curso intensivo mínimo para a linguagem de programação Python.

Para aprender mais, veja a documentação no site www.python.org;
especialmente o tutorial. Se você está se perguntando porque deveria se
interessar, veja esta comparação entre o Python e outras linguagens.

Esta introdução tem recebido elogios de leitores satisfeitos, e está sendo

traduzida para vários idiomas, entre os quais russo, norueguês, português (esta
página!) e espanhol. A versão original, em inglês, está aqui.

1. O básico
Para começar, pense em Python como sendo pseudo-código. Isto é quase uma
verdade. Variáveis não têm tipos, assim você não precisa declará-las. Elas são
criadas quando você lhes atribui um valor, e são destruídas quando não forem
mais usadas. A atribuição é feita pelo operador =. A igualdade é testada com o
operador ==. Você pode atribuir mais de uma variável ao mesmo tempo:

x,y,z = 1,2,3
primeiro, segundo = segundo, primeiro
a = b = 123

Os blocos são indicados somente pela indentação (nada de BEGIN/END ou

chaves.) Algumas estruturas de controle são:

if x < 5 or (x > 10 and x < 20):

print("O valor está correto.")

if x < 5 or 10 < x < 20:

print("O valor está correto.")

for i in [1,2,3,4,5]:
print("Esta é a iteração número", i)

x = 10
while x >= 0:
print("x ainda não é negativo.")
x = x-1

Os primeiros dois exemplos são equivalentes.

A variável de índice no laço for varia de acordo com os elementos de uma lista
(escrita como no exemplo). Para fazer um laço for comum (isto é, um laço de
contagem), use a função embutida range().
 # Mostra os valores de 0 a 99 inclusive.
for valor in range(100):
print(valor)

(A linha começando por "#" é um comentário, sendo ignorada pelo

interpretador.)

Vejamos: agora você já sabe o suficiente (em teoria) para implementar qualquer
algoritmo em Python. Vamos incluir alguma interação básica com o usuário.
Para obter dados do usuário (a partir de um prompt texto), use a função
embutida input.

x = input("Por favor digite um número: ")

print("O quadrado desse número é", x*x)

A função input mostra o texto dado (o qual pode ser vazio) e deixa o usuário
entrar qualquer valor válido em Python. Neste caso nós estamos esperando um
número - se alguma outra coisa (como uma string) for fornecida, o programa
poderá falhar. Para evitar isto nós devemos implementar alguma checagem de
erro.

Eu não vou entrar em detalhes aqui; é suficiente dizer que se você deseja
receber o dado do usuário, literalmente como uma string (assim qualquer coisa
pode ser fornecida), use a função raw_input. Se você deseja converter uma
string s para um inteiro, você poderia usar int(s).

Nota: Se o usuário deseja fornecer uma string com input, ele deverá escrever as
aspas explicitamente. Em python, as strings podem ser delimitadas com aspas
simples ou duplas.

Assim, já que temos estruturas de controle, entrada e saída - agora nós

precisamos de algumas estruturas de dados. As mais importantes são as listas e
os dicionários. As listas são escritas com colchetes, e podem ser (naturalmente)
aninhadas:

nome = ["Cleese", "John"]

x = [[1,2,3],[y,z],[[[]]]]

Uma das coisas mais interessantes sobre as listas é que os seus elementos
podem ser acessados separadamente ou em grupos, através de indexação e
corte em fatias. A indexação é feita (como em muitas outras linguagens) pela
colocação do índice entre os colchetes (Note que o primeiro elemento tem
índice 0).

print(nome[1], nome[0]) # Mostra "John Cleese"

nome[0] = "Smith"
O corte em fatias é parecido com a indexação, indicando-se os índices inicial e
final separados por dois pontos (":")

x = ["spam","spam","spam","spam","spam","eggs","and","spam"]

print(x[5:7]) # Mostra a lista ["eggs","and"]

Observe que o índice final não se inclui no resultado. Se um dos índices é

omitido, assume-se que você deseja todos os elementos na direção
correspondente. Por exemplo, lista[:3] significa "cada elemento desde o início da
lista até o elemento 3, este não incluído." (Poderia-se dizer na verdade que vai
até o elemento 4, desde que a contagem inicia do 0... Oh, tudo bem) list[3:]
significaria, por outro lado, "cada elemento da lista, começando do elemento 3
(inclusive) até o último inclusive." Para outros resultados bem interessantes,
você pode usar números negativos também: list[-3] é o terceiro elemento desde
o final da lista...

Já que estamos falando de indexação, é interessante saber que a função

embutida len fornece o tamanho de uma lista (em número de elementos).

E agora, o que há sobre os dicionários? Para ser breve, eles são como listas, mas
o seu conteúdo não está ordenado. Como você os indexa então? Bem, cada
elemento tem uma chave, ou um "nome" que é usado para buscar o elemento
tal qual um dicionário de verdade. Eis dois dicionários como exemplo:

{ "Alice" : 23452532, "Boris" : 252336,

"Clarice" : 2352525, "Doris" : 23624643}

pessoa = { 'nome': "Robin", 'sobrenome': "Hood",

'ocupação': "Ladrão" }

Agora, para obter a ocupação da pessoa, nós usamos a expressão

pessoa["ocupação"]. Se nós desejarmos alterar o seu sobrenome, nos
poderíamos escrever:

pessoa['sobrenome'] = "de Locksley"

Simples, não? Como as listas, os dicionários podem armazenar outros

dicionários. Ou listas, que já conhecemos. E naturalmente listas podem
armazenar dicionários também. Desta forma, você pode conseguir estruturas de
dados bastante avançadas.

2. Funções
Próximo passo: Abstração. Queremos dar um nome a um pedaço de código, e
chamá-lo com um parâmetro. Em outras palavras - nós queremos definir uma
função (ou "procedimento"). Isto é fácil. Use a palavra-chave def assim:
 def quadrado(x):
return x*x

print(quadrado(2)) # Mostra 4

Para quem pode entender: todos os parâmetros em Python são passados por
referência (como, por exemplo, em Java). Para quem não entende: Não se
preocupe com isto :)

Python tem muitas coisas "legais" como argumentos com nome e argumentos
com valor padrão, podendo manipular um número variável de argumentos para
uma função. Para mais informações sobre isto, veja a seção 4.7 do tutorial de
Python.

Se você sabe como usar funções em geral, isto é basicamente o que você
precisa saber sobre elas em Python. (Ah, sim... A palavra-chave return termina a
execução da função e retorna o valor dado.)

Uma coisa que é útil saber, entretanto, é que as função são valores em python.
Assim se você tem uma função como quadrado, você pode fazer alguma coisa
assim:

figura = quadrado
figura(2) # Mostra 4

Para chamar uma função sem argumentos você deve lembrar de escrever func()
e não func. A segunda forma, como mostrado, somente retorna a própria
função, como um valor. (Isto ocorre com os métodos dos objetos também...
Veja abaixo.)

3. Objetos e coisas...
Eu suponho que você saiba como funciona a programação orientada a objetos.
(De outra forma, esta seção não faria muito sentido. Sem problemas... Comece a
brincar sem os objetos :).) Em Python você define classes com a palavra-chave
(surpresa!) class, assim:

class Cesta:

# Lembre-se sempre do argumento *self*

def __init__(self,conteudo=None):
self.conteudo = conteudo or []

def adicione(self,elemento):
self.conteudo.append(elemento)

def mostre_me(self):
result = ""
for elemento in self.conteudo:
resultado = resultado + " " + "elemento"
 print("Contém:" + resultado)

Coisas novas aqui:

Todos os métodos (funções dentro de um objeto) recebem um argumento

adicional no início da lista de argumentos, contendo o próprio objeto.
(Chamado self neste exemplo, por convenção.)

Métodos são chamados assim: objeto.método(arg1,arg2).

Alguns nomes de métodos, como init são pré-definidos, e têm significado

especial. init é o nome do construtor da classe, isto é, esta é a função que é
chamada quando você cria uma instância.

Alguns argumentos podem ser opcionais e ter um valor padrão (como

mencionado acima, na seção sobre funções). Isto é feito escrevendo-se a
definição desta forma:

def spam(idade=32): ...

Aqui, spam pode ser chamado com um ou zero parâmetros. Se nenhum for
usado, então o parâmetro idade terá o valor 32. "Lógica de curto-circuito." Este
é um ponto... Veja abaixo.

Aspas simples invertidas convertem um objeto para sua representação como

string. (Assim se elemento contém o número 1, então elemento é o mesmo que
"1" sendo 'elemento' uma string literal.)
O sinal de adição + é usado também para concatenação de listas, e strings são
na verdade listas de caracteres (o que significa que você pode usar indexação e
corte em fatias e a função len com strings. Legal, não acha?)

Nenhum método ou variável membro é protegido (nem privado, nem nada

parecido) em Python. Encapsulação é na maioria das vezes um estilo de
programação. (Se você realmente precisar, existem convenções para nomes de
variáveis, que permitem alguma privacidade :)).

E agora, sobre a lógica de curto-circuito...

Todos os valores em Python podem ser usados como valores lógicos. Alguns
dos mais "vazios", tais como [], 0, "" e None representam o valor lógico "falso",
enquanto o resto dos valores (como [0], 1 ou "Olá Mundo" representam o valor
lógico "verdadeiro".

Assim, expressões lógicas como a and b são avaliadas deste modo: Primeiro,
verifique se a é verdadeiro. Se não, então simplesmente retorne-o. Se sim, então
simplesmente retorne b (o que irá representar o valor lógico da expressão.). A
lógica correspondente para a or b é: se a é verdadeiro, então retorne-o, Se não
é, então retorne b.

Este mecanismo faz com que and e or se comportem como os operadores

booleanos que implementam, mas eles também permitem escrever expressões
condicionais muito curiosas. Por exemplo, o código

if a:
print(a)
else:
print(b)

Poderia ser substituído por:

print(a or b)

Na verdade, isto já é alguma coisa do idioma Python, assim é melhor você ir se

acostumando. Isto é o que foi feito no método Cesta.init. O argumento
conteudo tem um valor padrão None (o que é, entre outras coisas, falso).
Portanto, para verificar se ele tem um valor, nós poderíamos escrever:

if conteudo:
self.conteudo = conteudo
else:
self.conteudo = []

É claro, agora você sabe como fazer de uma forma melhor. E por que nós não
demos o valor padrão [] no começo? Porque da maneira como o Python
funciona, isto daria a todas as Cestas a mesma lista vazia como valor padrão.
Tão logo uma das listas começasse a ser preenchida, todas as outras teriam os
mesmo elementos, e o padrão não seria mais vazio... Para aprender mais sobre
isto você deveria ler a documentação e procurar a diferença entre identidade e
igualdade.

Outra forma de fazer o anterior é:

def __init__(self, conteudo=[]):

self.conteudo = conteudo[:]

Você pode adivinhar como isto funciona? Ao invés de usar a mesma lista vazia
para todos, nós usamos a expressão conteudo[:] para fazer uma cópia (Usamos
uma fatia que contém a lista toda.)

Assim, para fazer uma Cesta e usá-la (isto é. para chamar alguns dos seus
métodos) nós devemos fazer algo assim:

b = Cesta(['maçã','laranja'])
b.adicione("limão")
b.mostre_me()
Há outros métodos mágicos além do init. Um desses métodos é str que define
como o objeto será conhecido quando for tratado como uma string. Nós
poderíamos usar este método ao invés de mostre_me:

def __str__(self):
result = ""
for elemento in self.conteudo:
resultado = resultado + " " + "elemento"
return "Contém:" + resultado

Agora, se nós desejamos mostrar a cesta b, nós usaríamos simplesmente:

print(b)

Legal, não acha?

Subclasses são feitas assim:

class CestaSpam(Cesta):
# ...

Python permite herança múltipla, assim você pode ter várias superclasses entre
parênteses, separadas por vírgulas. Classes são instanciadas assim: x = Cesta().
Construtores são implementados, como disse, com a definição de uma função
membro especial init. Digamos que CestaSpam tem um
construtor init(self,tipo). Então você poderia fazer uma cesta spam assim: y =
CestaSpam("maças").

Se você, no construtor de CestaSpam precisar chamar o construtor de uma ou

mais superclasses, você poderia chamá-los desta forma: Cesta.init(self). Note
que além dos parâmetros comuns, você deve fornecer explicitamente o self, já
que a superclasse init não sabe qual instância está tratando.

Para saber mais sobre as maravilhas da programação orientada a objeto em

Python, veja seção 9 do tutorial de Python.

4. Um truque mental de Jedi

(Esta seção está aqui porque eu acho que ela é muito interessante.
Definitivamente esta seção não é necessária para começar a aprender Python.)

Você gosta de exercícios mentais? Então, se você é realmente ousado, você

gostará de ver o ensaio do Guido van Rossum sobre metaclasses. Se, entretanto,
você prefere não explodir sua mente, irá igualmente satisfazer-se com este
pequeno truque.

Python usa espaços de nomes dinâmicos (não léxicos). Isto quer dizer que se há
uma função como esta:
 def suco_laranja():
return x*2

... onde uma variável (neste caso x) não está ligada a um argumento e não é
dado um valor dentro da função, Python usará o valor que ela tiver onde e
quando a função for chamada. Neste caso:

x = 3
y = suco_laranja() # y agora é 6
x = 1
y = suco_laranja() # y agora é 2

Normalmente este é o tipo de comportamento esperado (apesar do exemplo

ser um pouco rebuscado - raramente acessamos variáveis desta forma.)
Entretanto, algumas vezes pode ser útil ter um espaço de nomes estático, ou
seja, armazenar alguns valores do ambiente em que a função é criada. A
maneira de fazer isto em Python é por meio dos argumentos padrão.

x = 4
def suco_maça(x=x):
return x*2

Aqui, ao argumento x é atribuído o valor padrão que é o mesmo valor da

variável x quando a função é definida. Assim, se nenhum valor é fornecido como
argumento para a função, ela irá funcionar assim:

x = 3
y = suco_maça():
# y agora é 8
x = 1
y = suco_maça():
# y agora é 8

Assim - o valor de x não é alterado. Se isto era tudo que nós queríamos,
poderíamos simplesmente ter escrito

def suco_tomate():
x = 4
return x*2

ou mesmo

def suco_cenoura():
return 8

Entretanto, o ponto é que o valor de x é obtido do ambiente quando a função é

definida. O quanto isto é útil? Vejamos um exemplo: uma função composta.

Nós queremos uma função que funcione assim:

from math import sin, cos

sincos = componha(sin,cos)

x = sincos(3)
Onde componha é a função que queremos fazer, e x tem o valor -
0.836021861538, que é o mesmo que sin(cos(3)). Agora, como faremos isto?

(Note que nós estamos usando funções como argumentos... Este é o próprio
truque.)

Claramente, componha toma duas funções como parâmetros, e retorna uma

função que por sua vez recebe um parâmetro. Assim, um esqueleto da solução
seria:

def componha(fun1, fun2):

def interior(x):
pass # ...
return interior

Nós poderíamos tentar return fun1(fun2(x)) dentro da da função interior e

deixá-lo tal qual. Não, não, não. Isto teria um comportamento muito estranho.
Imagine o seguinte cenário:

from math import sin, cos

def fun1(x):
return x + " mundo!"

def fun2(x):
return "Olá,"

sincos = componha(sin,cos) # Usando a versão incorreta

x = sincos(3)

Agora, qual valor x terá? Resposta: "Olá, mundo!". Por que isto? Porque quando
é chamada, ela toma o valor de fun1 e fun2 do ambiente, não aqueles de
quando foi criada. Para conseguir a solução correta, tudo que teremos que fazer
é usar a técnica descrita anteriormente:

def componha(fun1, fun2):

def interior(x, fun1=fun1, fun2=fun2):
return fun1(fun2(x))
return interior

Agora nós só temos que esperar que ninguém forneça mais de um argumento à
função resultante, pois isto quebraria os esquemas :). E, a propósito, já que nós
não precisamos do nome interior, e esta função contém somente uma
expressão, nós podemos usar uma função anônima, usando a palavra-chave
lambda:

def componha(f1, f2):

return lambda x, f1=f1, f2=f2: f1(f2(x))

Sucinto, porém claro. Você tem que gostar :)

(E se você não entendeu nada, não se preocupe. Pelo menos eu espero tê-lo
convencido que Python é muito mais do que "uma linguagem para scripts"... :))

5. E agora...
Só umas coisinhas para terminar. A maioria das funções e classes mais úteis são
colocadas em módulos, os quais são na verdade arquivos-texto contendo
código Python. Você pode importá-los e usá-los em seus programas. Por
exemplo, para usar o método split do módulo padrão string, você pode ter
estas duas formas:

import string

x = string.split(y)

Ou...

from string import split

x = split(y)

Para mais informações sobre a biblioteca de módulos padrão, de uma olhada

em www.python.org/doc/lib. Contém muitos módulos úteis.

Todo o código em um módulo/script se executa quando é importado. Se você

quer que o seu programa seja tanto um módulo importável quanto um
programa executável, você pode adicionar alguma coisa parecida com isto no
final do programa:

if __name__ == "__main__":
run()

Esta é uma forma mágica de dizer que se este módulo esta sendo executado
como um script executável (isto é, que não está sendo importado por outro
script), então a função executar deve ser chamada. E é claro, você poderia fazer
qualquer coisa após os dois pontos... :)

E para aqueles que desejam fazer um script UN*X executável, escreva isto como
primeira linha do arquivo:

#!/usr/bin/env python

Finalmente, uma breve menção de um conceito importante: Exceções. Algumas

operações (como divisão por zero ou ler de um arquivo não-existente)
produzem condições de erro ou exceções. Você pode até criar suas próprias
exceções e lançá-las em momentos adequados.
Se nada é feito para tratar a exceção, seu programa termina e mostra uma
mensagem de erro. Você pode evitar isto com uma construção try/except. Por
exemplo:

def divisao_segura(a,b):
try:
return a/b
except ZeroDivisionError:
return None

ZeroDivisionError é uma exceção padrão. Neste caso, você poderia ter verificado
se b era zero, mas em muitos casos, esta estratégia não é viável. Além disso, se
não tivermos a cláusula try em divisao_segura, e dessa forma tornando arriscada
a sua chamada, nós poderíamos ainda fazer alguma coisa assim:

try:
divisao_insegura(a,b)
except ZeroDivisionError:
print("Foi tentada uma divisão por zero em divisao_insegura")

Nos casos onde normalmente não haveriam problemas específicos, mas eles
poderiam ocorrer, o uso de exceções evita tediosos testes, etc.

Bem - era isto. Espero que você tenha aprendido alguma coisa. Agora pode ir
brincar. E lembre-se do lema do aprendizado em Python: "Use os fontes, Lucas."
(Tradução: leia todo código fonte a que você tiver acesso :)) Para começar, aqui
está um exemplo. É o conhecido algoritmo QuickSort, de Hoare. Uma versão
com a sintaxe destacada em cores está aqui.

Vale a pena mencionar uma coisa sobre este exemplo. A variável done controla
se partition foi finalizada, ou não, na busca entre os elementos. Assim quando
um dos dois laços internos querem terminar a sequência de trocas, eles
atribuem 1 à variável done e interrompem-se a si próprios com break. Por que
os laços internos usam done? Porque, quando o primeiro laço interno finaliza
com um break, o laço seguinte só será executado se done não estiver com o
valor 1:

while not done:

while not done:
# Repete-se até ocorrer um break

while not done:

# Só executado se o primeiro não atribuir 1 para "done"

Uma versão equivalente, possivelmente mais clara, mas em minha opinião

menos elegante que a anterior poderia ser:

while not done:

while 1:
# Repete-se até ocorrer um break

if not done:
 while 1:
# Só executado se o primeiro não atribuir 1 para "done"

A única razão para eu usar a variável done no primeiro laço foi porque eu
preferi manter a simetria entre os dois laços. Desta forma poderia ser invertida a
ordem e mesmo assim o algoritmo funcionaria.

Mais alguns exemplos podem ser encontrados na página tidbit de Joe Strout.