4. Mais ferramentas de controle de fluxo
****************************************

Além do comando "while" recém apresentado, Python tem as estruturas
usuais de controle de fluxo conhecidas em outras linguagens, com
algumas particularidades.


4.1. Comando "if"
=================

Provavelmente o mais conhecido comando de controle de fluxo é o "if".
Por exemplo:

   >>> x = int(input("Please enter an integer: "))
   Please enter an integer: 42
   >>> if x < 0:
   ...     x = 0
   ...     print('Negative changed to zero')
   ... elif x == 0:
   ...     print('Zero')
   ... elif x == 1:
   ...     print('Single')
   ... else:
   ...     print('More')
   ...
   More

Pode haver zero ou mais seções "elif", e a seção "else" é opcional. A
palavra-chave "elif" é uma abreviação para 'else if', e é útil para
evitar indentação excessiva. Uma sequência "if" ... "elif" ... "elif"
... substitui as construções "switch" ou "case" existentes em outras
linguagens.


4.2. Comando "for"
==================

O comando "for" em Python difere um tanto do que talvez estejas
acostumado em C ou Pascal. Ao invés de se iterar sobre progressões
aritméticas (como em Pascal), ou dar ao usuário o poder de definir
tanto o passo da iteração quanto a condição de parada (como em C), o
comando "for" de Python itera sobre os itens de qualquer sequência
(como uma lista ou uma string), na ordem em que eles aparecem na
sequência. Por exemplo:

   >>> # Measure some strings:
   ... words = ['cat', 'window', 'defenestrate']
   >>> for w in words:
   ...     print(w, len(w))
   ...
   cat 3
   window 6
   defenestrate 12

Se for necessário modificar a sequência, sobre a qual está iterando,
dentro do laço de repetição (por exemplo, para duplicar itens
selecionados), é recomendado que primeiro crie-se uma cópia da
sequência. Iterar sobre uma sequência não cria implicitamente uma
cópia. A notação de fatiamento é bastante conveniente para isso:

   >>> for w in words[:]:  # Loop over a slice copy of the entire list.
   ...     if len(w) > 6:
   ...         words.insert(0, w)
   ...
   >>> words
   ['defenestrate', 'cat', 'window', 'defenestrate']

Com "for w in words:", o exemplo tentaria criar uma lista infinita,
inserindo "defenestrate" uma e outra vez.


4.3. A função "range()"
=======================

Se você precisar iterar sobre sequências numéricas, a função embutida
"range()" é a resposta. Ela gera progressões aritméticas:

   >>> for i in range(5):
   ...     print(i)
   ...
   0
   1
   2
   3
   4

O ponto de parada fornecido nunca é incluído na lista; "range(10)"
gera uma lista com 10 valores, exatamente os índices válidos para uma
sequência de comprimento 10. É possível iniciar o intervalo em outro
número, ou alterar a razão da progressão (inclusive com passo
negativo):

   range(5, 10)
      5, 6, 7, 8, 9

   range(0, 10, 3)
      0, 3, 6, 9

   range(-10, -100, -30)
     -10, -40, -70

Para iterar sobre os índices de uma sequência, combine "range()" e
"len()" da seguinte forma:

   >>> a = ['Mary', 'had', 'a', 'little', 'lamb']
   >>> for i in range(len(a)):
   ...     print(i, a[i])
   ...
   0 Mary
   1 had
   2 a
   3 little
   4 lamb

Na maioria dos casos, porém, é mais conveniente usar a função
"enumerate()", veja Técnicas de iteração.

Uma coisa estranha acontece se imprime-se um range:

   >>> print(range(10))
   range(0, 10)

Em muitos aspectos, o objeto retornado pela função "range()" se
comporta como se fosse uma lista, mas na verdade não é. É um objeto
que retorna os itens sucessivos da sequência desejada quando você
itera sobre a mesma, mas na verdade ele não gera a lista, economizando
espaço.

Nós dizemos que tal objeto é *iterável*, isto é, adequado como um alvo
para funções e construções que esperam algo do qual possam obter itens
sucessivos até que o suprimento se  esgote. Vimos que a instrução
"for" é um *iterador*. A função "list()" é outro; cria listas de
iteráveis:

   >>> list(range(5))
   [0, 1, 2, 3, 4]

Mais tarde, veremos mais funções que retornam "iteráveis" e recebem
"iteráveis" como argumento.


4.4. Comandos "break" e "continue", e cláusulas "else" em laços
===============================================================

O comando "break", como no C, sai imediatamente do laço de repetição
mais interno, seja "for" ou "while".

Laços podem ter uma cláusula "else", que é executada sempre que o laço
se encerra por exaustão da lista (no caso do "for") ou quando a
condição se torna falsa (no caso do "while"), mas nunca quando o laço
é interrompido por um "break". Isto é exemplificado no próximo exemplo
que procura números primos:

   >>> for n in range(2, 10):
   ...     for x in range(2, n):
   ...         if n % x == 0:
   ...             print(n, 'equals', x, '*', n//x)
   ...             break
   ...     else:
   ...         # loop fell through without finding a factor
   ...         print(n, 'is a prime number')
   ...
   2 is a prime number
   3 is a prime number
   4 equals 2 * 2
   5 is a prime number
   6 equals 2 * 3
   7 is a prime number
   8 equals 2 * 4
   9 equals 3 * 3

(Sim, o código está correto. Olhe atentamente: a cláusula "else"
pertence ao laço "for", e **não** ao comando "if".)

Quando usado com um loop, a cláusula "else" tem mais em comum com a
cláusula "else" de uma declaração "try" o que faz de instruções "if":
uma declaração "else" da instrução "try" é executada quando nenhuma
exceção ocorre e uma frase do "else" do loop é executada quando não
ocorre "break". Para mais informações sobre a declaração "try" e
exceções, veja Tratamento de exceções.

A instrução "continue", também emprestada da linguagem C, continua com
a próxima iteração do laço:

   >>> for num in range(2, 10):
   ...     if num % 2 == 0:
   ...         print("Found an even number", num)
   ...         continue
   ...     print("Found a number", num)
   Found an even number 2
   Found a number 3
   Found an even number 4
   Found a number 5
   Found an even number 6
   Found a number 7
   Found an even number 8
   Found a number 9


4.5. Comando "pass"
===================

O comando "pass" não faz nada. Ela pode ser usada quando a sintaxe
exige um comando mas a semântica do programa não requer nenhuma ação.
Por exemplo:

   >>> while True:
   ...     pass  # Busy-wait for keyboard interrupt (Ctrl+C)
   ...

Isto é usado muitas vezes para se definir classes mínimas:

   >>> class MyEmptyClass:
   ...     pass
   ...

Outra situação em que "pass" pode ser usado é para reservar o lugar de
uma função ou de um bloco condicional, quando se está trabalhando em
código novo, o que lhe possibilita continuar a raciocinar em um nível
mais abstrato. O comando "pass" é ignorado silenciosamente:

   >>> def initlog(*args):
   ...     pass   # Remember to implement this!
   ...


4.6. Definindo Funções
======================

Podemos criar uma função que escreve a série de Fibonacci até um
limite arbitrário:

   >>> def fib(n):    # write Fibonacci series up to n
   ...     """Print a Fibonacci series up to n."""
   ...     a, b = 0, 1
   ...     while a < n:
   ...         print(a, end=' ')
   ...         a, b = b, a+b
   ...     print()
   ...
   >>> # Now call the function we just defined:
   ... fib(2000)
   0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

A palavra reservada "def" inicia a *definição* de uma função. Ela deve
ser seguida do nome da função e da lista de parâmetros formais entre
parênteses. Os comandos que formam o corpo da função começam na linha
seguinte e devem ser indentados.

Opcionalmente, a primeira linha do corpo da função pode ser uma string
literal, cujo propósito é documentar a função. Se presente, essa
string chama-se *docstring*. (Há mais informação sobre docstrings na
seção Strings de documentação.) Existem ferramentas que utilizam
docstrings para produzir automaticamente documentação online ou para
imprimir, ou ainda permitir que o usuário navegue interativamente pelo
código. É uma boa prática incluir sempre docstrings em suas funções,
portanto, tente fazer disso um hábito.

A *execução* de uma função gera uma nova tabela de símbolos, usada
para as variáveis locais da função. Mais precisamente, toda atribuição
a variável dentro da função armazena o valor na tabela de símbolos
local. Referências a variáveis são buscadas primeiramente na tabela
local, então na tabela de símbolos global e finalmente na tabela de
nomes embutidos (built-in). Portanto, não se pode atribuir diretamente
um valor a uma variável global dentro de uma função (a menos que se
utilize a declaração "global" antes), ainda que variáveis globais
possam ser referenciadas livremente.

Os parâmetros reais (argumentos) de uma chamada de função são
introduzidos na tabela de símbolos local da função no momento da
chamada; portanto, argumentos são passados *por valor* (onde o *valor*
é sempre uma *referência* para objeto, não o valor do objeto). [1]
Quando uma função chama outra função, uma nova tabela de símbolos é
criada para tal chamada.

Uma definição de função introduz o nome da função na tabela de
símbolos atual. O valor associado ao nome da função tem um tipo que é
reconhecido pelo interpretador como uma função definida pelo usuário.
Esse valor pode ser atribuído a outros nomes que também podem ser
usados como funções. Esse mecanismo serve para renomear funções:

   >>> fib
   <function fib at 10042ed0>
   >>> f = fib
   >>> f(100)
   0 1 1 2 3 5 8 13 21 34 55 89

Conhecendo outras linguagens, pode-se questionar que "fib" não é uma
função, mas um procedimento, pois ela não devolve um valor. Na
verdade, mesmo funções que não usam o comando "return" devolvem um
valor, ainda que pouco interessante. Esse valor é chamado "None" (é um
nome embutido). O interpretador interativo evita escrever "None"
quando ele é o único resultado de uma expressão. Mas se quiser vê-lo
pode usar o comando "print":

   >>> fib(0)
   >>> print(fib(0))
   None

É fácil escrever uma função que devolve uma lista de números da série
de Fibonacci, ao invés de exibi-los:

   >>> def fib2(n):  # return Fibonacci series up to n
   ...     """Return a list containing the Fibonacci series up to n."""
   ...     result = []
   ...     a, b = 0, 1
   ...     while a < n:
   ...         result.append(a)    # see below
   ...         a, b = b, a+b
   ...     return result
   ...
   >>> f100 = fib2(100)    # call it
   >>> f100                # write the result
   [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Este exemplo demonstra novos recursos de Python:

* The "return" statement returns with a value from a function.
  "return" without an expression argument returns "None". Falling off
  the end of a function also returns "None".

* A instrução "result.append(a)" chama um *método* do objeto lista
  "result". Um método é uma função que 'pertence' a um objeto, e é
  chamada "obj.methodname", onde "obj" é um objeto qualquer (pode ser
  uma expressão), e "methodname" é o nome de um método que foi
  definido pelo tipo do objeto. Tipos diferentes definem métodos
  diferentes. Métodos de diferentes tipos podem ter o mesmo nome sem
  ambiguidade. (É possível definir seus próprios tipos de objetos e
  métodos, utilizando *classes*, veja em Classes) O método "append()",
  mostrado no exemplo é definido para objetos do tipo lista; ele
  adiciona um novo elemento ao final da lista. Neste exemplo, ele
  equivale a "result = result + [a]", só que mais eficiente.


4.7. Mais sobre definição de funções
====================================

É possível definir funções com um número variável de argumentos.
Existem três formas, que podem ser combinadas.


4.7.1. Argumentos com valores padronizados
------------------------------------------

A mais útil das três é especificar um valor padronizado para um ou
mais argumentos. Isso cria uma função que pode ser invocada com menos
argumentos do que os que foram definidos. Por exemplo:

   def ask_ok(prompt, retries=4, reminder='Please try again!'):
       while True:
           ok = input(prompt)
           if ok in ('y', 'ye', 'yes'):
               return True
           if ok in ('n', 'no', 'nop', 'nope'):
               return False
           retries = retries - 1
           if retries < 0:
               raise ValueError('invalid user response')
           print(reminder)

Essa função pode ser chamada de várias formas:

* fornecendo apenas o argumento obrigatório: "ask_ok('Do you really
  want to quit?')"

* fornecendo um dos argumentos opcionais: "ask_ok('OK to overwrite the
  file?', 2)"

* ou fornecendo todos os argumentos: "ask_ok('OK to overwrite the
  file?', 2, 'Come on, only yes or no!')"

Este exemplo também introduz o operador "in", que verifica se uma
sequência contém ou não um determinado valor.

Os valores padronizados são avaliados no momento da definição da
função, e no escopo em que a função foi *definida*, portanto:

   i = 5

   def f(arg=i):
       print(arg)

   i = 6
   f()

irá exibir "5".

**Aviso importante:** Valores padronizados são avaliados apenas uma
vez. Isso faz diferença quando o valor é um objeto mutável, como uma
lista, dicionário, ou instâncias de classes. Por exemplo, a função a
seguir acumula os argumentos passados, nas chamadas subsequentes:

   def f(a, L=[]):
       L.append(a)
       return L

   print(f(1))
   print(f(2))
   print(f(3))

Isso exibirá:

   [1]
   [1, 2]
   [1, 2, 3]

Se não quiser que o valor padrão seja compartilhado entre chamadas
subsequentes, pode reescrever a função assim:

   def f(a, L=None):
       if L is None:
           L = []
       L.append(a)
       return L


4.7.2. Argumentos nomeados
--------------------------

Funções também podem ser chamadas usando *keyword arguments* da forma
"kwarg=value".  Por exemplo, a função a seguir:

   def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
       print("-- This parrot wouldn't", action, end=' ')
       print("if you put", voltage, "volts through it.")
       print("-- Lovely plumage, the", type)
       print("-- It's", state, "!")

aceita um argumento obrigatório ("voltage") e três argumentos
opcionais ("state", "action", e "type"). Esta função pode ser chamada
de qualquer uma dessas formas:

   parrot(1000)                                          # 1 positional argument
   parrot(voltage=1000)                                  # 1 keyword argument
   parrot(voltage=1000000, action='VOOOOOM')             # 2 keyword arguments
   parrot(action='VOOOOOM', voltage=1000000)             # 2 keyword arguments
   parrot('a million', 'bereft of life', 'jump')         # 3 positional arguments
   parrot('a thousand', state='pushing up the daisies')  # 1 positional, 1 keyword

mas todas as formas a seguir seriam inválidas:

   parrot()                     # required argument missing
   parrot(voltage=5.0, 'dead')  # non-keyword argument after a keyword argument
   parrot(110, voltage=220)     # duplicate value for the same argument
   parrot(actor='John Cleese')  # unknown keyword argument

Numa chamada de função, argumentos nomeados devem vir depois dos
argumentos posicionais. Todos os argumentos nomeados passados devem
corresponder com argumentos aceitos pela função (ex. "actor" não é um
argumento nomeado válido para a função "parrot"), mas sua ordem é
irrelevante. Isto também inclui argumentos obrigatórios (ex.:
"parrot(voltage=1000)" funciona). Nenhum parâmetro pode receber mais
de um valor. Eis um exemplo que não funciona devido a esta restrição:

   >>> def function(a):
   ...     pass
   ...
   >>> function(0, a=0)
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: function() got multiple values for keyword argument 'a'

Quando o último parâmetro formal usar a sintaxe "**nome", ele receberá
um dicionário (ver Dicionários ou Tipo de Mapeamento --- dict
[online]) com todos os parâmetros nomeados passados para a função,
exceto aqueles que corresponderam a parâmetros formais definidos
antes. Isto pode ser combinado com o parâmetro formal "*nome"
(descrito na próxima subseção) que recebe uma tupla (N.d.T. uma
sequência de itens, semelhante a uma lista imutável; ver Tuplas e
Sequências) contendo todos argumentos posicionais que não correspondem
à lista da parâmetros formais. ("*nome" deve ser declarado antes de
"**nome".) Por exemplo, se definimos uma função como esta:

   def cheeseshop(kind, *arguments, **keywords):
       print("-- Do you have any", kind, "?")
       print("-- I'm sorry, we're all out of", kind)
       for arg in arguments:
           print(arg)
       print("-" * 40)
       for kw in keywords:
           print(kw, ":", keywords[kw])

Ela pode ser chamada assim:

   cheeseshop("Limburger", "It's very runny, sir.",
              "It's really very, VERY runny, sir.",
              shopkeeper="Michael Palin",
              client="John Cleese",
              sketch="Cheese Shop Sketch")

e, claro, exibiria:

   -- Do you have any Limburger ?
   -- I'm sorry, we're all out of Limburger
   It's very runny, sir.
   It's really very, VERY runny, sir.
   ----------------------------------------
   shopkeeper : Michael Palin
   client : John Cleese
   sketch : Cheese Shop Sketch

Observe que a ordem em que os argumentos nomeados são exibidos é
garantida corresponder à ordem em que foram fornecidos na chamada da
função.


4.7.3. Listas de argumentos arbitrários
---------------------------------------

Finalmente, a opção menos usada é especificar que a função pode ser
chamada com um número arbitrário de argumentos. Esses argumentos serão
empacotados em uma tupla (ver Tuplas e Sequências). Antes dos
argumentos em número variável, zero ou mais argumentos normais podem
estar presentes.

   def write_multiple_items(file, separator, *args):
       file.write(separator.join(args))

Normalmente, esses argumentos de "quantidade indefinida" estarão no
final da lista de parâmetros formais, porque eles englobam todos os
argumentos de entrada restantes, que são passados para a função.
Quaisquer parâmetros formais que ocorrem após o parâmetro "*args" são
argumentos 'chave-valor', o que significa que eles só podem ser usados
como chave-valor, em vez de argumentos posicionais:

   >>> def concat(*args, sep="/"):
   ...     return sep.join(args)
   ...
   >>> concat("earth", "mars", "venus")
   'earth/mars/venus'
   >>> concat("earth", "mars", "venus", sep=".")
   'earth.mars.venus'


4.7.4. Desempacotando listas de argumentos
------------------------------------------

A situação inversa ocorre quando os argumentos já estão numa lista ou
tupla mas ela precisa ser explodida para invocarmos uma função que
requer argumentos posicionais separados. Por exemplo, a função
"range()" espera argumentos separados, *start* e *stop*. Se os valores
já estiverem juntos em uma lista ou tupla, escreva a chamada de função
com o operador "*" para desempacotá-los da sequência:

   >>> list(range(3, 6))            # normal call with separate arguments
   [3, 4, 5]
   >>> args = [3, 6]
   >>> list(range(*args))            # call with arguments unpacked from a list
   [3, 4, 5]

Da mesma forma, dicionários podem produzir argumentos nomeados com o
operador "**":

   >>> def parrot(voltage, state='a stiff', action='voom'):
   ...     print("-- This parrot wouldn't", action, end=' ')
   ...     print("if you put", voltage, "volts through it.", end=' ')
   ...     print("E's", state, "!")
   ...
   >>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
   >>> parrot(**d)
   -- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !


4.7.5. Expressões lambda
------------------------

Pequenas funções anônimas podem ser criadas com a palavra-chave
"lambda". Esta função retorna a soma de seus dois argumentos: "lambda
a, b: a+b". As funções Lambda podem ser usadas sempre que objetos
função forem necessários. Eles são sintaticamente restritos a uma
única expressão. Semanticamente, eles são apenas açúcar sintático para
uma definição de função normal. Como definições de funções aninhadas,
as funções lambda podem referenciar variáveis contidas no escopo:

   >>> def make_incrementor(n):
   ...     return lambda x: x + n
   ...
   >>> f = make_incrementor(42)
   >>> f(0)
   42
   >>> f(1)
   43

O exemplo acima usa uma expressão lambda para retornar uma função.
Outro uso é passar uma pequena função como um argumento:

   >>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
   >>> pairs.sort(key=lambda pair: pair[1])
   >>> pairs
   [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]


4.7.6. Strings de documentação
------------------------------

Aqui estão algumas convenções sobre o conteúdo e formatação de strings
de documentação.

A primeira linha deve sempre ser curta, um resumo conciso do propósito
do objeto. Por brevidade, não deve explicitamente se referir ao nome
ou tipo do objeto, uma vez que estas informações estão disponíveis por
outros meios (exceto se o nome da função for o próprio verbo que
descreve a finalidade da função). Essa linha deve começar com letra
maiúscula e terminar com ponto.

Se existem mais linhas na string de documentação, a segunda linha deve
estar em branco, separando visualmente o resumo do resto da descrição.
As linhas seguintes devem conter um ou mais parágrafos descrevendo as
convenções de chamada ao objeto, seus efeitos colaterais, etc.

O analisador Python não remove a indentação de literais string multi-
linha. Portanto, ferramentas que processem strings de documentação
precisam lidar com isso, quando desejável. Existe uma convenção para
isso. A primeira linha não vazia após a linha de sumário determina a
indentação para o resto da string de documentação. (Não podemos usar a
primeira linha para isso porque ela em geral está adjacente às aspas
que iniciam a string, portanto sua indentação real não fica aparente.)
Espaços em branco "equivalentes" a essa indentação são então removidos
do início das demais linhas da string. Linhas com indentação menor não
devem ocorrer, mas se ocorrerem, todos os espaços à sua esquerda são
removidos. A equivalência de espaços em branco deve ser testada após a
expansão das tabulações (8 espaços, normalmente).

Eis um exemplo de uma docstring multi-linha:

   >>> def my_function():
   ...     """Do nothing, but document it.
   ...
   ...     No, really, it doesn't do anything.
   ...     """
   ...     pass
   ...
   >>> print(my_function.__doc__)
   Do nothing, but document it.

       No, really, it doesn't do anything.


4.7.7. Anotações de Função
--------------------------

Function annotations são informações metadados completamente opcionais
sobre os tipos usados pels funções definidas pelo usuário (veja **PEP
3107** e **PEP 484** para mais informações).

As anotações são armazenadas no atributo "__annotations__" da função
como um dicionário e não possuem efeito em nenhuma outra parte da
função. As anotações dos parâmetros são definidas por dois pontos após
o nome do parâmetro, seguido de uma expressão que avalia o valor da
anotação. As anotações de retorno são definidas por um literal "->",
seguido por uma expressão, entre a lista de parâmetros e o cólon
indicando o fim da declaração "def". O exemplo a seguir possui um
argumento posicional, um keyword argument e o valor de retorno
anotado:

   >>> def f(ham: str, eggs: str = 'eggs') -> str:
   ...     print("Annotations:", f.__annotations__)
   ...     print("Arguments:", ham, eggs)
   ...     return ham + ' and ' + eggs
   ...
   >>> f('spam')
   Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
   Arguments: spam eggs
   'spam and eggs'


4.8. Intermezzo: estilo de codificação
======================================

Agora que está prestes a escrever códigos mais longos e complexos em
Python, é um bom momento para falar sobre *estilo de codificação*. A
maioria das linguagens podem ser escritas (ou *formatadas*) em
diferentes estilos; alguns são mais legíveis do que outros. Tornar o
seu código mais fácil de ler, para os outros, é sempre uma boa ideia,
e adotar um estilo de codificação agradável ajuda bastante.

Em Python, o **PEP 8** tornou-se o guia de estilo adotado pela maioria
dos projetos; promove um estilo de codificação muito legível e
visualmente agradável. Todo desenvolvedor Python deve lê-lo em algum
momento; eis os pontos mais importantes, selecionados para você:

* Use indentação com 4 espaços, e não use tabulações.

  4 spaces are a good compromise between small indentation (allows
  greater nesting depth) and large indentation (easier to read).  Tabs
  introduce confusion, and are best left out.

* Quebre as linhas de modo que não excedam 79 caracteres.

  Isso ajuda os usuários com telas pequenas e torna possível abrir
  vários arquivos de código lado a lado em telas maiores.

* Deixe linhas em branco para separar funções e classes, e blocos de
  código dentro de funções.

* Quando possível, coloque comentários em uma linha própria.

* Escreva strings de documentação.

* Use espaços ao redor de operadores e após vírgulas, mas não
  diretamente dentro de parênteses, colchetes e chaves: "a = f(1, 2) +
  g(3, 4)".

* Name your classes and functions consistently; the convention is to
  use "CamelCase" for classes and "lower_case_with_underscores" for
  functions and methods.  Always use "self" as the name for the first
  method argument (see Primeiro contato com classes for more on
  classes and methods).

* Não use codificações exóticas se o seu código é feito para ser usado
  em um contexto internacional. O padrão do Python, UTF-8, ou mesmo
  ASCII puro funciona bem em qualquer caso.

* Da mesma forma, não use caracteres não-ASCII em identificadores se
  houver apenas a menor chance de pessoas falando um idioma diferente
  ler ou manter o código.

-[ Notas de rodapé ]-

[1] [#] Na verdade, *passagem por referência para objeto* seria uma
    descrição melhor, pois, se um objeto mutável for passado, quem
    chamou verá as alterações feitas por quem foi chamado (por
    exemplo, a inclusão de itens em uma lista).
