Python básico

Mis seguidores habituales ya saben por qué me gusta Python. Sin embargo, ya hay varias personas que me han comentado que no se leen algunos artículos míos porque están en Python, he decidido escribir un pequeño artículo introductorio.

No esperéis grandes explicaciones. Aquí va lo básico para aprenderlo en 15 minutos. Si queréis saber más, se tiene que dedicar mucho tiempo, y para ello hay mogollón de libros estupendos.

Veremos aquí las estructuras básicas y alguna plantilla para comenzar. También comentaré herramientas útiles para el desarrollo.

Un poquito de teoría

Python es un lenguaje interpretado. Eso significa que hay un programa que lee el código Python y lo va interpretando sobre la marcha. En Python tenemos varios intérpretes:

• python, que es el estándar. Aunque actualmente la versión más usada es la 2.7, se están esforzando en avanzar a la 3.3. El problema es la incompatibilidad hacia atrás de esta versión.
• ipython, que está genial para ejecutar pequeños trozos de código y aprender sobre la marcha. Recomiendo su uso para este artículo.
• bpython, similar a ipython, pero con otro estilo. Muestra ayuda gracias a ncurses

El intérprete python también puede usarse sin argumentos, de manera que podemos ejecutar cualquier comando a continuación:

1
2
3
4
5

$ python
Python 2.7.3 (default, Jan  2 2013, 16:53:07)
[GCC 4.7.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

En adelante se usarán la cadena “»>” para referirse a cada línea de órdenes, dado que es lo que muestra el intérprete python. Si estás usando ipython o bpython, el prompt será otro, pero los comandos seguirán siendo válidos.

Python básico

Indentación

La característica principal de Python es que los bloques se definen por su indentación. Se recomienda el uso de espacios frente a tabs.

Hay trucos para dividir líneas muy largas, como puede ser encerrar los valores entre paréntesis o concatenar strings sin ningún nexo de unión:

1
2
3
4
5
6

>>> a = ('primera parte'
...      'segunda parte')
>>> if condition:
...    this_is_the_main_execution_block()
... this_is_out_of_the_if()
>>>

Matemáticas básicas

Desde el intérprete podemos ejecutar matemáticas básicas:

1
2
3
4
5
6
7

>>> 2+2
4
>>> 20/8
2
>>> 20/8.
2.5
>>>

Y podemos importar módulos:

1
2
3
4

>>> import math
>>> math.sin(math.radians(90))
1.0
>>>

Existen módulos para matemáticas avanzadas: estadística y cálculos científicos.

Tipos de datos

En Python todo es un objeto. Los objetos más básicos son:

• object: es la clase básica. De ella deben heredar todas las demás.
• int: para enteros
• float: para números de coma flotante
• str: para cadenas
• tuple: para tuplas, o listas de tamaño fijo.
• list: para listas o arrays
• dict: para diccionarios o hashes.

Crear variables no tiene mayor misterio: se asigna un valor y listo:

1
2
3
4
5
6
7

>>> a = 8
>>> a
8
>>> a = 'hello'
>>> a
hello
>>>

Para crear un objeto basta con invocarlo, como si fuera una función:

1
2
3
4

>>> a = object()
>>> a
<object object at 0xb74e5688>
>>>

De esta manera podemos crear listas o diccionarios. Sin embargo, para las listas y los diccionarios hay atajos:

1
2
3
4
5
6
7
8
9

>>> list()
[]
>>> []
[]
>>> dict()
{}
>>> {}
{}
>>>

Una lista puede contener cualquier cosa. Para referenciarlos, basta indicar su posición, comenzando en 0:

1
2
3
4
5
6

>>> a = [1, 2, 'hello, world', [9], object()]
>>> a
[1, 2, 'hello, world', [9], <object object at 0xb74e5890>]
>>> a[2]
'hello, world'
>>>

Un diccionario debe contener claves y valores. Ambos pueden ser cualquier cosa. Para referenciarlos, basta indicar la key:

1
2
3
4
5
6

>>> a = {1:1, 2:'dos', 'whatever':5, object():object()}
>>> a
{1: 1, 2: 'dos', 'whatever': 5, <object object at 0xb74e5898>: <object object at 0xb74e5890>}
>>> a['whatever']
5
>>>

Las tuplas se crean englobando los elementos entre paréntesis. Debe existir más de un argumento o pondremos una coma suelta:

1
2
3
4
5
6
7
8
9

>>> a = (1,)
>>> a
(1,)
>>> type(a)
tuple
>>> b = (1, 5, [])
>>> b
(1, 5, [])
>>>

Condiciones

Hay dos tipos básicos de condiciones:

1
2
3
4
5
6
7

>>> condition = True
>>> if condition then print(True) else print(False)
True
>>> a = 5 if condition else 10
>>> a
5
>>>

Ni siquiera voy a explicar los operadores binarios, ya que creo que se explican por sí mismos:

1
2
3

>>> if condition1 and (condition2 or not condition3):
...    whatever()
>>>

Bucles

Hay varios tipos de bucles. Es importante saber que Python no tiene un bucle “for” como tal; realmente es un “foreach”, ya que recorre elementos. Por eso es necesario proporcionarle una lista de elementos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

>>> for i in range(5):
...   print(i)
...
1
2
3
4
5
>>> for i in (1, 3, 4):
...    print(i)
1
3
4
>>> cont = True
>>> while cont:
...    print 'hello'
...    cont = False
...
hello
>>>

Existe una forma rápida para crear listas o diccionarios recorriendo otros objetos y/o filtrándolos:

1
2
3
4
5
6

>>> a = [x for x in range(10) if x%3 == 0]
>>> a
[0, 3, 6, 9]
>>> b = {x:2*x for x in range(10) if x%3 == 0}
{0: 0, 3: 6, 6: 12, 9: 18}
>>>

También existe una forma rápida de crear listas, multiplicando los objetos:

1
2
3
4
5

>>> 'a' * 10
'aaaaaaaaaa'
>>> [0] * 10
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
>>>

Creando objetos

Al crear objetos hay que heredar de object:

1
2
3

class Example(object):
    def __init__(self):
        pass

En este ejemplo se crea la clase Example, que hereda de object. Ésta contiene un método constructor (__init__) que no hace nada.

Todos los métodos de un objeto deberán recibir como primer argumento self, que es el propio objeto.

Si queremos que el constructor llame al constructor del padre, lo correcto es:

1
2
3

class Example(object):
    def __init__(self):
        super(Example, self).__init__(self)

Argumentos

Los métodos pueden recibir dos tipos de argumentos: posicionales o nombrados. Veamos un ejemplo:

1
2
3
4
5
6
7
8

>>> def function(a, b, c=None):
...    print(a, b, c)
...
>>> function(3, 2, 1)
3 2 1
>>> function(c=3, b=2, a=1)
1 2 3
>>>

En el ejemplo se define una función function con tres argumentos (el último contiene un valor por defecto) y se la invoca de dos maneras diferentes. La primera utiliza argumentos posicionales y la segunda, nombrados. Estos modos se pueden combinar, pero los nombrados siempre irán después de los posicionales:

1
2
3

>>> function(1, c=3, b=2)
1 2 3
>>>

Podemos tener argumentos variables mediante un asterisco para los posicionales y dos para los nombrados:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

>>> def function(*args, **kwargs):
...    print('positional:', args)
...    print('named:', kwargs)
...
>>> function(3, 2, 1)
positional: (3 2 1)
named: {}
>>> function(1, c=3, b=2)
positional: (1,)
named: {'c': 3, 'b': 2}
>>>

Puede observarse que se están recogiendo los posicionales como una tupla y los nombrados como un diccionario. También podemos hacerlo a la inversa, transformando una tupla o un vector en argumentos posicionales y un diccionario en argumentos nombrados:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

>>> def function(*args, **kwargs):
...    print('positional:', args)
...    print('named:', kwargs)
...
>>> a = [1, 2, 3]
>>> b = {'b1': 'b'}
>>> function(*a, **b)
positional: (1, 2, 3)
named: {'b1': 'b'}
>>>

Excepciones

Como todo lenguaje moderno, tiene gestión de excepciones:

1
2
3
4
5
6
7
8
9

try:
   raise ValueError()
except ValueError as e:
    print e
except (NotImplemented, Exception):
    print 'ignored'
    pass
finally:
    print 'end'

Este ejemplo es muy estúpido pero bastante didáctico:

1. Se entra en la sección peligrosa, delimitada por try.
2. La sección peligrosa lanza una excepción de tipo ValueError
3. La excepción se captura mediante except y se muestra
4. A continuación se capturan dos excepciones juntas que mostrarán el mensaje de que se están ignorando. Evidentemente, con este código no se puede llegar nunca hasta aquí.
5. Ocurra lo que ocurra, se ejecutará el bloque del finally que indica la finalización.

Pase lo que pase se ejecutará el finally. Esto incluye:

• Finalización correcta sin lanzar excepciones.
• Lanzamiento de una excepción no capturada.
• Lanzamiento de una excepción capturada.

Plantilla

Y aquí tenéis una pequeña plantilla para programas básicos:

1
2
3
4
5

#!/usr/bin/env python
# -*- coding:utf-8; -*-

if __name__ == '__main__':
    whatever()

En esta plantilla se indica al sistema que es un programa Python, de manera que funcione en entornos virtuales como Virtualenv. Además, permite evitar la ejecución de código arbitrario cuando se está importando el archivo desde otro archivo python.

Aquí tenéis la plantilla básica para los tests, aunque sería mejor que leyérais cómo hacer pruebas en python:

1
2
3
4
5

import unittest

class ExampleTest(unittest.TestCase):
    def test_foo(self):
        self.fail("this test is failing")

Más información

El mejor sitio para obtener información básica de este lenguaje es en la propia documentación de Python.

También son interesantes los libros Dive into Python, de Mark Pilgrim. Es gratuíto y os lo podéis descargar de esa misma dirección. El libro Pro Python, de Marty Alchin puede ayudar también.