En esta clase haremos una rápida introducción al lenguaje Python y al intérprete IPython, así como a su Notebook. Veremos como ejecutar un script y cuáles son los tipos y estructuras básicas de este lenguaje. Seguro que ya has oído hablar mucho sobre las bondades de Python frente a otros lenguajes. Si no es así, échale un vistazo a esto. ¿Estás preparado? ¡Pues Empezamos!
In [1]:
import this
Vamos a ver mi_primer_script.py que está en la carpeta static. De momento no te preocupes por el código, ya habrá tiempo para eso...
In [2]:
!cat static/mi_primer_script.py
In [3]:
%run static/mi_primer_script.py
El método más simple es usar un editor (tu preferido) y ejecutar el script desde la línea de comandos. Pero existen también IDEs (integrated development environment pensados para facilitar la escritura de código y tener al alcance de la mano otras herramientas como profilers, debuggers, explorador de variables... Entre los más adecuados para la programación científica se encuentran IEP y Spyder (instalado con Anaconda).
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.
Será nuestra herramienta de trabajo durante el curso. 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 Jupyter, 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 Jupyter propiamente dicha donde ya podemos empezar a trabajar. Es similar a un intérprete, pero está dividida en celdas. Las celdas pueden contener, código, texto, imágenes...
Cada celda de código 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.
Si en la barra superior seleccionas Markdown (o usas el atajo Shift-M) en lugar de Code puedes escribir texto:
In [4]:
from IPython.display import Image
Image(url="static/markdown_cell.gif")
# Fuente Practical Numerical Methods with Python
# http://openedx.seas.gwu.edu/courses/GW/MAE6286/2014_fall/about
Out[4]:
También ecuaciones en latex y mucho más. Esto es una herramienta muy potente para explicar a alguien o a ti mismo lo que tu código hace, para hacer un informe, un trabajo, escribir en un blog...
Markdown es un lenguaje aparte, no te preocupes por él demasiado ahora, irás aprendiendo sobre la marcha... Para cuando lo vayas necesitando, aquí tienes una chuleta.
In [5]:
Image(url="static/markdown_math.gif")
# Fuente Practical Numerical Methods with Python
# http://openedx.seas.gwu.edu/courses/GW/MAE6286/2014_fall/about
Out[5]:
Puedes mover las celdas de un lugar a otro de este modo:
In [6]:
Image(url="static/cell_move.gif")
# Fuente: Practical Numerical Methods with Python
# http://openedx.seas.gwu.edu/courses/GW/MAE6286/2014_fall/about
Out[6]:
El Notebook tiene además numerosos atajos que irás aprendiendo sobre la marcha, puedes consultarlos en Help > Keyboard Shortcourts
Python dispone de los tipos numéricos y las operaciones más habituales:
In [7]:
2 * 4 - (7 - 1) / 3 + 1.0
Out[7]:
Las divisiones por cero lanzan un error:
In [8]:
1 / 0
In [ ]:
1.0 / 0.0
La división entre enteros en Python 3 devuelve un número real, al contrario que en Python 2.
In [9]:
3 / 2
Out[9]:
Se puede forzar que la división sea entera con el operador //:
In [10]:
3 // 2
Out[10]:
Se puede elevar un número a otro con el operador **:
In [11]:
2 ** 16
Out[11]:
Otro tipo que nos resultará muy útil son los complejos:
In [12]:
2 + 3j
Out[12]:
In [13]:
1j
Out[13]:
In [14]:
# Valor absoluto
abs(2 + 3j)
Out[14]:
In [15]:
abs(_13)
Podemos convertir variables a int, float, complex, str...
In [16]:
int(18.6)
Out[16]:
In [17]:
round(18.6)
Out[17]:
In [18]:
float(1)
Out[18]:
In [19]:
complex(2)
Out[19]:
In [20]:
str(256568)
Out[20]:
Podemos comprobar el tipo de una variable:
In [21]:
a = 2.
type(a)
Out[21]:
In [22]:
isinstance(a, float)
Out[22]:
Otras funciones útiles son:
In [23]:
print('hola mundo')
In [24]:
max(1,5,8,7)
Out[24]:
In [25]:
min(-1,1,0)
Out[25]:
¡Acabas de utilizar funciones! Como ves es una manera bastante estándar: 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.
print es la que se usa para imprimir resultados por pantalla. Por si lo ves en algún sitio, en Python 2 era una sentencia y funcionaba de manera distinta, sin paréntesis y sin posibilidad de pasar argumentos adicionales.La asignación se realiza con el operador =. Los nombres de las variables en Python pueden contener caracteres alfanuméricos (empezando con una letra) a-z, A-Z, 0-9 y otros símbolos como la _.
Por cuestiones de estilo, las variables suelen empezar con minúscula, reservando la mayúcula para clases.
Algunos nombres no pueden ser usados porque son usados por python:
and, as, assert, break, class, continue, def, del, elif, else, except, exec, finally, for, from, global, if, import, in, is, lambda, not, or, pass, print, raise, return, try, while, with, yield
In [26]:
a = 1 + 2j
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 [27]:
b = 3.14159
b
Out[27]:
En una celda podemos escribir código que ocupe varias líneas. Si la última de ellas devuelve un resultado, este se imprimirá.
In [28]:
x, y = 1, 2
x, y
Out[28]:
In [29]:
x, y = y, x
x, y
Out[29]:
Los operadores de comparación son:
== igual a!= distinto de < menor que<= menor o igual queDevolverán un booleano: True o False
In [30]:
x == y
Out[30]:
In [31]:
print(x != y)
In [32]:
print(x < y)
print(x <= y)
print(x > y)
print(x >= y)
In [33]:
# incluso:
x = 5.
6. < x < 8.
Out[33]:
Si la ordenación no tiene sentido nos devolverá un error:
In [34]:
1 + 1j < 0 + 1j
In [35]:
# En las cadenas de texto sí existe un orden
'aaab' > 'ba'
Out[35]:
In [36]:
True and False
Out[36]:
In [37]:
not False
Out[37]:
In [38]:
True or False
Out[38]:
In [39]:
# Una curiosidad:
(True + True) * 10
Out[39]:
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 [40]:
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:
In [41]:
tupla_sin_parentesis = 2,5,6,9,7
type(tupla_sin_parentesis)
Out[41]:
En los dos tipos podemos:
in:
In [42]:
2 in una_lista
Out[42]:
In [43]:
2 in una_tupla
Out[43]:
len:
In [44]:
len(una_lista)
Out[44]:
[<inicio>:<final>:<salto>]:
In [45]:
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
Veremos más cosas acerca de indexación en NumPy, así que de momento no te preocupes. Sólo recuerda una cosa:
Podemos complicarlo un poco más y hacer cosas como una lista de listas:
In [46]:
mis_asignaturas = [
['Álgebra', 'Cálculo', 'Física'],
['Mecánica', 'Termodinámica'],
['Sólidos', 'Electrónica']
]
mis_asignaturas
Out[46]:
Esto nos será de gran ayuda en el futuro para construir arrays.
if <condition>:
<do something>
elif <condition>:
<do other thing>
else:
<do other thing>
In [47]:
print(x,y)
if x > y:
print("x es mayor que y")
print("x sigue siendo mayor que y")
In [48]:
if 1 < 0:
print("1 es menor que 0")
print("1 sigue siendo menor que 0") # <-- ¡Mal!
In [49]:
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:
In [50]:
print(x,y)
if x > y:
print("x es mayor que y")
else:
print("x es menor que y")
In [51]:
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")
En Python existen dos tipos de estructuras de control típicas:
whileforLos bucles while repetiran las sentencias anidadas en él mientras se cumpla una condición:
while <condition>:
<things to do>
Como en el caso de los condicionales, los bloques se separan por indentación sin necesidad de sentencias del tipo end
In [52]:
ii = -2
while ii < 5:
print(ii)
ii += 1
Se puede interrumpir el bucle a la mitad con la sentencia break:
In [53]:
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 [54]:
ii = 0
while ii < 5:
print(ii)
ii += 1
if ii == 3:
break
else:
print("El bucle ha terminado")
In [55]:
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 que puede resultar chocante al principio. La idea es recorrer un conjunto de elementos:
for <element> in <iterable_object>:
<do whatever...>
In [56]:
for ii in (1,2,3,4,5):
print(ii)
In [57]:
for nombre in "Juan", "Luis", "Carlos":
print(nombre)
In [58]:
for ii in range(3):
print(ii)
In [59]:
for jj in range(2, 5):
print(jj)
La guía de estilo:
(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:
Hemos visto como la sintaxis de Python nos facilita escribir código legible así como aprendido algunas buenas prácticas al programar. Características como el tipado dinámico (no hace falta declarar variables) y ser lenguaje interpretado (no hace falta compilarlo) hacen que el tiempo que pasamos escrbiendo código sea menos que en otro tipo de lenguajes.
Se han presentado los tipos de variables, así como las estructuras de control básicas. En la siguiente clase practicaremos con algunos ejercicios para que te familiarices con ellas
Esperamos también que poco a poco te sientas cada vez más a gusto con el Notebook de IPython y puedas sacarle todo el partido
Referencias
Las siguientes celdas contienen configuración del Notebook
Para visualizar y utlizar los enlaces a Twitter el notebook debe ejecutarse como seguro
![](#<img-src="static/linkedin.png"-alt="AeroPython"-style="width:-25px"-align="right";/>-Curso-impartido-por:-Juan-Luis-Cano){kind=link}
File > Trusted Notebook
In [60]:
%%html
<a href="https://twitter.com/Pybonacci" class="twitter-follow-button" data-show-count="false">Follow @Pybonacci</a>
<script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script>
In [61]:
# Esta celda da el estilo al notebook
from IPython.core.display import HTML
css_file = 'static/styles/style.css'
HTML(open(css_file, "r").read())
Out[61]: