_ 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! _
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!
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...
!cat ../static/mi_primer_script.py
import math print("Hola gente del curso de AeroPython") print("¿Cuántos sois hoy en clase?") number = input() number = int(number) root = math.sqrt(number) print("Ufff! eso es un montón! espero que aprendáis mucho") print("Por cierto, la raiz de %i es %f" %(number, root))
%run ../static/mi_primer_script.py
Hola gente del curso de AeroPython ¿Cuántos sois hoy en clase? 45 Ufff! eso es un montón! espero que aprendáis mucho Por cierto, la raiz de 45 es 6.708204
Si quieres hacerlo desde una línea de comandos podrías hacer:
$ python3 ../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 __IDE__s (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](http://es.wikipedia.org/wiki/Int%C3%A9rprete_(inform%C3%A1tica) 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 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. 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:
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
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.
Image(url="../static/markdown_math.gif")
# Fuente Practical Numerical Methods with Python
# http://openedx.seas.gwu.edu/courses/GW/MAE6286/2014_fall/about
Puedes mover las celdas de un lugar a otro de este modo:
Image(url="../static/cell_move.gif")
# Fuente: Practical Numerical Methods with Python
# http://openedx.seas.gwu.edu/courses/GW/MAE6286/2014_fall/about
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:
2 * 4 - (7 - 1) / 3 + 1.0
7.0
Las divisiones por cero lanzan un error:
1 / 0
--------------------------------------------------------------------------- ZeroDivisionError Traceback (most recent call last) <ipython-input-8-e542b24897df> in <module>() ----> 1 1 / 0 ZeroDivisionError: division by zero
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
1.5
Se puede forzar que la división sea entera con el operador //
:
3 // 2
1
Se puede elevar un número a otro con el operador **
:
2 ** 16
65536
Otro tipo que nos resultará muy útil son los complejos:
2 + 3j
(2+3j)
1j
1j
# Valor absoluto
abs(2 + 3j)
3.605551275463989
abs(_13)
--------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-15-9ef688adf58b> in <module>() ----> 1 abs(_18) NameError: name '_18' is not defined
Podemos convertir variables a int, float, complex, str
...
int(18.6)
18
round(18.6)
19
float(1)
1.0
complex(2)
(2+0j)
str(256568)
'256568'
Podemos comprobar el tipo de una variable:
a = 2.
type(a)
float
isinstance(a, float)
True
Otras funciones útiles son:
print('hola mundo')
hola mundo
max(1,5,8,7)
8
min(-1,1,0)
-1
¡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
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:
b = 3.14159
b
3.14159
En una celda podemos escribir código que ocupe varias líneas. Si la última de ellas devuelve un resultado, este se imprimirá.
x, y = 1, 2
x, y
(1, 2)
x, y = y, x
x, y
(2, 1)
Los operadores de comparación son:
==
igual a!=
distinto de<
menor que<=
menor o igual queDevolverán un booleano: True
o False
x == y
False
print(x != y)
True
print(x < y)
print(x <= y)
print(x > y)
print(x >= y)
False False True True
# incluso:
x = 5.
6. < x < 8.
False
Si la ordenación no tiene sentido nos devolverá un error:
1 + 1j < 0 + 1j
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-34-9a32b6a036ce> in <module>() ----> 1 1 + 1j < 0 + 1j TypeError: unorderable types: complex() < complex()
# En las cadenas de texto sí existe un orden
'aaab' > 'ba'
False
True and False
False
not False
True
True or False
True
# Una curiosidad:
(True + True) * 10
20
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)
[1, 2, 3.0, (4+0j), '5'] (1, 2, 3.0, (4+0j), '5') False
Para las tuplas, podemos incluso obviar los paréntesis:
tupla_sin_parentesis = 2,5,6,9,7
type(tupla_sin_parentesis)
tuple
En los dos tipos podemos:
in
:2 in una_lista
True
2 in una_tupla
True
len
:len(una_lista)
5
[<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
1 2 [1, 2] (1, 2, 3.0) 5 (1, 2, 3.0, (4+0j), '5') [1, 3.0, '5']
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:
mis_asignaturas = [
['Álgebra', 'Cálculo', 'Física'],
['Mecánica', 'Termodinámica'],
['Sólidos', 'Electrónica']
]
mis_asignaturas
[['Álgebra', 'Cálculo', 'Física'], ['Mecánica', 'Termodinámica'], ['Sólidos', 'Electrónica']]
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>
print(x,y)
if x > y:
print("x es mayor que y")
print("x sigue siendo mayor que y")
5.0 1 x es mayor que y x sigue siendo mayor que y
if 1 < 0:
print("1 es menor que 0")
print("1 sigue siendo menor que 0") # <-- ¡Mal!
1 sigue siendo menor que 0
if 1 < 0:
print("1 es menor que 0")
print("1 sigue siendo menor que 0")
File "<ipython-input-49-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
:
print(x,y)
if x > y:
print("x es mayor que y")
else:
print("x es menor que y")
5.0 1 x es mayor que y
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")
5.0 1 x no es ni menor ni igual que y
En Python existen dos tipos de estructuras de control típicas:
while
for
while
¶Los 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
ii = -2
while ii < 5:
print(ii)
ii += 1
-2 -1 0 1 2 3 4
Otros operadores 'in-place' son: -=
, *=
, /=
Se puede interrumpir el bucle a la mitad con la sentencia break
:
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:
ii = 0
while ii < 5:
print(ii)
ii += 1
if ii == 3:
break
else:
print("El bucle ha terminado")
0 1 2
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
for
¶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...>
for ii in (1,2,3,4,5):
print(ii)
1 2 3 4 5
for nombre in "Juan", "Luis", "Carlos":
print(nombre)
Juan Luis Carlos
for ii in range(3):
print(ii)
0 1 2
for jj in range(2, 5):
print(jj)
2 3 4
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
File > Trusted Notebook
%%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>
# 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())