4. Más herramientas para control de flujo
*****************************************

Besides the "while" statement just introduced, Python uses the usual
flow control statements known from other languages, with some twists.


4.1. La sentencia "if"
======================

Tal vez el tipo más conocido de sentencia sea el "if". Por ejemplo:

   >>> 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

Puede haber cero o más bloques "elif", y el bloque "else" es opcional.
La palabra reservada '"elif"'es una abreviación de 'else if', y es
útil para evitar un sangrado excesivo. Una secuencia "if" ... "elif"
... "elif" ... sustituye las sentencias "switch" o "case" encontradas
en otros lenguajes.


4.2. La sentencia "for"
=======================

La sentencia "for" en Python difiere un poco de lo que uno puede estar
acostumbrado en lenguajes como C o Pascal. En lugar de siempre iterar
sobre una progresión aritmética de números (como en Pascal) o darle al
usuario la posibilidad de definir tanto el paso de la iteración como
la condición de fin (como en C), la sentencia "for" de Python itera
sobre los ítems de cualquier secuencia (una lista o una cadena de
texto), en el orden que aparecen en la secuencia. Por ejemplo:

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

Si necesitas modificar la secuencia sobre la que estás iterando
mientras estás adentro del ciclo (por ejemplo para borrar algunos
ítems), se recomienda que hagas primero una copia. Iterar sobre una
secuencia no hace implícitamente una copia. La notación de rebanada es
especialmente conveniente para esto:

   >>> 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']

Con "for w in words:", el ejemplo intentaría crear una lista infinita,
insertando "defenestrate" una y otra vez.


4.3. La función "range()"
=========================

Si se necesita iterar sobre una secuencia de números, es apropiado
utilizar la función integrada "range()", la cual genera progresiones
aritméticas:

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

El valor final dado nunca es parte de la secuencia; "range(10)" genera
10 valores, los índices correspondientes para los ítems de una
secuencia de longitud 10. Es posible hacer que el rango empiece con
otro número, o especificar un incremento diferente (incluso negativo;
algunas veces se lo llama 'paso'):

   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 los índices de una secuencia, puedes combinar
"range()" y "len()" así:

   >>> 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

En la mayoría de los casos, sin embargo, conviene usar la función
"enumerate()", mira Técnicas de iteración.

Algo extraño sucede si muestras un `    *range`*:

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

De muchas maneras el objeto devuelto por "range()" se comporta como si
fuera una lista, pero no lo es. Es un objeto que devuelve los ítems
sucesivos de la secuencia deseada cuando iteras sobre él, pero
realmente no construye la lista, ahorrando entonces espacio.

Decimos que tal objeto es *iterable*; esto es, que se lo puede usar en
funciones y construcciones que esperan algo de lo cual obtener ítems
sucesivos hasta que se termine. Hemos visto que la declaración "for"
es un iterador en ese sentido. La función "list()" es otra; crea
listas a partir de iterables:

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

Más tarde veremos más funciones que devuelven iterables y que toman
iterables como entrada.


4.4. Las sentencias "break", "continue", y "else" en bucles
===========================================================

La sentencia "break", como en C, termina el bucle "for" o "while" más
anidado.

Las sentencias de bucle pueden tener una cláusula`!else` que es
ejecutada cuando el lazo termina, luego de agotar la lista (con "for")
o cuando la condición se hace falsa (con "while"), pero no cuando el
bucle se termina con la sentencia "break". Se puede ver el ejemplo en
el siguiente bucle, que busca 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

(Sí, este es el código correcto. Fíjate bien: el "else" pertenece al
ciclo "for", no al "if".)

Cuando se usa con un ciclo, el "else" tiene más en común con el "else"
de una declaración "try" que con el de un "if": el "else" de un "try"
se ejecuta cuando no se genera ninguna excepción, y el "else" de un
ciclo se ejecuta cuando no hay ningún "break". Para más sobre la
declaración "try" y excepciones, mira Gestionando Excepciones.

La declaración "continue", también tomada de C, continua con la
siguiente iteración del ciclo:

   >>> 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. La sentencia "pass"
========================

La sentencia "pass" no hace nada. Se puede usar cuando una sentencia
es requerida por la sintaxis pero el programa no requiere ninguna
acción. Por ejemplo:

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

Se usa normalmente para crear clases en su mínima expresión:

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

Otro lugar donde se puede usar "pass" es como una marca de lugar para
una función o un cuerpo condicional cuando estás trabajando en código
nuevo, lo cual te permite pensar a un nivel de abstracción mayor. El
"pass" se ignora silenciosamente:

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


4.6. Definiendo funciones
=========================

Podemos crear una función que escriba la serie de Fibonacci hasta un
límite determinado:

   >>> 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

La palabra reservada "def" se usa para definir funciones. Debe
seguirle el nombre de la función y la lista de parámetros formales
entre paréntesis. Las sentencias que forman el cuerpo de la función
empiezan en la línea siguiente, y deben estar con sangría.

La primera sentencia del cuerpo de la función puede ser opcionalmente
una cadena de texto literal; esta es la cadena de texto de
documentación de la función, o *docstring*. (Puedes encontrar más
acerca de docstrings en la sección Cadenas de texto de
documentación.). Existen herramientas que usan las "docstrings" para
producir documentación imprimible o disponible en línea, o para dejar
que los usuarios busquen interactivamente a través del código; es una
buena práctica incluir "docstrings" en el código que escribes, y
hacerlo un buen hábito.

The *execution* of a function introduces a new symbol table used for
the local variables of the function.  More precisely, all variable
assignments in a function store the value in the local symbol table;
whereas variable references first look in the local symbol table, then
in the local symbol tables of enclosing functions, then in the global
symbol table, and finally in the table of built-in names. Thus, global
variables and variables of enclosing functions cannot be directly
assigned a value within a function (unless, for global variables,
named in a "global" statement, or, for variables of enclosing
functions, named in a "nonlocal" statement), although they may be
referenced.

Los parámetros reales (argumentos) de una función se introducen en la
tabla de símbolos local de la función llamada cuando esta es
ejecutada; así, los argumentos son pasados por valor (dónde el valor
es siempre una referencia a un objeto, no el valor del objeto). [1]
Cuando una función llama a otra función, una nueva tabla de símbolos
local es creada para esa llamada.

La definición de una función introduce el nombre de la función en la
tabla de símbolos actual. El valor del nombre de la función tiene un
tipo que es reconocido por el interprete como una función definida por
el usuario. Este valor puede ser asignado a otro nombre que luego
puede ser usado como una función. Esto sirve como un mecanismo general
para renombrar:

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

Viniendo de otros lenguajes, puedes objetar que "fib" no es una
función, sino un procedimiento, porque no devuelve un valor. De hecho,
técnicamente hablando, los procedimientos sin "return" sí retornan un
valor, aunque uno aburrido. Este valor se llama "None" (es un nombre
predefinido). El intérprete por lo general no escribe el valor "None"
si va a ser el único valor escrito. Si realmente se quiere, se puede
verlo usando la función "print()"

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

Es simple escribir una función que retorne una lista con los números
de la serie de Fibonacci en lugar de imprimirlos:

   >>> 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 ejemplo, como es usual, demuestra algunas características más de
Python:

* La sentencia "return" devuelve un valor en una función. "return" sin
  una expresión como argumento retorna "None". Si se alcanza el final
  de una función, también se retorna "None".

* La sentencia "result.append(a)" llama a un método del objeto lista
  "result". Un método es una función que 'pertenece' a un objeto y se
  nombra "obj.methodname", dónde "obj" es algún objeto (puede ser una
  expresión), y "methodname" es el nombre del método que está definido
  por el tipo del objeto. Distintos tipos definen distintos métodos.
  Métodos de diferentes tipos pueden tener el mismo nombre sin causar
  ambigüedad. (Es posible definir tipos de objetos propios, y métodos,
  usando clases, mira Clases). El método "append()" mostrado en el
  ejemplo está definido para objetos lista; añade un nuevo elemento al
  final de la lista. En este ejemplo es equivalente a "result = result
  + [a]", pero más eficiente.


4.7. Más sobre definición de funciones
======================================

También es posible definir funciones con un número variable de
argumentos. Hay tres formas que pueden ser combinadas.


4.7.1. Argumentos con valores por omisión
-----------------------------------------

La forma más útil es especificar un valor por omisión para uno o más
argumentos. Esto crea una función que puede ser llamada con menos
argumentos que los que permite. Por ejemplo:

   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)

Esta función puede ser llamada de distintas maneras:

* pasando sólo el argumento obligatorio: "ask_ok('Do you really want
  to quit?')"

* pasando uno de los argumentos opcionales: "ask_ok('OK to overwrite
  the file?', 2)"

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

Este ejemplo también introduce la palabra reservada "in", la cual
prueba si una secuencia contiene o no un determinado valor.

Los valores por omisión son evaluados en el momento de la definición
de la función, en el ámbito de la definición, entonces:

   i = 5

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

   i = 6
   f()

...imprimirá "`5".

**Advertencia importante:** El valor por omisión es evaluado solo una
vez. Existe una diferencia cuando el valor por omisión es un objeto
mutable como una lista, diccionario, o instancia de la mayoría de las
clases. Por ejemplo, la siguiente función acumula los argumentos que
se le pasan en subsiguientes llamadas:

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

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

Imprimirá

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

Si no se quiere que el valor por omisión sea compartido entre
subsiguientes llamadas, se pueden escribir la función así:

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


4.7.2. Palabras claves como argumentos
--------------------------------------

Las funciones también puede ser llamadas usando *argumentos de
palabras clave* (o argumentos nombrados) de la forma "kwarg=value".
Por ejemplo, la siguiente función:

   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, "!")

...acepta un argumento obligatorio ("voltage")) y tres argumentos
opcionales ("state", "action", y "type"). Esta función puede llamarse
de cualquiera de las siguientes maneras:

   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

...pero estas otras llamadas serían todas 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

En una llamada a una función, los argumentos nombrados deben seguir a
los argumentos posicionales. Cada uno de los argumentos nombrados
pasados deben coincidir con un argumento aceptado por la función (por
ejemplo, "actor" no es un argumento válido para la función "parrot"),
y el orden de los mismos no es importante. Esto también se aplica a
los argumentos obligatorios (por ejemplo, "parrot(voltage=1000)"
también es válido). Ningún argumento puede recibir más de un valor al
mismo tiempo. Aquí hay un ejemplo que falla debido a esta restricción:

   >>> 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'

When a final formal parameter of the form "**name" is present, it
receives a dictionary (see Mapping Types --- dict) containing all
keyword arguments except for those corresponding to a formal
parameter.  This may be combined with a formal parameter of the form
"*name" (described in the next subsection) which receives a tuple
containing the positional arguments beyond the formal parameter list.
("*name" must occur before "**name".) For example, if we define a
function like this:

   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])

Puede ser llamada así:

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

...y por supuesto imprimirá:

   -- 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

Se debe notar que el orden en el cual los argumentos nombrados son
impresos está garantizado para coincidir con el orden en el cual
fueron provistos en la llamada a la función.


4.7.3. Listas de argumentos arbitrarios
---------------------------------------

Finalmente, la opción menos frecuentemente usada es especificar que
una función puede ser llamada con un número arbitrario de argumentos.
Estos argumentos serán organizados en una tupla (mira Tuplas y
secuencias). Antes del número variable de argumentos, cero o más
argumentos normales pueden estar presentes.:

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

Normalmente estos argumentos de cantidad variables son los últimos en
la lista de parámetros formales, porque toman todo el remanente de
argumentos que se pasan a la función. Cualquier parámetro que suceda
luego del "*args" será 'sólo nombrado', o sea que sólo se pueden usar
como argumentos nombrados y no como posicionales.:

   >>> 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. Desempaquetando una lista de argumentos
----------------------------------------------

La situación inversa ocurre cuando los argumentos ya están en una
lista o tupla pero necesitan ser desempaquetados para llamar a una
función que requiere argumentos posicionales separados. Por ejemplo,
la función predefinida "range()" espera los argumentos inicio y fin.
Si no están disponibles en forma separada, se puede escribir la
llamada a la función con el operador  "*" para desempaquetar
argumentos desde una lista o una tupla

   >>> 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]

Del mismo modo, los diccionarios pueden entregar argumentos nombrados
con el 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. Expresiones lambda
-------------------------

Pequeñas funciones anónimas pueden ser creadas con la palabra
reservada "lambda". Esta función retorna la suma de sus dos
argumentos: "lambda a, b: a+b" Las funciones Lambda pueden ser usadas
en cualquier lugar donde sea requerido un objeto de tipo función.
Están sintácticamente restringidas a una sola expresión.
Semánticamente, son solo azúcar sintáctica para definiciones normales
de funciones. Al igual que las funciones anidadas, las funciones
lambda pueden hacer referencia a variables desde el ámbito que la
contiene:

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

El ejemplo anterior muestra el uso de una expresión lambda para
retornar una función. Otro uso es para pasar pequeñas funciones como
argumentos

   >>> 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. Cadenas de texto de documentación
----------------------------------------

Acá hay algunas convenciones sobre el contenido y formato de las
cadenas de texto de documentación.

La primera línea debe ser siempre un resumen corto y conciso del
propósito del objeto. Para ser breve, no se debe mencionar
explícitamente el nombre o tipo del objeto, ya que estos están
disponibles de otros modos (excepto si el nombre es un verbo que
describe el funcionamiento de la función). Esta línea debe empezar con
una letra mayúscula y terminar con un punto.

Si hay más líneas en la cadena de texto de documentación, la segunda
línea debe estar en blanco, separando visualmente el resumen del resto
de la descripción. Las líneas siguientes deben ser uno o más párrafos
describiendo las convenciones para llamar al objeto, efectos
secundarios, etc.

El analizador de Python no quita el sangrado de las cadenas de texto
literales multi-líneas, entonces las herramientas que procesan
documentación tienen que quitarlo si así lo desean. Esto se hace
mediante la siguiente convención. La primera línea que no está en
blanco *siguiente* a la primer línea de la cadena determina la
cantidad de sangría para toda la cadena de documentación. (No podemos
usar la primer línea ya que generalmente es adyacente a las comillas
de apertura de la cadena y el sangrado no se nota en la cadena de
texto). Los espacios en blanco "equivalentes" a este sangrado son
luego quitados del comienzo de cada línea en la cadena. No deberían
haber líneas con una sangría menor, pero si las hay todos los espacios
en blanco del comienzo deben ser quitados. La equivalencia de espacios
en blanco debe ser verificada luego de la expansión de tabuladores (a
8 espacios, normalmente).

Este es un ejemplo de un "docstring" multi-línea:

   >>> 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. Anotación de funciones
-----------------------------

Las anotaciones de funciones son información completamente opcional
sobre los tipos usadas en funciones definidas por el usuario (ver PEP
484 para más información).

Las *anotaciones* se almacenan en el atributo "__annotations__" de la
función como un diccionario y no tienen efecto en ninguna otra parte
de la función. Las anotaciones de los parámetros se definen luego de
dos puntos después del nombre del parámetro, seguido de una expresión
que evalúa al valor de la anotación. Las anotaciones de retorno son
definidas por el literal ->, seguidas de una expresión, entre la lista
de parámetros y los dos puntos que marcan el final de la declaración
"def". El siguiente ejemplo tiene un argumento posicional, uno
nombrado, y el 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 codificación
=======================================

Ahora que estás a punto de escribir piezas de Python más largas y
complejas, es un buen momento para hablar sobre *estilo de
codificación*. La mayoría de los lenguajes pueden ser escritos (o
mejor dicho, *formateados*) con diferentes estilos; algunos son mas
fáciles de leer que otros. Hacer que tu código sea más fácil de leer
por otros es siempre una buena idea, y adoptar un buen estilo de
codificación ayuda tremendamente a lograrlo.

Para Python, **PEP 8**  se erigió como la guía de estilo a la que más
proyectos adhirieron; promueve un estilo de codificación fácil de leer
y visualmente agradable. Todos los desarrolladores Python deben leerlo
en algún momento; aquí están extraídos los puntos más importantes:

* Usar sangrías de 4 espacios, no tabuladores.

  4 espacios son un buen compromiso entre una sangría pequeña (permite
  mayor nivel de sangrado)y una sangría grande (más fácil de leer).
  Los tabuladores introducen confusión y es mejor dejarlos de lado.

* Recortar las líneas para que no superen los 79 caracteres.

  Esto ayuda a los usuarios con pantallas pequeñas y hace posible
  tener varios archivos de código abiertos, uno al lado del otro, en
  pantallas grandes.

* Usar líneas en blanco para separar funciones y clases, y bloques
  grandes de código dentro de funciones.

* Cuando sea posible, poner comentarios en una sola línea.

* Usar "docstrings".

* Usar espacios alrededor de operadores y luego de las comas, pero no
  directamente dentro de paréntesis: "a = f(1, 2) + g(3, 4)".

* Name your classes and functions consistently; the convention is to
  use "UpperCamelCase" for classes and "lowercase_with_underscores"
  for functions and methods.  Always use "self" as the name for the
  first method argument (see Un primer vistazo a las clases for more
  on classes and methods).

* No uses codificaciones estrafalarias si esperas usar el código en
  entornos internacionales. El default de Python, UTF-8, o incluso
  ASCII plano funcionan bien en la mayoría de los casos.

* De la misma manera, no uses caracteres no-ASCII en los
  identificadores si hay incluso una pequeñísima chance de que gente
  que hable otro idioma tenga que leer o mantener el código.

-[ Notas al pie ]-

[1] En realidad, *llamadas por referencia de objeto* sería una mejor
    descripción, ya que si se pasa un objeto mutable, quien realiza la
    llamada verá cualquier cambio que se realice sobre el mismo (por
    ejemplo ítems insertados en una lista).
