Python For Data Science Cheat Sheet
Aceleración
Variables y Strings
Las variables son usadas para guardar valores. Un string es una serie de caracteres
conformado por comillas simples ( ‘’ ) o dobles (“”).
Hello world
Hello world con una variable
Concatenación (unión de strings)
Pidiendo Ayuda
>>> help(str)
Variables y Tipos de Data
Asignación Variable
>>> x=5
>>> x
5 my_list[list][itemOfList]
Cálculos con Variables
Suma de variables
Resta de variables
Multiplicación de variables
Exponencial de una variable
Resto de una variable
División de una variable
Tipos de variables y conversión
Variables a strings
Variables a enteros
Variables a floats
Variable a booleanos
Strings
>>> my_string = 'thisStringIsAwesome'
>>> my_string
'thisStringIsAwesome'
Operaciones de String
>>> my_string * 2
'thisStringIsAwesomethisStringIsAwesome'
>>> my_string + 'Innit'
'thisStringIsAwesomeInnit'
>>> 'm' in my_string
True
Líderes en
Python Basics Digital
Listas Diccionarios
>>> a = 'is'
>>> b = 'nice' Los diccionarios almacenan conexiones entre piezas de información. Cada elemento
>>> my_list = ['my', 'list', a, b] es un par llave - valor
>>> my_list2 = [[4,5,6,7], [3,4,5,6]]
Crear Lista >>> bikes = ['trek', 'redline', Un simple Diccionario >>> alien = {'color': 'green',
>>> print(“Hello world!”) 'giant'] 'points': 5}
Recorrer una lista >>> for bike in bikes: >>> alien['x_position'] = 0
>>> msg= “Hello world!” Accediendo a un valor
>>> print(bike)
>>> print(msg)
Recorriendo todos los pares llave- >>> fav_numbers = {'eric': 17, 'ever':
Agregar ítems a la lista >>> bike = [] 4}
>>> first_name = 'albert' valor
>>> bikes.append (‘trek’) >>> for name, number in
>>> last_name = 'einstein'
>>> bikes.append(‘redline’) >>> fav_numbers.items():
>>> full_name = first_name + ' ' +
>>> bikes.append(‘giant’) >>> print(name + ' loves ' +
last_name
str(number))
>>> print(full_name)
Hacer listas númericas >>> squares = []
>>> fav_numbers = {'eric': 17,
>>> for x in range (1,11): Recorriendo todos los pares llave
'ever': 4}
square.append(x**2)
>>> for name in fav_numbers.keys():
>>> print(name + ' loves a
number')
>>> fav_numbers = {'eric': 17, 'ever':
Seleccionando elementos de la Lista
Recorriendo todos los valores
4}
>>> for number in
fav_numbers.values():
Subset >>> print(str(number) + ' is a
Seleccionar item en index 1 >>> my_list[1] favorite')
Seleccionar 3º último item >>> my_list[-3]
Slice
Seleccionar items de index 1 y 2 >>> my_list[1:3]
If Statements
Seleccionar items después de index 0 >>> my_list[1:]
Seleccionar items antes del index 3 >>> my_list[:3]
Copiar my_list >>> my_list[:] Los If statements son usados para comprobar condiciones particulares y
que respondan apropiadamente.
Subset Lists of Lists
>>> my_list2[1][0]
>>> my_list2[1][:2]
Igual a
Pruebas Condicionales >>> x == 42
Operaciones de Lista Mayor a
>>> x+2 >>> x > 42
7
Mayor o igual a
>>> x-2 >>> my_list + my_list >>> x >=42
3 ['my', 'list', 'is', 'nice', 'my', 'list', 'is', 'nice']
>>> my_list * 2 Pruebas Condicionales con listas >>> 'trek' in bikes
>>> x*2 ['my', 'list', 'is', 'nice', 'my', 'list', 'is', 'nice'] >>> 'surly' not in bikes
10 >>> my_list2 > 4
True
>>> x**2
25 Asignando valores booleanos >>> game_active = True
Comparación >>> can_edit = False
>>> x%2
1
>>> x/float(2) Obtener el index de un ítem >>> my_list.index(a) If- elif- else statements >>> if age >= 4:
2.5 ticket_price = 0
Contar un ítem >>> my_list.count(a)
>>> elif age < 18:
Añadir un ítem a la vez >>> my_list.append('!') ticket_price = 10
>>> else:
Quitar un ítem >>> my_list.remove('!') ticket_price = 15
str () '5', '3.45', 'True' Quitar un ítem >>> del(my_list[0:1])
Invertir la lista >>> my_list.reverse()
int () 5, 3, 1
Añadir un ítem >>> my_list.extend('!')
float () 5.0, 1.0 Quitar un ítem >>> my_list.pop(-1) Librerías
Insertar un ítem en cierta posición >>> my_list.insert(0,'!')
bool () True, True, True
Ordenar la lista >>> my_list.sort() Importar librerías
>>> import numpy
>>> import numpy as np
Importación Selectiva
>>> from math import pi
Operaciones de String
>>> my_string[3]
>>> my_string[4:9]
Métodos de String
String a mayúscula >>> my_string.upper()
String a minúscula >>> my_string.lower()
>>> my_string.count('w')
Contar los elementos del string
Descubre más en www.option.cl
Cambiar los elementos del string >>> my_string.replace('e', 'i')
Eliminar espacios en blanco >>> my_string.strip()
 Python For Data Science Cheat Sheet Líderes en
Aceleración
NumPy Basics Digital

NumPy Pedir Ayuda Data Types

Signed 64-bit tipos enteros >>> np.int64

>>> np.info(np.ndarray.dtype)
Estandard de doble-precisión >>> np.float32
NumPy es la librería principal para cálculos científicos en Python. floating point
Proporciona potentes estructuras de datos, implementando arreglos
(arrays) multidimensionales y herramientas para trabajar con estos. Números complejos representados >>> np.complex
Creating Arrays por float128

Utiliza la siguiente convención de importación: Arreglos (array) Matemáticos

Tipo Boolean que almacena valores >>> np.bool
TRUE y FALSE
>>> import numpy as np
Operaciones Aritméticas
Objeto de Python >>> np.object

Arreglos NumPy String de longitud fija >>> np.string_

Resta >>> g = a - b
array([[-0.5, 0. , 0. ], Unicode de longitud fija >>> np.unicode_
[-3. , -3. , -3. ]])
1D array 2D array 3D array
axis 1 Resta >>> np.subtract(a,b)
axis 2
1 2 3 Suma >>> b + a
axis 1 array([[ 2.5, 4. , 6. ],
1.5 2 3
axis 0 [ 5. , 7. , 9. ]]) Inspeccionando Arreglos
axis 0
4 5 6 Suma >>> np.add(b,a)

División >>> a / b
Dimensiones del arreglo >>> a.shape
array([[ 0.66666667, 1. , 1. ],
Creating Arrays
Creando Arreglos [ 0.25 , 0.4 , 0.5 ]]) Longitud del arreglo >>> len(a)
División >>> np.divide(a,b) Dimensiones del arreglo >>> b.ndim
Multiplicación >>> a * b
Número de elementos del arreglo >>> e.size
>>> a = np.array([1,2,3]) array([[ 1.5, 4. , 9. ],
>>> b = np.array([(1.5,2,3), (4,5,6)], dtype = float) [ 4. , 10. , 18. ]])) Data type de los elementos del >>> b.dtype
>>> c = np.array([[(1.5,2,3), (4,5,6)], [(3,2,1), (4,5,6)]], arreglo
Multiplicación >>> np.multiply(a,b)
dtype = float)
Exponencial Nombre del tipo de data >>> b.dtype.name
>>> np.exp(b)
Raíz Cuadrada >>> np.sqrt(b) Convertir un arreglo a un tipo >>> b.astype(int)
diferente
Placeholders Iniciales Seno de cada elemento del arreglo >>> np.sin(a)
Coseno de cada elemento del arreglo >>> np.cos(b)
Crear un arreglo de ceros >>> np.zeros((3,4))
Logaritmo natural de cada elemento >>> np.log(a)
del arreglo
Crear un arreglo de unos >>> np.ones((2,3,4),dtype=np.int16) >>> e.dot(f)

Crear un arreglo de valores

Producto punto entre dos arreglos
(e y f )
array([[ 7., 7.], Manipulando Arreglos
>>> d = np.arange(10,25,5) [ 7., 7.]])
espaciados uniformemente (step
value)
Transponer arreglos
Crear un arreglo de valores Comparación
>>> np.linspace(0,2,9) Permutar las dimensiones del arreglo >>> i = np.transpose(b)
espaciados uniformemente
(número de muestra) Transponer un arreglo >>> i.T
Comparación de dos Arreglos >>> a == b
Crear un arreglo constante >>> e = np.full((2,2),7) array([[False, True, True],
Cambiar tamaño de arreglos
[False, False, False]],
Crear una matriz de identidad 2x2 >>> f = np.eye(2) Aplanar el arreglo >>> b.ravel()
dtype=bool)
Crear un arreglo con valores Comparación de Elementos >>> a < 2
>>> np.random.random((2,2)) Remodelar, pero no cambiar la data >>> g.reshape(3,-2)
array([True, False, False]
aleatorios
Agregar/eliminar elementos
Crear un arreglo vacío >>> np.empty((3,2))
dtype=bool) Retornar un nuevo arreglo con forma >>> h.resize((2,6))
Comparación de Arreglos >>> np.array_equal(a, b)
(2,6)

Añadir elementos a un arreglo >>> np.append(h,g)

Funciones agregadas
Seleccionando, cortando e indexando
Insertar elementos a un arreglo >>> np.insert(a, 1, 5)

Suma de elementos del arreglo Borrar elementos de un arreglo >>> np.delete(a,[1])

>>> a.sum()
Subsetting
Seleccionar el elemento en el Valor mínimo del arreglo >>> a.min() Combinar arreglos
segundo index (tercera posición) >>> a[2]
1 2 3 Máximo valor de fila de un arreglo >>> b.max(axis=0)
3 Concatenar arreglos >>> np.concatenate((a,d),axis=0)
Seleccionar elemento en fila 1 Suma acumulada de los elementos >>> b.cumsum(axis=1) array([ 1, 2, 3, 10, 15, 20])
>>> b[1,2] 1.5 2 3
(segunda fila), columna 2 (tercera 6.0 Media >>> a.mean() >>> np.vstack((a,b))
Apilar arreglos verticalmente (por
columna) 4 5 6 filas) array([[ 1. , 2. , 3. ],
Mediana >>> b.median()
[ 1.5, 2. , 3. ],
Slicing Coeficiente de correlación >>> a.corrcoef() [ 4. , 5. , 6. ]])
Seleccionar items de fila 0 y 1
(primera y segunda) y columna 1 >>> a[0:2] 1 2 3 Desviación Standard >>> np.std(b) Apilar arreglos verticalmente (por >>> np.r_[e,f]
(segunda columna) array([1, 2]) filas)

>>> b[0:2,1]
1.5 2 3 Apilar arreglos horizontalmente >>> np.hstack((e,f))
Seleccionar ítems en la fila 0 y 1 en
array([ 2., 5.]) 4 5 6 (por columnas) array([[ 7., 7., 1., 0.],
columna 1
[ 7., 7., 0., 1.]])
Seleccionar todos los items en la >>> b[:1]
fila 0(equivalente a b[0:1, :]) array([[1.5, 2., 3.]])
1.5 2 3 Copiando Arreglos Crear arreglos apilados por columnas >>> np.column_stack((a,d))
4 5 6 array([[ 1, 10],
Igual a [1, :, :] >>> c[1,...] [ 2, 15],
array([[[ 3., 2., 1.], Crear una vista del arreglo con la [ 3, 20]])
>>> h = a.view()
[ 4., 5., 6.]]]) misma data Crear arreglos aplilados por columnas >>> np.c_[a,d]

Invertir arreglo >>> a[ : :-1] Crear una copia del arreglo >>> np.copy(a) Dividir arreglos
array([3, 2, 1])
Crear una copia profunda del arreglo >>> h = a.copy() Dividir el arreglo horizontalmente en >>> np.hsplit(a,3)
Boolean Indexing el 3er índice [array([1]),array([2]),array([3])]

Seleccionar elementos de a menor >>> a[a<2] 1 2 3 Dividir el arreglo verticalmente en el >>> np.vsplit(c,2)
a2 array([1]) 2do índice [array([[[ 1.5, 2. , 1. ],
[ 4. , 5. , 6. ]]]),
Fancy Indexing
Ordenando Arreglos array([[[ 3., 2., 3.],
[ 4., 5., 6.]]])]
Seleccionar elementos (1,0),(0,1),(1,2) >>> b[[1, 0, 1, 0],[0, 1, 2, 0]]
y (0,0) array([ 4. , 2. , 6. , 1.5])

Seleccionar un subconjunto de filas >>> b[[1, 0, 1, 0]][:,[0,1,2,0]]
y columnas de la matriz array([[ 4. ,5. , 6. , 4. ],
[ 1.5, 2. , 3. , 1.5],
[ 4. , 5. , 6. , 4. ],
[ 1.5, 2. , 3. , 1.5]])
Ordenar un arreglo >>> a.sort()
Ordenar elementos según un eje >>> c.sort(axis=0)
del arreglo
Descubre más en www.option.cl
 Python For Data Science Cheat Sheet Líderes en
Aceleración
Matplotlib Digital

Matplotlib Anatomía y Flujo de Trabajo

Anatomía del Plot Anotomía del Plot

1 Preparar Data 3 Plot 5 Salvar Plot
Axes/Subplot
2 Crear Plot 4 Personalizar Plot 6 Mostrar Plot
Es una librería de Python 2D que produce gráficas de calidad en una 35
variedad de formatos impresos y entornos interactivos a través de >>> import matplotlib.pyplot as plt
plataformas. Paso 1 >>> x = [1,2,3,4]
30 >>> y = [10,20,25,30]
Paso 2 >>> fig = plt.figure()
Paso 3 >>> ax = fig.add_subplot(111)
25 Paso 3 y 4 >>> ax.plot(x, y, color='lightblue', linewidth=3)
Y-axis
1) Preparar la Data >>> ax.scatter([2,4,6],
[5,15,25],
20
color='darkgreen',
1D Data marker='^')
15 >>> ax.set_xlim(1, 6.5)
Paso 5 >>> plt.savefig('foo.png')
>>> import numpy as np 1 2 3 Paso 6 >>> plt.show()
>>> x = np.linspace(0, 10, 100) 10 X-axis
>>> y = np.cos(x) 4 5 6
>>> z = np.sin(x)
5
4) Personalizar Plot
2D Data 0
Colores, Barras de colores y Mapa de Colores Límites, leyendas y layout

>>> data = 2 * np.random.random((10, 10)) Límites y Autoescalado

>>> data2 = 3 * np.random.random((10, 10)) >>> plt.plot(x, x, x, x**2, x, x**3) Agregar padding a plot >>> ax.margins(x=0.0,y=0.1)
>>> Y, X = np.mgrid[-3:3:100j, -3:3:100j] >>> ax.plot(x, y, alpha = 0.4) Establecer la relación de aspecto de >>> ax.axis('equal')
>>> U = -1 - X**2 + Y >>> ax.plot(x, y, c='k') la trama en 1
Creating Arrays
>>> V = 1 + X - Y**2 >>> fig.colorbar(im, orientation='horizontal')
>>> im = ax.imshow(img, Establecer límites para los ejes x e y >>>ax.set(xlim=[0,10.5],ylim=[-1.5,1.5])
>>> from matplotlib.cbook import get_sample_data
cmap='seismic') Establecer límites para eje x >>> ax.set_xlim(0,10.5)
>>> img = np.load(get_sample_data('axes_grid/bivariate_normal.npy'))

Leyendas
Establecer un título y etiquetas para >>> ax.set(title='An Example Axes',
Estilo de Línea ejes x e y
ylabel='Y-Axis', xlabel='X-Axis')
Establecer leyendas para
>>> ax.legend(loc='best')
ejes x e y
2) Crear Plot >>> plt.plot(x,y,linewidth=4.0)
>>> plt.plot(x,y,ls='solid') Ticks
>>> plt.plot(x,y,ls='--') Establecer manualmente x-ticks >>> ax.xaxis.set(ticks=range(1,5),
>>> plt.plot(x,y,'--',x**2,y**2,'-.') ticklabels=[3,100,-12,"foo"])
>>> import matplotlib.pyplot as plt >>> plt.setp(lines,color='r',linewidth=4.0) Alargar y-ticks, que estén dentro y >>> ax.tick_params(axis='y',
fuera del eje direction='inout', length=10)

Figura Texto Matemático Espaciado de Subplots

Ajustar el espacio entre suplots >>> fig3.subplots_adjust(wspace=0.5,
subplots hspace=0.3,
>>> fig = plt.figure() >>> plt.title(r'$sigma_i=15$', fontsize=20)
left=0.125,right=0.9,top=0.9,bottom=0.1)
>>> fig2 = plt.figure(figsize=plt.figaspect(2.0))
Encajar subplot(s) en el área de la >>> fig.tight_layout()
figura
Texto y anotaciones Hacer la línea del eje superior invisible Axis Spines
Ejes
para un plot >>> ax1.spines['top'].set_visible(False)
>>> ax.text(1, Mover la línea del eje inferior hacia >>>ax1.spines['bottom'].set_position(('o
Todo los plots están hechos respecto a Axes (ejes). En la mayoría de los -2.1, afuera utward',10))
casos un subplot se ajustará a tus necesidades. Un subplot son ejes en un
Creating Arrays
sistema de cuadrilla.
'Example Graph',
style='italic')
>>> ax.annotate("Sine",
>>> fig.add_axes() xy=(8, 0), Marcadores
>>> ax1 = fig.add_subplot(221) # row-col-num xycoords='data',
>>> ax3 = fig.add_subplot(212) xytext=(10.5, 0),
>>> fig, ax = plt.subplots()
>>> fig3, axes = plt.subplots(nrows=2,ncols=2) textcoords='data',
>>> ax.scatter(x,y,marker=".")
>>> fig4, axes2 = plt.subplots(ncols=3) arrowprops=dict(arrowstyle="->",
>>> ax.plot(x,y,marker="o")
connectionstyle="arc3"),)

3) Rutinas de Plotting 5) Guardar Plot

1D Data Guardar figuras

Dibujar puntos con líneas o
marcadores conectándolos
Dibujar puntos sin conectar, a
escala o con colores
>>> plt.savefig('foo.png')
Guardar figuras sin fondo
>>> fig, ax = plt.subplots() Campos vectoriales
>>> plt.savefig('foo.png', transparent=True)
>>> lines = ax.plot(x,y)
Agregar una flecha a los ejes >>> axes[0,1].arrow(0,0,0.5,0.5)
>>> ax.scatter(x,y)
Graficar un campo 2D de flechas >>> axes[1,1].quiver(y,z)

Plot rectángulos verticales (ancho >>> axes[0,0].bar([1,2,3],[3,4,5]) Graficar un campo 2D de flechas >>> axes[0,1].streamplot(X,Y,U,V) 6) Mostrar Plot
constante)

Plot rectángulos horizontales >>> axes[1,0].barh([0.5,1,2.5],

>>> plt.show()
(altura constante) [0,1,2]) Distribuciones de Datos
Dibujar línea horizontal a través de
>>> axes[1,1].axhline(0.45) Graficar un histograma >>> ax1.hist(y)
los ejes

Dibujar línea vertical a través de los >>> axes[0,1].axvline(0.65)

Graficar un boxplot o diagrama de >>> ax3.boxplot(y) Cerrar y Limpiar
caja y bigote
ejes
Graficar un violin plot >>> ax3.violinplot(z) Limpiar un eje >>> plt.cla() Clear an axis
Dibujar polígonos rellenos >>> ax.fill(x,y,color='blue')
Creating Arrays
Limpiar la figura completa >>> plt.clf() Clear the entire figure
Rellenar entre los valores de y y el >>> ax.fill_between(x,y,color='yellow')
eje x
3D Data o Imágenes Cerrar ventana
>>> plt.close()

Graficar pseudocolor plot de 2D array >>> axes2[0].pcolor(data2)

2D Data o Imágenes
Mapa de colores o arreglos RGB
Graficar Pseudocolor de 2D array >>> axes2[0].pcolormesh(data)
>>> fig, ax = plt.subplots()
>>> im = ax.imshow(img, Graficar una línea de contorno >>> CS = plt.contour(Y,X,U)
cmap='gist_earth',
interpolation='nearest', Graficar una línea de contorno rellena >>> axes2[2].contourf(data1)
Descubre más en www.option.cl
vmin=-2,
vmax=2) Etiquetar una línea de contorno >>> axes2[2]= ax.clabel(CS)
 Python For Data Science Cheat Sheet Líderes en
Aceleración
Seaborn Digital

Visualización de datos estadísticos con Seaborn 3) Plotting con Seaborn

Seaborn es una librería para Python que esta basada en matplotlib y Cuadrillas de Ejes Plot Categórico
proporciona una interfaz de alto nivel para dibujar atractivos gráficos
estadísticos.
Cuadrilla de Subplot para trazar >>> g = sns.FacetGrid(titanic, Scatterplot
relaciones condicionales col="survived", Scatterplot con una variable >>> sns.stripplot(x="species",
Utiliza la siguiente convención de importación:
row="sex") categórica y="petal_length", data=iris)
>>> import matplotlib.pyplot as plt >>> g = g.map(plt.hist,"age")
Scatterplot categórico con puntos >>> sns.swarmplot(x="species",
>>> import seaborn as sns Dibujar un plot categórico en un >>> sns.factorplot(x="pclass", y="petal_length", data=iris)
Facetgrid no superpuestos
y="survived”,
Los pasos básicos para crear gráficos con Seaborn son: hue="sex",
data=titanic) Mostrar estimaciones de puntos e Bar Chart
1. Preparar la data Creating Arrays intervalos de confianza con glifos >>> sns.barplot(x="sex", y="survived",
2. Controlar la estética de las figuras >>> sns.lmplot(x="sepal_width", de dispersión hue="class", data=titanic)
Graficar data y ajuste de modelo de
3. Plot con Seaborn regresión usando un FacetGrid y="sepal_length",
4. Personalizar tu plot hue="species", Count Plot
data=iris) Mostrar recuento de observaciones >>> sns.countplot(x="deck",
data=titanic,palette="Greens_d")
Grilla de subplot para graficar >>> h = sns.PairGrid(iris)
>>> import matplotlib.pyplot as plt relaciones por pares >>> h = h.map(plt.scatter) Boxplot
>>> import seaborn as sns Mostrar estimaciones de puntos e >>> sns.boxplot(x="alive",
>>> tips = sns.load_dataset("tips") Paso 1 intervalos de confianza como y="age",
Plot para pares de distribuciones >>> sns.pairplot(iris)
>>> sns.set_style("whitegrid") Paso 2 bivariadas barras rectangulares hue="adult_male",
>>> g = sns.lmplot(x="tip", data=titanic)
y="total_bill", Paso 3 Grilla para gráfico bivariado con >>> i = sns.JointGrid(x="x", y="y",
distribuciones marginales data=data)
data=tips, univariadas >>> i = i.plot(sns.regplot, Diagrama de caja con datos de
aspect=2) formato ancho >>> sns.boxplot(data=iris,orient="h")
sns.distplot)
>>> g = (g.set_axis_labels("Tip","Total bill(USD)").
set(xlim=(0,10),ylim=(0,100))) Gráfico de distribución bivariada >>> sns.jointplot("sepal_length",
"sepal_width", Violin Plot >>> sns.violinplot(x="age",
Paso 4
>>> plt.title("title") data=iris, y="sex",hue="survived",
>>> plt.show(g) kind='kde') data=titanic)

Plots de Regresión Plots de Distribución

1) Preparar la data Datos de plot y ajuste de modelo >>> sns.regplot(x="sepal_width", Gráfico de distribución univariada >>> plot = sns.distplot(data.y,
de regresión lineal y="sepal_length", data=iris, kde=False,
ax=ax) color="b")

>>> import pandas as pd

>>> import numpy as np
>>> uniform_data = np.random.rand(10, 12)
>>> data = pd.DataFrame({'x':np.arange(1,101),
'y':np.random.normal(0,4,100)})
4) Perzonalizaciones Adicionales

Seaborn también ofrece sets de datos incorporados: Objetos de Axisgrid Plot

>>> titanic = sns.load_dataset("titanic") Quitar columna izquierda
>>> iris = sns.load_dataset("iris")
Establecer las etiquetas del eje y
Establecer las etiquetas de tick
para x
>>> g.despine(left=True) Añadir título al plot >>> plt.title("A Title")
>>> g.set_ylabels("Survived") Ajustar la etiqueta del eje y >>> plt.ylabel("Survived")
>>> g.set_xticklabels(rotation=45) Ajustar la etiqueta del eje x >>> plt.xlabel("Sex")

Establecer las etiquetas de eje
2) Estética de la Figura Establecer el límite y ticks de los
Creating Arrays
ejes x e y
Crear una figura y un subplot
>>> f, ax = plt.subplots(figsize=(5,6))
>>> g.set_axis_labels("Survived", Ajustar los límites del eje y >>> plt.ylim(0,100)
"Sex")
Ajustar los límites del eje x >>> plt.xlim(0,10)
>>> h.set(xlim=(0,5),
Ajustar una propiedad del plot >>> plt.setp(ax,yticks=[0,5])
ylim=(0,5),
xticks=[0,2.5,5],
Ajustar parámetros de subplot >>> plt.tight_layout()
yticks=[0,2.5,5])

Estilos de Seaborn
5) Mostrar o Guardar Plot Cerrar y Limpiar
(Re) iniciar seaborn por defecto >>> sns.set()
Limpiar un eje >>> plt.cla() Clear an axis
Establecer los parámetros de >>>sns.set_style("whitegrid")
Creating Arrays
matplotlib Mostrar el plot >>> plt.show() Creating Arrays
Limpiar la figura completa >>> plt.clf() Clear the entire figure

Establecer los parámetros de
matplotlib
Devuelve un dictado de parámetros
o utiliza with para establecer
temporalmente el estilo
>>> sns.set_style("ticks", Set the
matplotlib parameters
{"xtick.major.size":8,
"ytick.major.size":8})
>>> sns.axes_style("whitegrid")
Guarda el plot como una figura >>> plt.savefig("foo.png") Cerrar ventana
>>> plt.close()
Guarda una figura transparente >>> plt.savefig("foo.png"
transparent=True)

Descubre más en www.option.cl

Funciones de Contexto

Establecer contexto “talk” >>> sns.set_context("talk")

Establecer contexto para

>>> sns.set_context("notebook"
“notebook”, escalar elementos
font_scale=1.5,
fuentes y sobre-escribir
rc={"lines.linewidth":2.5})
parámetros de mapeo

Paletas de colores

Definir paleta de colores >>> sns.set_palette("husl",3)

Usar with para establecer >>> sns.color_palette("husl")

temporalmente la paleta
>>> flatui =
["#9b59b6","#3498db","#95a5a6","#e74"]

Establecer tu propia paleta de >>> sns.set_palette(flatui)

colores
 Python For Data Science Cheat Sheet Líderes en
Aceleración
Pandas Basics Digital

Pandas Pedir ayuda Ordenar y Rango

Ordenar por etiquetas a lo largo de >>> df.sort_index()

>>> help(pd.Series.loc) un eje

Ordenar por los valores a lo largo de >>> df.sort_values(by='Country')

un eje

Asignar rangos a las entradas >>> df.rank()

Creating Arrays
Pandas es una librería escrita como extensión de NumPy para Seleccionar
manipulación y análisis de datos para el lenguaje de programación
Python. Ofrece estructuras de datos y operaciones para manipular
tablas numéricas y series temporales. Obtener un elemento
Creating Arrays
Recuperar información de series/dataframe
Utiliza la siguiente convención de importación:
Obtener un elemento >>> s['b']
>>> import pandas as pd -5 Información Básica

Obtener conjunto de DataFrame >>> df[1:]

Country Capital Population (Filas, columnas) >>> df.shape
Creating Arrays
Estructura de Datos de Pandas 1 India New Delhi 1303171035
Describir index >>> df.index
2 Brazil Brasília 207847528
Describir columnas de DataFrame >>> df.columns

Series Información en DataFrame >>> df.info()

Seleccionar, Boolean, Indexar y Configurar Número de valores no-NA >>> df.count()

Seleccionar un solo valor por fila y Por Posición

a 3 Un arreglo unidimensional que puede >>> df.iloc[[0],[0]]
columna Resumen
contener cualquier tipo de datos 'Belgium'
b -5 >>> df.iat([0],[0])
c 7 'Belgium' >>> df.sum()
>>> s = pd.Series([3, -5, 7, 4], Suma de valores
Index
index=['a', 'b', 'c', 'd']) Por Etiqueta
d 4 >>> df.cumsum()
Seleccionar un solo valor por >>> df.loc[[0], ['Country']] Suma acumulativa de valores
etiquetas de fila y columna 'Belgium'
>>> df.at([0], ['Country']) Valores mínimos / máximos >>> df.min()/df.max()
'Belgium'
Valor de index mínimo / máximo >>> df.idxmin()/df.idxmax()
DataFrame Por Etiqueta/Posición Resumen estadístico >>> df.describe()
Seleccionar una sola columna de >>> df.ix[2] Resumen
subconjunto de filas Country Brazil Media de valores >>> df.mean()
Capital Brasília
Una etiqueta bidimensional de estructura de datos
Population 207847528 Mediana de valores
con columnas de tipos potencialmente diferentes >>> df.median()

Seleccionar una sola columna de >>> df.ix[:,'Capital']

subconjunto de columnas 0 Brussels
1 New Delhi
Columnas 2 Brasília
Creating Arrays
Alineación de Data
Country Capital Population >>> df.ix[1,'Capital']
Seleccionar por fila y columna
'New Delhi'
a Belgium Brussels 11190846 Alineación de data interna
Boolean Indexing
892
b India New Delhi 1303171035 Los valores NA se introducen en los índices que no se superponen
Serie s donde el valor no es mayor a 1 >>> s[~(s > 1)]
c Brazil Brasília 207847528
Index
S donde el valor es < -1 o > 2 >>> s[(s < -1) | (s > 2)] >>> s3 = pd.Series([7, -2, 3], index=['a', 'c', 'd'])

>>> s + s3
>>> data = {'Country': ['Belgium', 'India', 'Brazil'], Usar filtro para ajustar DataFrame >>> df[df['Population']>1200000000] a 10.0
'Capital': ['Brussels', 'New Delhi', 'Brasília'], b NaN
'Population': [11190846, 1303171035, 207847528]} Configuración c 5.0
>>> df = pd.DataFrame(data, Configurar index a de la Series s a 6 >>> s['a'] = 6 d 7.0
columns=['Country', 'Capital', 'Population'])

También se puede hacer la alineación interna de los datos con

la ayuda de los métodos de relleno:

Operaciones aritméticas con métodos de relleno

I/O
>>> s.add(s3, fill_value=0)
a 10.0
Leer y Escribir en CSV Leer y Escribir en SQL Query o Database Table b -5.0
c 5.0
d 7.0
>>> pd.read_csv('file.csv', header=None, nrows=5) >>> from sqlalchemy import create_engine
>>> df.to_csv('myDataFrame.csv') >>> s.sub(s3, fill_value=2)
>>> engine = create_engine('sqlite:///:memory:')
>>> pd.read_sql("SELECT * FROM my_table;", engine) >>> s.div(s3, fill_value=4)
>>> pd.read_sql_table('my_table', engine)
892
>>> s.mul(s3, fill_value=3)
Leer y Escribir en Excel >>> pd.read_sql_query("SELECT * FROM my_table;", engine)

>>> pd.read_excel('file.xlsx') read_sql()es un conveniente envoltorio de read_sql_table() y

>>> pd.to_excel('dir/myDataFrame.xlsx', sheet_name='Sheet1') read_sql_query()
Leer múltiples hojas del mismo archivo
>>> xlsx = pd.ExcelFile('file.xls') >>> pd.to_sql('myDf', engine) Descubre más en www.option.cl
>>> df = pd.read_excel(xlsx, 'Sheet1')

Aplicar funciones Eliminar

Aplicar la función
Aplicar la función a cada elemento
>>> f = lambda x: x*2 Eliminar valores de las filas (ejes=0) >>> s.drop(['a', 'c'])
>>> df.apply(f)
Eliminar valores de la
>>> df.applymap(f) >>> df.drop('Country', axis=1)
columna(eje=1)