Parte 1 - Introducción a Python e IPython

¿Qué es Python?

  • Lenguaje de programación dinámico, interpretado y fácil de aprender
  • Creado por Guido van Rossum en 1991
  • Ampliamente utilizado en ciencia e ingeniería
  • Multitud de bibliotecas

El zen de Python

In [1]:
import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Contacto con el notebook de IPython

Durante este curso utilizaremos el notebook de IPython para trabajar. IPython no es más que un intérprete de Python con algunas mejoras sustanciales, pero además su interfaz notebook es más cómoda de manejar que la línea de comandos y nos da un poco más de flexibilidad.

Esto que estás leyendo ahora no es más que un notebook de IPython, que como diremos luego además de código puede contener texto e imágenes. Pero veamos primero cómo funciona.

Al iniciar el notebook de IPython, en la pantalla principal podemos ver una ruta y una lista de notebooks. Cada notebook es un archivo que está almacenado en el ordenador en la ruta que aparece. Si en esa carpeta no hay notebooks, veremos un mensaje indicando que la lista de notebooks está vacía.

Al crear un notebook o al abrir uno nuevo se abre la interfaz de IPython propiamente dicha donde ya podemos empezar a trabajar. Es similar a un intérprete, pero está dividida en celdas. Cada celda está marcada por la palabra In [<n>] y están numeradas. Tan solo tenemos que escribir el código en ella y hacer click arriba en Cell -> Run, el triángulo ("Run cell") o usar el atajo shift + Enter. El resultado de la celda se muestra en el campo Out [<n>], también numerado y coincidiendo con la celda que acabamos de ejecutar. Esto es importante, como ya veremos luego.

Vamos ahora a hacer una introducción muy rápida a la sintaxis de Python, y a medida que avancemos iremos describiendo más características de IPython que nos pueden resultar útiles.

Introducción a la sintaxis de Python

Tipos numéricos

Naturalmente disponemos de los tipos numéricos y las operaciones habituales:

In [2]:
2 * 4 - (7 - 1) / 3 + 1.0
Out[2]:
7.0

Las divisiones por cero lanzan un error:

In [3]:
1 / 0
---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
<ipython-input-3-b710d87c980c> in <module>()
----> 1 1 / 0

ZeroDivisionError: division by zero
In [4]:
1.0 / 0.0
---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
<ipython-input-4-42176c28e89e> in <module>()
----> 1 1.0 / 0.0

ZeroDivisionError: float division by zero
Más adelante veremos cómo tratar estos errores. Por otro lado, cuando usemos NumPy esta operación devolverá `NaN`.

La división entre enteros en Python 3 devuelve un número real, al contrario que en Python 2.

In [5]:
3 / 2
Out[5]:
1.5

Para forzar la división entera, podemos usar el operador //:

In [6]:
3 // 2
Out[6]:
1

Además, Python incluye también números complejos:

In [7]:
2 + 3j
Out[7]:
(2+3j)
In [8]:
(3 + 2j) * (1 - 1j)
Out[8]:
(5-1j)
In [9]:
(1j) ** 2
Out[9]:
(-1+0j)

Para hallar el valor absoluto:

In [10]:
abs(3 + 2j)
Out[10]:
3.605551275463989
Tip de IPython: podemos recuperar resultados pasados usando `_`. Por ejemplo, para recuperar el resultado correspondiente a `Out [7]`, usaríamos `_7`. Esta variable guarda ese valor para toda la sesión.

Para convertir entre tipos numéricos podemos usar las funciones int, float y complex:

In [11]:
_10
Out[11]:
3.605551275463989
In [12]:
int(_)
Out[12]:
3

Al convertir a int descartamos la parte entera. Si en realidad queremos redondear:

In [13]:
round(_10)
Out[13]:
4
In [14]:
float(_)
Out[14]:
4.0
In [15]:
complex(_)
Out[15]:
(4+0j)

Otras funciones útiles:

In [16]:
max(0, -1, 1, 2)
Out[16]:
2
In [17]:
min(1, 2, 0, -1)
Out[17]:
-1
Nota: Esta es la manera de llamar funciones en Python: los argumentos se encierran entre paréntesis y se separan por comas. Se hace de esta manera en otros lenguajes de programación y no requiere mayor explicación, de momento.

Asignación y operadores de comparación

La asignación en Python funciona con el operador =

In [18]:
a = 1 + 2j
Nota: En Python la asignación no imprime el resultado por pantalla, al contrario de como sucede en MATLAB y Octave (salvo que se incluya el punto y coma al final). La mejor manera de visualizar la variable que acabamos de asignar es esta:
In [19]:
a = 1 + 2j
a
Out[19]:
(1+2j)
Tip de IPython: En una celda podemos escribir código que ocupe varias líneas. Si la última de ellas devuelve un resultado, este se imprimirá.

Podemos encadenar varias asignaciones:

In [20]:
x, y = 1, 2
x, y
Out[20]:
(1, 2)
Podemos realizar **asignación múltiple**, que hemos hecho en la celda anterior con las variables `x` e `y` para intercambiar valores de manera intuitiva:
In [21]:
x, y = y, x
x, y
Out[21]:
(2, 1)

Los operadores de comparación son ==, !=, <, <=, >, >=.

In [22]:
x, y = 1, 2
x, y
Out[22]:
(1, 2)
In [23]:
print(x == y)
False
In [24]:
print(x != y)
True
In [25]:
print(x < y)
print(x <= y)
print(x > y)
print(x >= y)
True
True
False
False
La función print es la que se usa para imprimir resultados por pantalla. En Python 2 era una sentencia y funcionaba de manera distinta, sin paréntesis y sin posibilidad de pasar argumentos adicionales.

Si la ordenación no tiene sentido, obtenemos un error:

In [26]:
1 + 1j < 0 + 1j
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-26-9a32b6a036ce> in <module>()
----> 1 1 + 1j < 0 + 1j

TypeError: unorderable types: complex() < complex()

Otros tipos de datos

Otro tipo de datos muy importante que vamos a usar son las secuencias: las tuplas y las listas. Ambos son conjuntos ordenados de elementos: las tuplas se demarcan con paréntesis y las listas con corchetes.

In [27]:
una_lista = [1, 2, 3.0, 4 + 0j, "5"]
una_tupla = (1, 2, 3.0, 4 + 0j, "5")
print(una_lista)
print(una_tupla)
print(una_lista == una_tupla)
[1, 2, 3.0, (4+0j), '5']
(1, 2, 3.0, (4+0j), '5')
False

Para las tuplas, podemos incluso obviar los paréntesis:

In [28]:
1, 2, 3.0
Out[28]:
(1, 2, 3.0)

Los dos tipos tienen varias cosas en común. En particular:

  • Podemos comprobar si un elemento está en la secuencia con el operador in:
In [29]:
2 in una_tupla
Out[29]:
True
  • Podemos saber cuántos elementos tiene la secuencia con la función len:
In [30]:
len(una_lista)
Out[30]:
5
  • Podemos indexar las secuencias, utilizando la sintaxis [<inicio>:<final>:<salto>]:
In [31]:
print(una_lista[0])  # Primer elemento, 1
print(una_tupla[1])  # Segundo elemento, 2
print(una_lista[0:2])  # Desde el primero hasta el tercero, excluyendo este: 1, 2
print(una_tupla[:3])  # Desde el primero hasta el cuarto, excluyendo este: 1, 2, 3.0
print(una_lista[-1])  # El último: 4 + 0j
print(una_tupla[:])  # Desde el primero hasta el último
print(una_lista[::2])  # Desde el primero hasta el último, saltando 2: 1, 3.0
1
2
[1, 2]
(1, 2, 3.0)
5
(1, 2, 3.0, (4+0j), '5')
[1, 3.0, '5']
Nota: ¡En Python la indexación empieza por cero!

Fíjate en dos detalles:

  • Cuando especificamos índices negativos, recorremos el array desde el final hasta el principio. Por eso [-1] da el último elemento, [-2] el penúltimo y así sucesivamente.
  • Hemos utilizado la notación [::2] para el último caso. Esto es una manera abreviada de escribir [0:-1:2], es decir, si no decimos nada empezamos en el principio y terminamos en el final. Por eso [:] devuelve todos los elementos de la secuencia.

Naturalmente, las sequencias se pueden anidar: por ejemplo, una lista puede contener, a su vez, más listas.

In [32]:
a = [
 [1, 2, 3],
 [4, 5],
]
print(a)
print(a[0])
print(a[0][0])
[[1, 2, 3], [4, 5]]
[1, 2, 3]
1

Esto nos será de gran ayuda en el futuro para construir arrays.


Estructuras de control (I): condicionales

En Python, los condicionales siguen esta estructura:

In [33]:
print(x, y)
if x < y:
    print("x es menor que y")
    print("x sigue siendo menor que y")
1 2
x es menor que y
x sigue siendo menor que y
Importante: En Python los bloques se delimitan por sangrado, utilizando siempre cuatro espacios. Cuando ponemos los dos puntos al final de la primera línea del condicional, todo lo que vaya a continuación con *un* nivel de sangrado superior se considera dentro del condicional. En cuanto escribimos la primera línea con un nivel de sangrado inferior, hemos cerrado el condicional. Si no seguimos esto a rajatabla Python nos dará errores; es una forma de forzar a que el código sea legible.
In [34]:
if 1 < 0:
    print("1 es menor que 0")
print("1 sigue siendo menor que 0")  # <-- ¡Mal!
1 sigue siendo menor que 0
In [35]:
if 1 < 0:
    print("1 es menor que 0")
     print("1 sigue siendo menor que 0")
  File "<ipython-input-35-89ceea330d08>", line 3
    print("1 sigue siendo menor que 0")
    ^
IndentationError: unexpected indent

Si queremos añadir ramas adicionales al condicional, podemos emplear la sentencia elif (abreviatura de else if). Para la parte final, que debe ejecutarse si ninguna de las condiciones anteriores se ha cumplido, usamos la sentencia else:

In [36]:
print(x, y)
if x < y:
    print("x es menor que y")
elif x == y:
    print("x es igual a y")
else:
    print("x no es ni menor ni igual que y")
1 2
x es menor que y

Estructuras de control (II): bucles

Los bucles también se demarcan con el sangrado. En Python hay dos tipos de bucles: while y for.

In [37]:
ii = 0
while ii < 5:
    print(ii)
    ii += 1
0
1
2
3
4

Podemos interrumpir el bucle a la mitad usando la sentencia break:

In [38]:
ii = 0
while ii < 5:
    print(ii)
    ii += 1
    if ii == 3:
        break
0
1
2

Un bloque else justo después del bucle se ejecuta si este no ha sido interrumpido por nosotros:

In [39]:
ii = 0
while ii < 5:
    print(ii)
    ii += 1
    if ii == 3:
        break
else:
    print("El bucle ha terminado")
0
1
2
In [40]:
ii = 0
while ii < 5:
    print(ii)
    ii += 1
    #if ii == 3:
        #break
else:
    print("El bucle ha terminado")
0
1
2
3
4
El bucle ha terminado

El otro bucle en Python es el bucle for, y funciona de manera un poco peculiar. La idea es recorrer un conjunto de elementos:

In [41]:
for ii in 1, 2, 4:
    print(ii)
1
2
4
In [42]:
for nombre in "Juan", "Luis", "Carlos":
    print(nombre)
Juan
Luis
Carlos

Una cosa que haremos de manera recurrente será recorrer un rango de números. Esto lo conseguimos con la función range:

In [43]:
for ii in range(3):
    print(ii)
0
1
2
In [44]:
for jj in range(2, 5):
    print(jj)
2
3
4

Definición de funciones

Para definir nuestra propia función utilizamos la sentencia def seguida del nombre de la misma y entre paréntesis los argumentos de entrada. La primera línea de la función puede ser una cadena de documentación.

In [45]:
def funcion(x, y):
    """Función de prueba."""
    pass
In [46]:
funcion
Out[46]:
<function __main__.funcion>
In [47]:
funcion.__doc__
Out[47]:
'Función de prueba.'

Los valores de retorno de la función se especifican con la sentencia return. Por ejemplo:

In [48]:
def al_cuadrado(x):
    """Función que eleva un número al cuadrado."""
    y = x ** 2
    return y
In [49]:
al_cuadrado(4)
Out[49]:
16
In [50]:
def multiplica(x, y=2.0):
    """Multiplica dos números, por defecto el primero por 2."""
    return x * y

multiplica(2, 3)
Out[50]:
6
In [51]:
multiplica(4)
Out[51]:
8.0
In [52]:
multiplica(x, y=1.0)
Out[52]:
1.0

PEP8, la guía de estilo

  • Usa sangrado de 4 espacios, no tabuladores [IPython o tu editor se encargan de ello].
  • Acota las líneas a 79 caracteres.
  • Usa líneas en blanco para separar funciones y bloques de código dentro de ellas.
  • Pon los comentarios en líneas aparte si es posible.
  • Usa cadenas de documentación (docstrings).
  • Pon espacios alrededor de los operadores y después de coma.
  • Usa la convención minuscula_con_guiones_bajos para los nombres de las funciones y las variables.
  • Aunque Python 3 te lo permite, no uses caracteres especiales para los identificadores.

(Traducido de http://docs.python.org/3/tutorial/controlflow.html#intermezzo-coding-style)

Utilizando el módulo pep8

https://pypi.python.org/pypi/pep8

Y la extensión pep8magic

https://gist.github.com/Juanlu001/9082229/

Podemos comprobar si una celda de código cumple con las reglas del PEP8:

In [53]:
%load_ext pep8magic
In [54]:
%%pep8
if 6*9==42:print("Something fundamentally wrong..."  )
stdin:1:7: E225 missing whitespace around operator
if 6*9==42:print("Something fundamentally wrong..."  )
      ^
stdin:1:11: E231 missing whitespace after ':'
if 6*9==42:print("Something fundamentally wrong..."  )
          ^
stdin:1:11: E701 multiple statements on one line (colon)
if 6*9==42:print("Something fundamentally wrong..."  )
          ^
stdin:1:53: E202 whitespace before ')'
if 6*9==42:print("Something fundamentally wrong..."  )
                                                    ^
In [55]:
%%pep8
if 6*9 == 42:
    print("Something fundamentally wrong...")
This code is PEP8-compliant!

Referencias