La Sentencia :keyword:`if`

La Sentencia :keyword:`if`
===============

Tal vez el tipo más conocido de sentencias sea la sentencia :keyword:`if`. Por ejemplo:

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

Puede haber cero o más bloques :keyword:`elif`, y el bloque :keyword:`else` es opcional. La palabra reservada ':keyword:`elif`' es una abreviación de 'else if', y es útil para evitar identación excesiva. Una sequencia :keyword:`if` ... :keyword:`elif` ... :keyword:`elif` ... sustituye las sentencias switch o case encontradas en otros lenguajes.

La Sentencia :keyword:`for`

La Sentencia :keyword:`for`
================

.. index::
   statement: for
   statement: for

La sentencia :keyword:`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 y condición de fin (como en C), la sentencia :keyword:`for` de Python itera sobre los items de cualquier sequencia (una lista o una cadena de texto), en el orden que aparcen en la secuencia. Por ejemplo (no pun intended):

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

No es seguro modificar la secuencia sobre la que se está iterando en el loop (esto solo es posible para tipos de secuencias mutables, como las listas). Si se necesita modificar la lista sobre la que se está iterando (por ejemplo, para duplicar items seleccionados) se debe iterar sobre una copia. La notación de rebanada es conveniente para esto:

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

La Función :func:`range`

La Función :func:`range`
==============

Si se necesita iterar sobre una secuencia de números, es apropiado utilizar la función incorporada :func:`range`. Genera una lista conteniendo progresiones aritméticas:

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

El valor final dado nunca esparte de la lista; range(10) genera una lista de 10 valores, los índices correspondientes para los items de una secuencia de longitud 10. Es posible hacer que el rango empiece con otro número, o especificar un incremento diferente (incluso negativos; 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, se combina :func:`range` y :func:`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

Las Sentencias :keyword:`break` y :keyword:`continue`, y la Clausula :keyword:`else` en Loops

Las Sentencias :keyword:`break` y :keyword:`continue`, y la Clausula :keyword:`else` en Loops
=========================================================================================

La sentencia :keyword:`break`, como en C, termina el loop :keyword:`for` o :keyword:`while` más anidado.

La sentencia :keyword:`continue`, también tomada prestada de C, continua con la próxima iteración del loop.

Las setencias de loop pueden tener una clausula else; es ejecutada cuando el loop termina luego de agotar la lista (con :keyword:`for`) o cuando la condición se hace falsa (con :keyword:`while`), pero no cuando el loop es terminado con la sentencia :keyword:`break`. Se ejemplifica en el siguiente loop, 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

La Sentencia :keyword:`pass`

La Sentencia :keyword:`pass`
==================

La sentencia :keyword:`pass` no hace nada. Se puede usar cuando una sentencia es requerida por la sintáxis pero el programa no requiere ninguna acción. Por ejemplo:

>>> while True:
...       pass # Busy-wait for keyboard interrupt
...

Definiendo funciones

Definiendo funciones
=============

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

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

.. index::
   single: documentation strings
   single: docstrings
   single: strings, documentation

La palabra reservada :keyword:`def` de una 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 linea siguiente, y deben estar identadas. La primer sentencia del cuerpo de la función puede ser opcionalmente una cadena de texto litaral; esta es la cadena de texto de documentación de la función, o :dfn:`docstring`.

Hay herramientas que usan las docstrings para producir automáticamente documentación en líne o imprimible, o para permitirle al usuario que navegue el código en forma interactiva; es una buena práctica incluir docstrings enel código que uno escriba, así que se debe intentar hacer un hábito de esto.

La ejecución de una función introduce una nueva tabla de símbolos usada para las variables locales de la función. Más precisamente, todas las asignaciones de variables en la función almacenan el valor en la tabla de símbolos local; así mismo la referencia a variables primero mira la tabla de símbolos local, luego en la tabla de símbolos local de las funciones externas, luego la tabla de sínbolos global, y finalmente la tabla de nombres predefinidos. Así, no se les puede asignar directamente un valor a las variables globales dentro de una función (a menos se las nombre en la sentencia :keyword:`global`), aunque si pueden ser referenciadas.

Los parámetros reales (arguementos) de una función se introducen en la tabla de símbolos local de la función llamada cuando esta es llamada; 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 ocmo una función. Esto sirve como un mecanismo general para renombrar:

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

Se puede objetar que fib no es una función, sino un procedimiento. En Python, como en C, los procedimientos son solo funciones que no retornan un valor. De hecho, tecnicamente hablando, los procedimientos si retornan un valor, aunque uno aburrido. Este valor es llamada 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 :keyword:`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 b < n:
...         result.append(b)    # see below
...         a, b = b, a+b
...     return result
...
>>> f100 = fib2(100)    # call it
>>> f100                # write the result
[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 :keyword:`return` devuelve un valor en una función. :keyword:`return` sin una expresión como argumento retorna None. Si se alcanza el final de un procedimiento, también se retorna None.

  System Message: ERROR/3 (<string>, line 262); backlink

  Unknown interpreted text role "keyword".

  System Message: ERROR/3 (<string>, line 262); backlink

  Unknown interpreted text role "keyword".

• La sentencia result.append(b) llama al método del objeto lista result. Un método es una función que 'pertenece' a unobjeto 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 ambiguedad. (Es posible definir tipos de objetos propios, y métodos, usando clases, como se discutirá más adelante en el tutorial). El método :meth:`append` mostrado en el ejemplo está definidio para objetos lista; añade un nuevo elemento al final de la lista. En este ejemplo es equivalente a adds a new element at the end of the list. In this example it is equivalent to result = result + [b], pero más eficiente.

  System Message: ERROR/3 (<string>, line 266); backlink

  Unknown interpreted text role "meth".

Más sobre Definición de Funciones

Más sobre Definición de Funciones
==========================

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

def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
    while True:
        ok = raw_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 IOError, 'refusenik user'
        print complaint

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

def f(a, L=[]):
    L.append(a)
    return L
print f(1)
print f(2)
print f(3)

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

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

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

parrot(1000)
parrot(action = 'VOOOOOM', voltage = 1000000)
parrot('a thousand', state = 'pushing up the daisies')
parrot('a million', 'bereft of life', 'jump')

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

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

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
    keys = keywords.keys()
    keys.sort()
    for kw in keys: print kw, ':', keywords[kw]

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

-- 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.
----------------------------------------
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch

.. index::
  statement: *

def fprintf(file, template, *args):
    file.write(template.format(args))

.. index::
  statement: **

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

.. index::
   single: docstrings
   single: documentation strings
   single: strings, documentation

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

Intermezzo: Coding Style

.. sectionauthor:: Georg Brandl <georg@python.org>

.. index:: pair: coding; style

Now that you are about to write longer, more complex pieces of Python, it is a good time to talk about coding style. Most languages can be written (or more concise, formatted) in different styles; some are more readable than others. Making it easy for others to read your code is always a good idea, and adopting a nice coding style helps tremendously for that.

For Python, PEP 8 has emerged as the style guide that most projects adhere to; it promotes a very readable and eye-pleasing coding style. Every Python developer should read it at some point; here are the most important points extracted for you:

• Use 4-space indentation, and no tabs.

  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.

• Wrap lines so that they don't exceed 79 characters.

  This helps users with small displays and makes it possible to have several code files side-by-side on larger displays.

• Use blank lines to separate functions and classes, and larger blocks of code inside functions.

• When possible, put comments on a line of their own.

• Use docstrings.

• Use spaces around operators and after commas, but not directly inside bracketing constructs: 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.

• Don't use fancy encodings if your code is meant to be used in international environments. Plain ASCII works best in any case.

Footnotes