Parte 1 - Introducción a Python

¿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

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

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



In [1]:

    
3 / 2









    Out[1]:





1

Para convertir entre tipos numéricos podemos usar las funciones int yfloat :



In [11]:









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









    Out[13]:





4



In [14]:

    
float(_)









    Out[14]:





4.0

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. La mejor manera de visualizar la variable que acabamos de asignar es esta:



In [19]:

    
a = 1 + 2j
a









    Out[19]:





(1+2j)

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 [3]:

    
x, y = 1, 2
x, y









    Out[3]:





(1, 2)



In [23]:

    
print(x == y)









    



False



In [24]:

    
print(x != y)









    



True



In [4]:

    
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 es una sentencia y funciona sin paréntesis y sin posibilidad de pasar argumentos adicionales. En Python 3 es una función. Aunque se use Python 2, es recomendable usar la sintáxis de Python 3

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

Estructuras de datos fundamentales de Python

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.

Más estructuras de datos: Diccionarios

Son otro tipo de contenedor, al igual que las listas, pero en lugar de estar indexados por un número como el 0 o el 1, están indexados por una clave (key) que puede ser casi cualquier cosa. Para definirlos los diccionarios usan llaves ("{}"), en lugar de los corchetes ("[]") o paréntesis ("()") que usan listas y tuplas.

{"Python": "An awesome programming language", "Monty Python": "A british comedy troupe"}

En los diccionarios la clave va primero, seguida por dos puntos (":") y el valor. Si queremos poner más claves:valor sólo hay que separarlos por comas (",").



In [ ]:

    
{"Python": "An awesome programming language", 
 "Monty Python": "A british comedy troupe"}

Podemos asignar un diccionario a una varibale e indexarla por sus claves para obtener los valores.



In [ ]:

    
our_dictionary = {
   "Python": "An awesome programming language", 
   "Monty Python": "A british comedy troupe"
}
our_dictionary["Python"]

También se puede iterar por las claves en un diccionario para obtener una lista de todas las definiciones:



In [ ]:

    
for key in our_dictionary:
    print('The Key is "{0}" and the value is  "{1}"'.format(key, our_dictionary[key]))

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 indentación. Lo más estándar y, además recomendado, es usar 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 indentación superior se considera dentro del condicional. En cuanto escribimos la primera línea con un nivel de indentación 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 la indentación. En Python hay dos tipos de bucles: while y for.



In [37]:

    
ii = 0
while ii < 5:
    print(ii)
    ii += 1

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

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



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 i in 1, 2, 4:
    print(i)



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 i in range(3):
    print(i)



In [5]:

    
for j in range(2, 15,3):
    print(j)

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 indentación 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)

Referencias

Tutorial de Python oficial actualizado y traducido al español http://docs.python.org.ar/tutorial/
Vídeo de 5 minutos de IPython http://youtu.be/C0D9KQdigGk
Introducción a la programación con Python, Universitat Jaume I http://www.uji.es/bin/publ/edicions/ippython.pdf
PEP8 http://www.python.org/dev/peps/pep-0008/‎