Esta notebook fue creada originalmente como un blog post por Raúl E. López Briega en Mi blog sobre Python. El contenido esta bajo la licencia BSD.
En mi artículo anterior hice una breve introducción al mundo de Python, hoy voy a detallar algunas de las librerías que son esenciales para trabajar con Python en la comunidad científica o en el análisis de datos.
Una de las grandes ventajas que ofrece Python sobre otros lenguajes de programación, además de que es que es mucho más fácil de aprender; es lo grande y prolifera que es la comunidad de desarrolladores que lo rodean; comunidad que ha contribuido con una gran variedad de librerías de primer nivel que extienden la funcionalidades del lenguaje. Vamos a poder encontrar una librería en Python para prácticamente cualquier cosa que se nos ocurra.
Algunas de las librerías que se han vuelto esenciales y ya forman casi parte del lenguaje en sí mismo son las siguientes:
Numpy, abreviatura de Numerical Python , es el paquete fundamental para la computación científica en Python. Dispone, entre otras cosas de:
Más allá de las capacidades de procesamiento rápido de matrices que Numpy añade a Python, uno de sus propósitos principales con respecto al análisis de datos es la utilización de sus estructuras de datos como contenedores para transmitir los datos entre diferentes algoritmos. Para datos numéricos , las matrices de Numpy son una forma mucho más eficiente de almacenar y manipular datos que cualquier otra de las estructuras de datos estándar incorporadas en Python. Asimismo, librerías escritas en un lenguaje de bajo nivel, como C o Fortran, pueden operar en los datos almacenados en matrices de Numpy sin necesidad de copiar o modificar ningún dato.
Como nomenclatura general, cuando importamos la librería Numpy en nuestro programa Python se suele utilizar la siguiente:
In [1]:
import numpy as np
Existen varias maneras de crear matrices en Numpy, por ejemplo desde:
arange, linspace, etc.En Numpy tanto los vectores como las matrices se crean utilizando el objeto ndarray
In [2]:
#Creando un vector desde una lista de Python
vector = np.array([1, 2, 3, 4])
vector
Out[2]:
In [3]:
#Para crear una matriz, simplemente le pasamos una lista anidada al objeto array de Numpy
matriz = np.array([[1, 2],
[3, 4]])
matriz
Out[3]:
In [4]:
#El tipo de objeto de tanto de los vectores como de las matrices es ndarray
type(vector), type(matriz)
Out[4]:
In [5]:
#Los objetos ndarray de Numpy cuentan con las propiedades shape y size que nos muestran sus dimensiones.
print vector.shape, vector.size
print matriz.shape, matriz.size
In [6]:
#arange
#La funcion arange nos facilita la creación de matrices
x = np.arange(1, 11, 1) # argumentos: start, stop, step
x
Out[6]:
In [7]:
#linspace
#linspace nos devuelve un vector con la cantidad de muestras que le ingresemos y separados uniformamente entre sí.
np.linspace(1, 25, 25) # argumentos: start, stop, samples
Out[7]:
In [8]:
#mgrid
#Con mgrid podemos crear arrays multimensionales.
x, y = np.mgrid[0:5, 0:5]
x
Out[8]:
In [9]:
y
Out[9]:
In [10]:
#zeros y ones
#Estas funciones nos permiten crear matrices de ceros o de unos.
np.zeros((3,3))
Out[10]:
In [11]:
np.ones((3,3))
Out[11]:
In [12]:
#random.randn
#Esta funcion nos permite generar una matriz con una distribución estándar de números.
np.random.randn(5,5)
Out[12]:
In [13]:
#diag
#Nos permite crear una matriz con la diagonal de números que le ingresemos.
np.diag([1,1,1])
Out[13]:
Matplotlib es la librería más popular en Python para visualizaciones y gráficos. Matplotlib puede producir gráficos de alta calidad dignos de cualquier publicación científica.
Algunas de las muchas ventajas que nos ofrece Matplotlib, incluyen:
Matplotlib se integra de maravilla con IPython (ver más abajo), lo que nos proporciona un ambiente confortable para las visualizaciones y la exploración de datos interactiva.
In [14]:
#Generalmente se suele importar matplotlib de la siguiente forma.
import matplotlib.pyplot as plt
Ahora vamos a graficar la siguiente función.
$$f(x) = e^{-x^2}$$
In [15]:
# Definimos nuestra función.
def f(x):
return np.exp(-x ** 2)
In [16]:
#Creamos un vector con los puntos que le pasaremos a la funcion previamente creada.
x = np.linspace(-1, 5, num=30)
In [17]:
#Representeamos la función utilizando el objeto plt de matplotlib
plt.xlabel("Eje $x$")
plt.ylabel("$f(x)$")
plt.legend()
plt.title("Funcion $f(x)$")
plt.grid(True)
fig = plt.plot(x, f(x), label="Función f(x)")
In [18]:
#Grafico de puntos con matplotlib
N = 100
x1 = np.random.randn(N) #creando vector x
y1 = np.random.randn(N) #creando vector x
s = 50 + 50 * np.random.randn(N) #variable para modificar el tamaño(size)
c = np.random.randn(N) #variable para modificar el color(color)
plt.scatter(x1, y1, s=s, c=c, cmap=plt.cm.Blues)
plt.grid(True)
plt.colorbar()
fig = plt.scatter(x1, y1)
La idea principal con la programación orientada a objetos es que a los objetos que se pueden aplicar funciones y acciones, y ningún objeto debería tener un estado global (como en el caso de la interfase con plt que acabamos de utilizar). La verdadera ventaja de este enfoque se hace evidente cuando se crean más de una figura, o cuando una figura contiene más de una trama secundaria.
Para utilizar la API orientada a objetos comenzamos de forma similar al ejemplo anterior, pero en lugar de crear una nueva instancia global de plt, almacenamos una referencia a la recientemente creada figura en la variable fig, y a partir de ella creamos un nuevo eje ejes usando el método add_axes de la instancia Figure:
In [19]:
x = linspace(0, 5, 10) # Conjunto de puntos
y = x ** 2 # Funcion
fig = plt.figure()
axes1 = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # Eje principal
axes2 = fig.add_axes([0.2, 0.5, 0.4, 0.3]) # Eje secundario
# Figura principal
axes1.plot(x, y, 'r')
axes1.set_xlabel('x')
axes1.set_ylabel('y')
axes1.set_title('Ej OOP')
# Insertada
axes2.plot(y, x, 'g')
axes2.set_xlabel('y')
axes2.set_ylabel('x')
axes2.set_title('insertado');
In [20]:
# Ejemplo con más de una figura.
fig, axes = plt.subplots(nrows=1, ncols=2)
for ax in axes:
ax.plot(x, y, 'r')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_title('titulo')
fig.tight_layout()
IPython promueve un ambiente de trabajo de ejecutar-explorar en contraposición al tradicional modelo de desarrollo de software de editar-compilar-ejecutar. Es decir, que el problema computacional a resolver es más visto como todo un proceso de ejecucion de tareas, en lugar del tradicional modelo de producir una respuesta(output) a una pregunta(input). IPython también provee una estrecha integración con nuestro sistema operativo, permitiendo acceder fácilmente a todos nuestros archivos desde la misma herramienta.
Algunas de las características sobresalientes de IPython son:
IPython es mucho más que una librería, es todo un ambiente de trabajo que nos facilita enormemente trabajar con Python; las mismas páginas de este blog están desarrolladas con la ayuda del fantástico Notebook de IPython. (para ver el Notebook en el que se basa este artículo, visiten el siguiente enlace.)
Para más información sobre IPython y algunas de sus funciones los invito también a visitar el artículo que escribí en mi otro blog.
Pandas es una librería open source que aporta a Python unas estructuras de datos fáciles de user y de alta performance, junto con un gran número de funciones esenciales para el análisis de datos. Con la ayuda de Pandas podemos trabajar con datos estructurados de una forma más rápida y expresiva.
Algunas de las cosas sobresalientes que nos aporta Pandas son:
DataFrame para manipular datos con indexación integrada;DataFrame, con la mayoría de los formatos conocidos para el manejo de datos, como ser: CSV y archivos de texto, archivos Microsoft Excel, bases de datos SQL, y el formato científico HDF5.DataFrames y una fácil manipulación y ordenamiento de los datos de nuestro data set;data set, facilidad para construir tablas pivote;group by que nos permite dividir-aplicar-combinar nuestros conjuntos de datos;
In [21]:
# Importando pandas
import pandas as pd
In [22]:
# Las series son matrices de una sola dimension similares a los vectores, pero con su propio indice.
# Creando una Serie
serie = pd.Series([2, 4, -8, 3])
serie
Out[22]:
In [23]:
# podemos ver tantos los índices como los valores de las Series.
print serie.values
print serie.index
In [24]:
# Creando Series con nuestros propios índices.
serie2 = pd.Series([2, 4, -8, 3], index=['d', 'b', 'a', 'c'])
serie2
Out[24]:
In [25]:
# Accediendo a los datos a través de los índices
print serie2['a']
print serie2[['b', 'c', 'd']]
print serie2[serie2 > 0]
In [26]:
# El DataFrame es una estructura de datos tabular similar a las hojas de cálculo de Excel.
# Posee tanto indices de columnas como de filas.
# Creando un DataFrame.
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
'year' : [2000, 2001, 2002, 2001, 2002],
'pop' : [1.5, 1.7, 3.6, 2.4, 2.9]}
frame = pd.DataFrame(data) # Creando un DataFrame desde un diccionario
frame
Out[26]:
In [27]:
# Creando un DataFrame desde un archivo.
!cat 'dataset.csv' # ejemplo archivo csv.
In [28]:
# Leyendo el archivo dataset.csv para crear el DataFrame
frame2 = pd.read_csv('dataset.csv', header=0)
frame2
Out[28]:
In [29]:
# Seleccionando una columna como una Serie
frame['state']
Out[29]:
In [30]:
# Seleccionando una línea como una Serie.
frame.ix[1]
Out[30]:
In [31]:
# Verificando las columnas
frame.columns
Out[31]:
In [32]:
# Verificando los índices.
frame.index
Out[32]:
Otras librerías que también son muy importantes para el análisis de datos con Python son:
SciPy es un conjunto de paquetes donde cada uno ellos ataca un problema distinto dentro de la computación científica y el análisis numérico. Algunos de los paquetes que incluye, son:
scipy.integrate: que proporciona diferentes funciones para resolver problemas de integración numérica.scipy.linalg: que proporciona funciones para resolver problemas de álgebra lineal.scipy.optimize: para los problemas de optimización y minimización.scipy.signal: para el análisis y procesamiento de señales.scipy.sparse: para matrices dispersas y solucionar sistemas lineales dispersosscipy.stats: para el análisis de estadística y probabilidades.Scikit-learn es una librería especializada en algoritmos para data mining y machine learning.
Algunos de los problemas que podemos resolver utilizando las herramientas de Scikit-learn, son: