import this
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.
Naturalmente disponemos de los tipos numéricos y las operaciones habituales:
2 * 4 - (7 - 1) / 3 + 1.0
Las divisiones por cero lanzan un error:
1 / 0
1.0 / 0.0
La división entre enteros en Python 3 devuelve un número real, al contrario que en Python 2.
3 / 2
Para forzar la división entera, podemos usar el operador //:
3 // 2
Además, Python incluye también números complejos:
2 + 3j
(3 + 2j) * (1 - 1j)
(1j) ** 2
Para hallar el valor absoluto:
abs(3 + 2j)
Para convertir entre tipos numéricos podemos usar las funciones int, float y complex:
_10
int(_)
Al convertir a int descartamos la parte entera. Si en realidad queremos redondear:
round(_10)
float(_)
complex(_)
Otras funciones útiles:
max(0, -1, 1, 2)
min(1, 2, 0, -1)
La asignación en Python funciona con el operador =
a = 1 + 2j
a = 1 + 2j
a
Podemos encadenar varias asignaciones:
x, y = 1, 2
x, y
x, y = y, x
x, y
Los operadores de comparación son ==, !=, <, <=, >, >=.
x, y = 1, 2
x, y
print(x == y)
print(x != y)
print(x < y)
print(x <= y)
print(x > y)
print(x >= y)
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:
1 + 1j < 0 + 1j
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.
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)
Para las tuplas, podemos incluso obviar los paréntesis:
1, 2, 3.0
Los dos tipos tienen varias cosas en común. En particular:
in:2 in una_tupla
len:len(una_lista)
[<inicio>:<final>:<salto>]: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
Fíjate en dos detalles:
[-1] da el último elemento, [-2] el penúltimo y así sucesivamente.[::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.
a = [
[1, 2, 3],
[4, 5],
]
print(a)
print(a[0])
print(a[0][0])
Esto nos será de gran ayuda en el futuro para construir arrays.
En Python, los condicionales siguen esta estructura:
print(x, y)
if x < y:
print("x es menor que y")
print("x sigue siendo menor que y")
if 1 < 0:
print("1 es menor que 0")
print("1 sigue siendo menor que 0") # <-- ¡Mal!
if 1 < 0:
print("1 es menor que 0")
print("1 sigue siendo menor que 0")
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:
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")
Los bucles también se demarcan con el sangrado. En Python hay dos tipos de bucles: while y for.
ii = 0
while ii < 5:
print(ii)
ii += 1
Podemos interrumpir el bucle a la mitad usando la sentencia break:
ii = 0
while ii < 5:
print(ii)
ii += 1
if ii == 3:
break
Un bloque else justo después del bucle se ejecuta si este no ha sido interrumpido por nosotros:
ii = 0
while ii < 5:
print(ii)
ii += 1
if ii == 3:
break
else:
print("El bucle ha terminado")
ii = 0
while ii < 5:
print(ii)
ii += 1
#if ii == 3:
#break
else:
print("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:
for ii in 1, 2, 4:
print(ii)
for nombre in "Juan", "Luis", "Carlos":
print(nombre)
Una cosa que haremos de manera recurrente será recorrer un rango de números. Esto lo conseguimos con la función range:
for ii in range(3):
print(ii)
for jj in range(2, 5):
print(jj)
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.
def funcion(x, y):
"""Función de prueba."""
pass
funcion
funcion.__doc__
Los valores de retorno de la función se especifican con la sentencia return. Por ejemplo:
def al_cuadrado(x):
"""Función que eleva un número al cuadrado."""
y = x ** 2
return y
al_cuadrado(4)
def multiplica(x, y=2.0):
"""Multiplica dos números, por defecto el primero por 2."""
return x * y
multiplica(2, 3)
multiplica(4)
multiplica(x, y=1.0)
(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:
%load_ext pep8magic
%%pep8
if 6*9==42:print("Something fundamentally wrong..." )
%%pep8
if 6*9 == 42:
print("Something fundamentally wrong...")