Acerca de.
Materiales de trabajo para el curso corto de Python para ciencias biológicas presentado en la Universidad
de Antioquia el Miércoles 27 de Abril de 2016.
Revisión del documento: Versión 1.3.0
Los sistemas biológicos exhiben gran complejidad. El desarrollo de técnicas experimentales y tecnologías nuevas ha causado que se disponga de datos experimentales cada vez más masivos, requiriéndose el uso de herramientas complejas que pueda manipular la cantidad de información disponible con facilidad. La mejor manera de exponer razones por las cuales un biógolo o profesional de las ciencias biológicas debería aprender a programar como una herramienta se puede hacer a través de casos reales de aplicación.
Dentro de los casos de éxito tenemos,
Ómicas: genómica, proteómica, metabolómica, secuenciación...
Minería de datos en bases de datos (Proteínas, Georeferenciación, ...).
Dinámica de poblaciones (Ecosistémica?).
Análisis estadístico masivo.
Análisis de datos con inteligencia artificial (Redes Neuronales, Algoritmos Adaptativos y Evolutivos, ...).
Simulación en general (Demasiados casos de éxito...).
Python es un lenguaje de programación interpretado que se ha popularizado mucho debido a su simpleza y
relativa facilidad de aprendizaje. Es un lenguaje de programación de scripting, es decir, el código fuente se ejecuta línea a línea,
y no requiere de su compilación para producir aplicaciones.
La diferencia entre un lenguaje de programación compilado y uno interpretado es que en el primer caso el código fuente debe ser compilado para producir un archivo ejecutable. Para el lenguaje interpretado se requiere de la existencia de una aplicación conocida como interprete que se encarga de ejecutar las instrucciones descritas en el código fuente o script.
Durante el desarrollo de este curso estaremos trabajando con una distribución de Python conocida como Anaconda.
Anaconda es un empaquetado de Python que incluye varios paquetes de uso frecuente en ciencias y análisis de datos, entre
ellos Matplotlib y Numpy de interés para este curso y cuya instalación independiente es bastante tediosa.
Enlace de descarga Anaconda para Windows
Tamaño aproximado: 350 MB.
Tiempo de instalación aproximado: 15 minutos.
El módulo de python-visual es útil para el dibujado de objetos 3D y animaciones.
El módulo VisualPython (VPython) funciona bajo Python 2.7 que es la versión estándar anterior a Python 3.x.
Para instalar vpython con Anaconda 3.5 se deben seguir los siguientes pasos
Crear un entorno con Python 2.7 en Anaconda, mediante el comando
conda create --name oldpython python=2.7el nombre oldpython puede ser cambiado por cualquier otro. Posteriormente, es necesario activar el nuevo entorno
activate oldpythonYa se puede instalar vpython desde la consola de Anaconda mediante el comando,
conda install -c https://conda.binstar.org/mwcraig vpythonOpcionalmente, para usar vpython con IPython es necesario instalar una versión de ipython compatible con python 2.7. Esto se logra mediante el comando
conda install ipythonSiempre y cuando tengamos el entorno oldpython activado.
Más información y otros enlaces de descarga
Para usar, vpython con las versiones más nuevas de python se recomienda incluir la siguiente línea al inicio del código
fuente,
from __future__ import print_function, divisionCualquier editor de texto es útil para escribir código fuente en python, el único requisito es guardar el código fuente con extensión .py.
Un editor que podría ser útil debido al resaltado de sintaxis es ATOM el cual puede descargarse para windows desde
este enlace https://github.com/atom/atom/releases/download/v1.7.2/atom-windows.zip
100 MB. Consola de IPython en Linux
Para iniciar una consola de IPython es necesario buscar la carpeta de instalación de Anaconda en el menú de inicio
de windows, y abrir el acceso directo IPyton correspondiente.
Al abrir la consola de IPython nos debe aparecer el siguiente mensaje (tal como en la figura más arriba ),
Esta consola o prompt nos permite ingresar líneas de código python que se ejecutan después de ser ingresadas.
In [1]:
print("Hola mundo!")
In [2]:
print("1+1=",2)
In [3]:
print("Hola, otra vez","1+1=",2)
In [4]:
print("Hola, otra vez.","Sabias que 1+1 =",2,"?")
In [5]:
numero=3
In [6]:
print(numero)
In [7]:
numero=3.1415
In [8]:
print(numero)
Probemos creando una variable que inicialice a una palabra
Esto produce la siguiente salida,
palabra=hola
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-12-fda39d79c7ea> in <module>()
----> 1 palabra=hola
NameError: name 'hola' is not defined
Lo que ocurrió es que la expresión palabra=hola corresponde a la asignación del contenido de una variable llamada
hola en una llamada palabra. La variable hola no existe (no fue definida previamente) por lo tanto se arrojó el error.
Para asignar el contenido de una palabra o frase se debe hacer uso de comillas dobles,
In [9]:
palabra="hola"
In [10]:
print(palabra)
In [11]:
%history
Es posible visualizar la lista de los comandos ingresados durante una sesión de trabajo de IPython. También es posible crear
un archivo que almacene los comandos de la sesión añadiendo la opción -f nombre_archivo_destino.py.
Por ejemplo, el comando
In [12]:
%history -f archivo_destino.py
Crea el archivo archivo_destino.py en el directorio de trabajo actual. Los contenidos de dicho archivo son los comandos ingresados durante la sesión de trabajo.
Jupyter es la evolución de lo que se conocía como notebooks de IPython, una interfaz en un navegador web que interacciona con un
kernel o núcleo de computación de IPython el cual se encarga de ejecutar los comandos ingresados en el notebook.
Actualmente Jupyter soporta varios núcleos de computación, entre ellos Python, R, Perl, entre otros.
Notebook de Jupyter
Para iniciar un notebook de Jupyter en Anaconda es necesario ejecutar el enlace directo con nombre Jupyter
en el menú de inicio, bajo el directorio de Anaconda
Esto iniciará el kernel establecido por defecto según la instalación de Anaconda que hayamos elegido,
y se abrirá una ventana del navegador web del sistema presentando el notebook de manera similar que vemos
en la figura más arriba
En programación existe el concepto de variable. Una variable puede verse como una etiqueta que le damos a una región de memoria donde almacenamos información. La utilidad de tener etiquetadas regiones de memoria es que podemos hacer llamadas a ella en cualquier parte de nuestros programas.
In [13]:
Cualquier_Cosa="Almaceno contenido"
print(Cualquier_Cosa)
Las variables pueden clasificarse según los siguientes tipos de datos,
Booleanos: almacenan valores de verdad, verdaero, falso, 1, 0.
Enteros: almacenan valores numéricos enteros, como 2, -2, 3, 1000.
Punto flotante: almacenan valores numéricos de punto flotante es decir, números con decimales o en notación científica.
boolAlmacenan valores de verdad verdadero o falso que en Python corresponden a true y false
In [14]:
verdadera = True
falsa = False
print(verdadera)
print(falsa)
In [15]:
numero=19881129
print(numero)
In [16]:
numeronegativo=-19881129
print(numero)
In [17]:
numero=3.19881129
print(numero)
In [18]:
numeronegativo=-3.19881129
print(numero)
In [19]:
palabra="Alicia"
frase="¿En qué se parecen un cuervo y un escritorio?"
print(palabra)
print(frase)
In [20]:
lista = [2,3.5,True, "perro feliz"] #existe en esta lista diferentes tipos de datos
Las listas permiten acceder a cada elemento utilizando un sistema de indices que van desde el 0 hasta el N-1 donde N
es el tamaño de la lista, es decir, la cantidad de elementos que almacena
In [21]:
print(lista[0])
print(lista[1])
print(lista[2])
print(lista[3])
También es posible mostrar los contenidos de una lista utilizando print
In [22]:
print(lista)
In [23]:
lista=[]
print(lista)
lista.append(1)
lista.append(":D")
lista.append("0211")
print(lista)
lista.remove("0211")
print(lista)
In [24]:
barranquero={"Reino":"Animalia","Filo":"Chordata","Clase":"Aves","Orden":"Coraciiformes","Familia":"Momotidae","Género":"Momotus"}
velociraptor={"Reino":"Animalia","Filo":"Chordata","Clase":"Sauropsida","Orden":"Saurischia","Familia":"Dromaeosauridae","Género":"Velociraptor"}
In [25]:
print(barranquero)
In [26]:
Meses={"Enero":1,"Febrero":2}
In [27]:
Meses["Enero"]
Out[27]:
In [28]:
Meses={1:"Enero",2:"Febrero"}
Meses[1]
Out[28]:
In [29]:
print("Hola")
Al interior tenemos la cadena de caracteres "Hola".
In [30]:
print(5.5)
Es posible ingresar varios argumentos a la función print,
In [31]:
print("Voy a tener varios argumentos","separados","por",1,"coma","entre ellos")
Las secuencias de escape son un conjunto de caracteres especiales que cotienen información sobre el formateo de texto,
\n significa nueva línea.
\t significa un espacio de tabulación.
\' permite colocar comillas simples en el texto.
\" permite colocar comillas dobles en el texto.
Un código de ejemplo ilustra mejor su uso,
In [32]:
print("Esto es un \"texto\" que se divide por\nUna línea nueva")
print("También puedo tener texto\tseparado por un tabulador")
print("Las secuencias de escape\n\t pueden ser combinadas\ncuantas veces se quiera")
In [33]:
nombre=input("Que quieres saber?: ")
print(barranquero[nombre])
Es equivalente a tener,
In [34]:
print("Hola, cual es tu nombre?")
nombre=input() # es necesario colocar comillas al texto ingresado
print("Tu nombre es",nombre)
Las estructuras de control determinan el comportamiento de un programa con base en desiciones. Los criterios de decisión suelen ser condiciones de lógica Booleana, es decir, Verdadero o Falso.
and, orCorresponde a las operaciones lógicas de conjunción y disyunción. Las tablas de verdad son las siguientes,
Conjunción and
| A | B | A and B |
|---|---|---|
| V | V | V |
| V | F | F |
| F | V | F |
| F | F | F |
In [35]:
print("Tabla de verdad \'and\'")
A = True
B = True
print(A,"and",B,"=",A or B)
A = True
B = False
print(A,"and",B,"=",A or B)
A = False
B = True
print(A,"and",B,"=",A or B)
A = False
B = False
print(A,"and",B,"=",A or B)
Disyunción or
| A | B | A or B |
|---|---|---|
| V | V | F |
| V | F | V |
| F | V | V |
| F | F | V |
In [36]:
print("Tabla de verdad \'or\'")
A = True
B = True
print(A,"or",B,"=",A or B)
A = True
B = False
print(A,"or",B,"=",A or B)
A = False
B = True
print(A,"or",B,"=",A or B)
A = False
B = False
print(A,"or",B,"=",A or B)
In [37]:
A=5
print(5>2)
print(5<2)
print(5==10)
print(5==A)
print(5>=2)
print(5<=2)
print(5<=A)
In [38]:
A=2
if( 5 > A ):
print("5 es mayor que",A)
La sentencia permite añadir la instrucción else que se ocupa del caso excluyente del if
In [39]:
A=2
if( 5 > A ):
print("5 es mayor que",A)
print("Hey")
else:
print("5 es menor que",A)
Se pueden anidar sentencias if que añadan condiciones adicionales mediante la instrucción elif (de else if).
Por ejemplo, considere lo que pasaría según los distintos valores de la variable A
In [40]:
A=5
if( 5 > A ):
print("5 es mayor que",A)
elif( 5 == A):
print("5 es igual",A)
else:
print("5 es menor que",A)
In [41]:
peticion=input("Que desea saber? ")
if(peticion=="Familia"):
print(barranquero["Familia"])
elif(peticion=="Orden"):
print(barranquero["Orden"])
else:
print("No entiendo tu petición")
Un ciclo es una porción de código que se ejecuta repetidamente, una y otra vez, un número de veces determinado. El ciclo se detiene cuando se satisface una condición de parada
forEste ciclo es muy útil cuando se conoce de antemano la cantidad de veces que se necesita repetir una acción determinada dentro del programa. Para controlar el ciclo se pueden utlizar las diferentes secuencias vistas anteriormente
In [42]:
for x in range(1,6):
print("Este mensaje aparece por",x,"vez")
También se puede incluír un "paso" en el ciclo
In [43]:
for x in range(1,20,2):
print(x)
In [44]:
for x in range(1,30,3):
print(x**2)
También es posible iterar a lo largo de los elementos de una lista,
In [45]:
lista=[1,2,3,4,5,6]
animales=["perro","gato","elefante"]
for x in animales:
print(x)
O a lo largo de los elementos de una cadena de caracteres,
In [46]:
frase="Alicia\n¿En qué se parecen un cuervo y un escritorio?"
for i in frase:
print(i)
In [47]:
frase[0:6]
Out[47]:
Notemos que en este caso i contiene momentáneamente el i-ésimo caracter de la cadena frase.
whileEl ciclo while se utiliza para ejecutar un conjunto de instrucciones repetidamente hasta que se
cumpla cierta condición que nosotros inducimos.
Veamos cómo generar los puntos que describen la trayectoria de un movimiento parabólico con velocidad inicial de 20 m/s con un ángulo de tiro de 60 grados.
Utilizaremos las ecuaciones de movimiento,
$$x = x_{0} + v_{0}\cos\theta\,t$$$$y = y_{0} + v_{0}\sin\theta\, t - \frac{1}{2}g\,t^{2}$$
In [48]:
# Esto se conoce como la importación de un módulo
# Aquí importamos el módulo math que contiene las operaciones matematicas de seno y coseno
# las cuales vamos a utilizar para calcular las componentes vertical y horizontal de la velocidad
# inicial
import math
t=0.0
dt=0.2
x=0.0
y=0.0
# Aquí tenemos
vx=20*math.sin(math.radians(60))
vy=20*math.cos(math.radians(60))
while y>=0.0:
print(t,"\t",x,"\t",y)
t=t+dt
x=x+vx*t
y=y+vy*t-(9.8/2)*t**2
En programación es común que existan tareas que se realicen recurrentemente. Las funciones sirven para disminuir la complejidad del código, organizarlo mejor, además de facilitar su depuración. Al igual que las fuciones en matemáticas, las funciones en programación pueden recibir argumentos los cuales son procesados para retornar algún resultado. Por otro lado, las fuciones también pueden existir sin requerir argumentos y ejecutar un conjunto de ordenes sin necesidad de devolver resultado alguno.
In [49]:
def producto(argumento1,argumento2):
return argumento1*argumento2
print(producto(2,3))
In [50]:
def busqueda(diccionario,peticion):
if(peticion=="Familia"):
print(diccionario["Familia"])
elif(peticion=="Orden"):
print(diccionario["Orden"])
else:
print("No entiendo tu petición")
In [51]:
peticion=input("Que desea saber? ")
busqueda(barranquero,peticion)
In [52]:
peticion=input("Que desea saber? ")
busqueda(velociraptor,peticion)
In [53]:
animales=[barranquero,velociraptor]
for animal in animales:
print(animal["Orden"])
for x in animales:
busqueda(animal,"Orden") #función definida previamente
También puedo tener argumentos que no retornen resultado alguno
In [54]:
def mensaje():
print("Hola clase")
mensaje()
In [55]:
def informacion(diccionario):
for i in diccionario.keys():
print(i,"\t",diccionario[i])
In [56]:
informacion(velociraptor)
Los módulos o librerías son conjuntos de funciones que han sido creadas por grupos de programadores y que permiten ahorrar
tiempo a la hora de programar.
Los módulos de interés para este curso son
math.
numpy (Numerical Python).
matplotlib (Mathematical Plot Library).
In [57]:
import math
print("math.fabs(-1)=",math.fabs(-1))
print("math.ceil(3.67)=",math.ceil(3.67))
print("math.floor(3.37)=",math.floor(3.37))
print("math.ceil(3.67)=",math.ceil(3.67))
print("math.floor(3.37)=",math.floor(3.37))
print("math.factorial(4)=",math.factorial(4))
print("math.exp(1)=",math.exp(1))
print("math.log(math.exp(1))=",math.log(math.exp(1)))
print("math.log(10)=",math.log(10))
print("math.log(10,10)=",math.log(10,10))
print("math.sqrt(2)=",math.sqrt(2))
print("math.degrees(3.141592)=",math.degrees(3.141592))
print("math.radians(2*math.pi)=",math.radians(2*math.pi))
print("math.cos(1)=",math.cos(1))
print("math.sin(1)=",math.sin(1))
print("math.tan(1)=",math.tan(1))
print("math.acos(1)=",math.acos(1))
print("math.asin(1)=",math.asin(1))
print("math.atan(1)=",math.atan(1))
In [58]:
import numpy as np
a = np.arange(15).reshape(3, 5)
print(a)
a = np.array([[ 0, 1, 2, 3, 4],[ 5, 6, 7, 8, 9],[10, 11, 12, 13, 14]])
a.shape
a.ndim
Out[58]:
In [59]:
np.zeros( (3,4) )
Out[59]:
In [60]:
np.ones( (3,4) )
Out[60]:
In [61]:
np.arange( 10, 30, 5 )
Out[61]:
In [62]:
random = np.random.random((2,3))
In [63]:
%matplotlib inline
import math
import matplotlib.pyplot as plt
t=0.0
dt=0.1
# Posición inicial
x=0.0
y=0.0
# Velocidad inicial
vo=20
# Listas vacías que almacenaran los puntos
# x, y de las trayectorias
puntos_x=[]
puntos_y=[]
# Aquí tenemos
vx=vo*math.cos(math.radians(60))
vy=vo*math.sin(math.radians(60))
while y>=0.0:
# Añado las coordenadas a la lista
puntos_x.append(x)
puntos_y.append(y)
t=t+dt
x=x+vx*t
y=y+vy*t-(9.8/2)*t**2
plt.title("Movimiento Parabólico")
plt.xlabel("Posición horizontal(m)")
plt.ylabel("Altura (m)")
plt.plot(puntos_x,puntos_y)
plt.show()
In [64]:
%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
def f(t):
return np.exp(-t) * np.cos(2*np.pi*t)
t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)
plt.figure(1)
plt.subplot(211)
plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')
plt.subplot(212)
plt.plot(t2, np.cos(2*np.pi*t2), 'r--')
plt.show()
In [65]:
%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
mu, sigma = 100, 15
x = mu + sigma * np.random.randn(10000)
# the histogram of the data
n, bins, patches = plt.hist(x, 50, normed=1, facecolor='g', alpha=0.75)
plt.xlabel('Smarts')
plt.ylabel('Probability')
plt.title('Histogram of IQ')
plt.text(60, .025, r'$\mu=100,\ \sigma=15$')
plt.axis([40, 160, 0, 0.03])
plt.grid(True)
plt.show()
In [66]:
%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
# make up some data in the interval ]0, 1[
y = np.random.normal(loc=0.5, scale=0.4, size=1000)
y = y[(y > 0) & (y < 1)]
y.sort()
x = np.arange(len(y))
# plot with various axes scales
plt.figure(1)
# linear
plt.subplot(221)
plt.plot(x, y)
plt.yscale('linear')
plt.title('linear')
plt.grid(True)
# log
plt.subplot(222)
plt.plot(x, y)
plt.yscale('log')
plt.title('log')
plt.grid(True)
# symmetric log
plt.subplot(223)
plt.plot(x, y - y.mean())
plt.yscale('symlog', linthreshy=0.05)
plt.title('symlog')
plt.grid(True)
# logit
plt.subplot(224)
plt.plot(x, y)
plt.yscale('logit')
plt.title('logit')
plt.grid(True)
plt.show()