Suscríbete a DeepL Pro para poder traducir archivos de mayor tamaño.

Más información disponible en www.DeepL.com/pro.

Hoja de trucos: El objeto pandas DataFrame

Preliminares Introducir los datos en un DataFrame

Empieza siempre importando estos módulos de Instanciar un DataFrame vacío

Python
importar numpy como np df = DataFrame()
import matplotlib.pyplot as plt
import pandas as pd Cargar un DataFrame desde un archivo CSV
from pandas import DataFrame, Series df = pd.read_csv('fichero.csv') # a
Nota: estos son los alias de importación recomendados menudo funciona df =
Nota: puedes poner esto en un archivo PYTHONSTARTUP pd.read_csv('fichero.csv', header=0,
index_col=0, quotechar='"', sep=':',
na_values = ['na', '-',
Nota: consulte la documentación de'.', ''])
pandas para conocer
todos los argumentos
Convenciones
Obtener datos de texto CSV en línea a un DataFrame
from io import StringIO
Ejemplos de códigos data = """, Animal, Simpatía, Deseable
# Los ejemplos de código se encuentran en los row-1, perro, 8.7, Verdadero
recuadros amarillos fila-2, cat, 9.5, Verdadero
fila-3, bate, 2.6, Falso""
En los ejemplos de código, normalmente uso: df = pd.read_csv(StringIO(data), header=0,
• s para representar un objeto pandas Series; index_col=0, skipinitialspace=True)
• df para representar un objeto pandas
DataFrame; Nota: skipinitialspace=True permite un diseño bonito
• idx para representar un objeto pandas Index.
• También: t - tupla, l - lista, b - booleano, i - Cargar DataFrames desde un archivo de Microsoft
entero, a - matriz numpy, st - cadena, d - Excel
# Cada hoja Excel en un diccionario Python
diccionario, etc. workbook = pd.ExcelFile('archivo.xlsx')
d = {} # empezar con un diccionario vacío
for nombre_hoja in nombres_hoja.libro: df =
libro.parse(nombre_hoja)
El modelo conceptual d[nombre_hoja] = df
Objeto DataFrame: es una tabla bidimensional de
datos con índices de columnas y filas (algo así como Nota: el método parse() toma muchos argumentos como
una hoja de cálculo). Las columnas están formadas read_csv() arriba. Consulte la documentación de pandas.
por objetos Series.
Índice de columnas (df.columns) Cargar un DataFrame desde una base de datos MySQL
importar pymysql
from sqlalchemy import crear_motor engine =
crear_motor('mysql+pymysql://'
d dato

d dato

d dato

d dato
d dato

d dato

d dato
(df.index)

+'USUARIO:CONTRASEÑA@HOST/BASE DE DATOS')
e s

e s

e s

e s
e s

e s

e s
Índice de

df = pd.read_sql_table('tabla', motor)
filas

Los datos de las series se combinan en un DataFrame

Serie

Serie

Serie

Serie
Serie

Serie

Serie

# Ejemplo 1 ...
s1 = Serie(rango(6)) s2
= s1 * s1
Un DataFrame tiene dos índices: datos con un
s2.index índice. Todos
= s2.index + 2los datos de unaíndices
# desalinear serie son del
• Normalmente, el índice de columna (df.columns) es df = pd.concat([s1,
mismo tipo. La aritméticas2], axis=1)
de las series se vectoriza
una lista de cadenas (nombres de variables) o después del primer
(menos comúnmente) números enteros # Ejemplo 2 ...
• Normalmente, el índice de fila (df.index) podría ser: s3 = Serie({'Tom':1, 'Dick':4, 'Har':9})
o Enteros - para números de caja o de fila; s4 = Serie({'Tom':3, 'Dick':2, 'Mar':5})
o Cadenas - para nombres de casos; o df = pd.concat({'A':s3, 'B':s4 }, axis=1)
o DatetimeIndex o PeriodIndex - para series
temporales

Objeto Serie: una matriz unidimensional ordenada de

Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
on twitter]. 1
Nota: el 1er método tiene etiquetas de columna en
números enteros
Nota: El 2º método no garantiza el pedido de col

Obtener un DataFrame de un diccionario Python

Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
on twitter]. 1
Obtener un DataFrame a partir de los datos de un diccionario Python
# --- use helper method for data in rows Trabajar con todo el DataFrame
df = DataFrame.from_dict({ # datos por fila
# filas como diccionarios Eche un vistazo al contenido/estructura del DataFrame
python 'fila0' : {'col0':0, df.info() # Índice y tipos de
'col1':'A'}, dfh = df.head(i) datos
fila1 : {'col0':1, 'col1':'B'} dft = df.tail(i) # Obtener las
}, orient='index') primeras
dfs = df.describe() # resumen i filas
estadístico
cols # Obtener las
df = DataFrame.from_dict({ # datos por fila últimas i =
esquina_arriba_izquierda_df filas
# filas como listas python df.iloc[:4, :4]
fila0' : [1, 1+1j, 'A'],
fila1 : [2, 2+2j, 'B'] Atributos no indexables de DataFrame
}, orient='index') df = df.T # transponer filas y
l = df.ejes columnas
# list row and#col
(r_idx, c_idx) = df.axes de indexes
arriba
Crear datos de reproducción/falsificación (útil para pruebas) s = d f . dtypes # Tipos de datos de
# --- simple - índices enteros por columna de serie b = d f .empty # True
defecto df = para DataFrame vacío i = d f . ndim# número
DataFrame(np.random.rand(50,5)) de ejes (es 2) t = d f . shape # (número
de filas, número de columnas) i = df.size #
# --- con un índice de fila de marca de tiempo: número de filas * número de columnas a =
df = DataFrame(np.random.rand(500,5)) d f . values # obtener una matriz
df.index = pd.date_range('1/1/2005', numpy para df
Métodos de utilidad de DataFrame
periods=len(df), freq='M')
df = df.copy() # copiar un DataFrame
df = d f . rank() # clasificar cada col (por
# con índices alfabéticos de filas y
defecto) df = df.sort_values(by=col)
columnas y una variable "agrupable"
df = df.sort_values(by=[col1, col2])
import string
df = df.sort_index()
importar
random filas = df = df.astype(dtype) # conversión de tipos
52
Métodos de iteración de DataFrame
cols = 5
assert(1 <= filas <= 52) # número df.iteritems() # (col-index, Series)
mínimo/máximo de filas df = pares df.iterrows() # pares (fila-
DataFrame(np.random.randn(filas, cols), índice, Serie) # ejemplo ... iterando
columns=['c'+str(i) for i in range(cols)], sobre columnas ... for (nombre, serie)
index=list((string.ascii_uppercase + in df.iteritems():
string.ascii_lowercase)[0:filas])) print('\nCol nombre: ' + str(nombre))
df['agrupable'] = [random.choice('abcde') print('1er valor: ' + str(serie.iat[0]))
for _ in range(filas)]
Matemáticas en todo el DataFrame (no es una lista
Guardar un DataFrame completa)
df = df.abs() # valores absolutos
df = df.add(o) # añadir df, Serie o valor s =
df.count() # valores no NA/nulos
Guardar un DataFrame en un archivo CSV
df = df.cummax() # (cols eje por
df.to_csv('nombre.csv', encoding='utf-8')
defecto) df = df.cummin() # (cols eje
por defecto) df = df.cumsum() # (cols
Guardar DataFrames en un libro de Excel
eje por defecto)
from pandas import ExcelWriter
df = df.diff() # 1er diff (col def eje)
writer = ExcelWriter('nombrearchivo.xlsx')
df = d f . div(o) # div por df, Serie, valor
df1.to_excel(writer,'Hoja1')
df = d f . dot(o) # matriz producto punto
df2.to_excel(writer,'Hoja2')
s = df.max() # max of axis (col def)
writer.save()
s = df.mean() # media (col eje por
defecto) s = df.mediana() # mediana
Guardar un DataFrame en MySQL
(col p o r d e f e c t o )
importar pymysql
s = df.min() # min of axis (col def)
from sqlalchemy import crear_motor
df = df.mul(o) # mul por df Serie val
e = create_engine('mysql+pymysql://' + Nota: los métodos que#devuelven una seriepor
funcionan por
s = df.sum() eje suma (cols
'USUARIO:CONTRASEÑA@HOST/DATABASE') defecto en cols
defecto) df = df.where(df > 0.5,
df.to_sql('TABLE',e, if_exists='replace') other=np.nan)
Seleccionar/filtrar filas/carpetas en función de los
valores de las etiquetas de índice
Nota: if_exists � 'fail', 'replace', 'append' df = df.filter(items=['a', 'b']) # por
col df = df.filter(items=[5], axis=0) # por
Guardar en objetos Python fila df = df.filter(like='x') # mantener x
en
Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com col df = df.filter(regex='x') #
- @Mark_Graph
2
on twitter].
regex en col
d = df.to_dict() # al diccionario
str = df.to_string() # a cadena
m = df.as_matrix() # to numpy matrix Nota: select toma una función booleana, para cols: axis=1
Nota: el filtro se aplica por defecto a las columnas; la
selección se aplica por defecto a las filas.

Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
on twitter]. 3
 Establecer valores de columna en función de criterios
Trabajar con columnas df['b'] = df['a'].where(df['a']>0, other=0)
df['d'] = df['a'].where(df.b!=0, other=df.c)
Obtener índice de columnas Nota: donde other puede ser una Serie o un escalar
y etiquetas
idx = d f . columnas # obtener índice
col label = d f .columns[0] # Conversiones de tipos de datos
etiqueta primera columna st = df['col'].astype(str)# Serie dtype
l = df.columns.tolist() # lista de a = df['col'].values # matriz
etiquetas col a = df.columns.values# numpy l = df['col'].tolist() # lista
array de etiquetas col python
Cambiar las etiquetas Nota: dtypes útiles para la conversión de series: int, float,
de las
df = columnas str
df.rename(columns={'antiguo':'nuevo','a':'1'}) Trampa: índice perdido en la conversión de Serie a array o
df.columns = ['nuevo1', 'nuevo2', 'nuevo3'] # lista
etc.
Selección de Métodos/atributos comunes a toda la columna
columnas
s = df['colNombre'] # select col to Series
df = d f [['colName']] # seleccionar col en
df
valor = df['col'].dtype # Tipo de datos
df = df[['a','b']] # seleccionar 2-plus
valor = df['col'].size # dimensiones
cols
valor = df['col'].count() col # recuento
df = df[['c','a','b']] # cambiar orden col s =
valor = df['col'].sum() no-NA
df[df.columnas[0]] # seleccionar por
valor = df['col'].prod()
número
valor = df['col'].min()
df = df[df.columnas[[0, 3, 4]]] # por
valor = df['col'].max()
números df = [ d f . c o l u m n a s [ :-1]] #
valor = df['col'].media() # también
todas menos la última col mediana()
valor = df['col'].cov(df['col2'])
s = df.pop('c') # obtener y soltar de df
s= df['col'].describe()
s=
Selección de columnas con atributos Python
df['col'].recuentos_valore
s = df.a # igual que s = df['a']
s()
Buscar etiqueta de índice para valores mín./máx. en
# no se pueden crear nuevas columnas por
atributo df.columna_existente = df.a / df.b columna
df['columna_nueva'] = df.a / df.b label = df['col1'].idxmin()
label = df['col1'].idxmax()
Trampa: los nombres de las columnas deben
ser identificadores válidos. Métodos comunes de columna por elementos

Añadir nuevas columnas a un DataFrame s = df['col'].isnull()

s = d f [ ' c o l '].notnull() # no isnull()
df['new_col'] = range(len(df))
s = d f [ 'col'].astype(float)
df['new_col'] = np.repeat(np.nan,len(df))
s = df['col'].abs()
df['random'] = np.random.rand(len(df))
s=
df['index_as_col'] = df.index
df['col'].round(decimales=0) s
df1[['b','c']] = df2[[['e','f']]
= df['col'].diff(periodos=1)
df3 = df1.append(other=df2)
s = df['col'].shift(periods=1)
Trampa: Al añadir una nueva columna, sólo se añadirán s = df['col'].to_datetime()
los elementos de la nueva serie que tengan un índice s = df['col'].fillna(0) # sustituye NaN por
correspondiente en el DataFrame. El DataFrame 0 s = df['col'].cumsum()
receptor no se amplía para dar cabida a la nueva serie. s = df['col'].cumprod()
Trampa: al añadir una lista python o un array numpy, la s = df['col'].pct_change(periods=4)
columna se añadirá por posición entera. s = df['col'].rolling(window=4,
min_periods=4, center=False).sum()
Intercambiar el contenido de las columnas
df[['B', 'A']] = df[['A', 'B']] Añade una columna de sumas de filas a un

Eliminación de columnas (principalmente por DataFrame Nota: también medias, mínimas,

etiquetas) df['Total'] = df.sum(axis=1)
máximas, etc.
df = d f .drop('col1', axis=1)
df.drop('col1', axis=1, inplace=True) Multiplicar cada columna de DataFrame por Series
df = df.drop(['col1','col2'], axis=1) df = df.mul(s, axis=0) # en filas coincidentes
s = df.pop('col') # drops from frame Nota: también add, sub, div, etc.
del df['col'] # incluso el python clásico
funciona df = df.drop(df.columns[0], Selección de columnas con .loc, .iloc y .ix
axis=1)#first df = df.drop(df.columns[-
1:],axis=1)#last
Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
on twitter]. 4
 df = df.loc[:, 'col1':'col2'] #
i n c l u s i v o df = df.iloc[:, 0:2] #
exclusivo
Aritmética vectorial en columnas
df['proporción']=df['recuento']/df['tota Obtener la posición entera de una etiqueta de índice de
l'] df['porcentaje'] = df['proporción'] * columna
100,0 i = df.columns.get_loc('nombre_col')

Aplicar funciones matemáticas de numpy a las columnas Comprobar si los valores de índice de las columnas
son únicos/monotónicos if df.columns.is_unique: pass # ...
df['log_data'] = np.log(df['col1']) b = df.columns.is_monotonic_increasing b
Nota: muchas más funciones matemáticas numpy = df.columns.is_monotonic_decreasing
Sugerencia: Prefiera pandas math a numpy siempre que pueda.

Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
on twitter]. 5
 Seleccionar una porción de filas por etiqueta/índice
Trabajar con filas [inclusivo-de : inclusivo-a [ : paso]]
df = df['a':'c'] # filas 'a' a 'c'
Obtener el índice de fila y las Trampa: no puede funcionar para filas etiquetadas con
etiquetas
idx = d f . index # obtener índice números enteros - véase
de fila label = df.index[0] # fragmento de código anterior sobre el corte de posiciones
etiqueta de la primera fila etiqueta = de enteros.
df.index[-1] # etiqueta de la
última fila l = d f . i n d e x .tolist() # Añadir una fila de totales de columna a un DataFrame
obtener como lista # Opción 1: utilizar la comprensión del
a = df.index.values # obtener como array diccionario sums = {col: df[col].sum() for
col in df} sums_df =
Cambiar el índice (de fila) DataFrame(sums,index=['Total']) df =
df.append(sums_df)
df.index = idx # nuevo índice ad
df = df.set_index('A') hoc
# col# Un nuevo # Opción 2: Todo hecho con
df = df.set_index(['A', 'B']) MultiIndex
índice pandas df =
df = df.reset_index() # reemplazar
df.append(DataFrame(df.sum(),
antiguo con nuevo # nota: índice antiguo
almacenado como col en df df.index = columns=['Total']).T)
Iteración sobre filas DataFrame
range(len(df)) # establecer con lista for (index, row) in df.iterrows(): # pasar
df = df.reindex(index=range(len(df))) Trampa: el tipo de datos de la fila
df = df.set_index(keys=['r1','r2','etc'])
df.rename(index={'old':'new'}, inplace=True) puede estar forzado.

Ordenar valores de filas de DataFrame

Añadir filas df = df.sort(df.columnas[0],
df = original_df.append(más_filas_en_df) ascendente=False)
Sugerencia: convierta la fila en un DataFrame y df.sort(['col1', 'col2'], inplace=True)
luego añádala.
Ambos DataFrames deben tener las mismas Ordenar DataFrame por su índice de fila
etiquetas de columna. df.sort_index(inplace=True) # ordenar por
fila df = df.sort_index(ascending=False)
Eliminación de filas (por nombre)
df = df.drop('etiqueta_fila')
df = df.drop(['fila1','fila2']) # varias filas
Selección aleatoria de filas
Selección booleana de filas por valores de una columna import random como r
df = df[df['col2'] >= 0.0] k = 20 # elige un número
df = df[(df['col3']>=1.0) | (df['col1']<0.0)] selection = r.sample(range(len(df)), k)
df = df[df['col'].isin([1,2,5,7,11])] df_sample = df.iloc[selection, :] # obtener
df = df[~df['col'].isin([1,2,5,7,11])] copia
Nota: esta muestra seleccionada aleatoriamente no está
df = df[df['col'].str.contains('hola')] ordenada
Trampa: bitwise "or", "and" "not; (ie. | & ~) cooptados
para ser operadores booleanos en una Serie de Eliminar duplicados en el índice de filas
Boolean
Trampa: se necesitan paréntesis alrededor de las df['index'] = df.index # 1 crear nueva col
comparaciones. df = df.drop_duplicates(cols='index',
take_last=True)# 2 usar nueva
Selección de filas mediante isin en varias columnas col del df['index'] # 3 del the col
# falsear algunos datos df.sort_index(inplace=True)# 4 tidy up
datos = {1:[1,2,3], 2:[1,4,9], 3:[1,8,27]}
df = DataFrame(datos) Comprueba si dos DataFrames tienen el mismo índice
de fila
# isin multicolumna len(a)==len(b) y all(a.index==b.index)
lf = {1:[1, 3], 3:[8, 27]} # buscar
f = df[df[list(lf)].isin(lf).all(axis=1)] Obtener la posición entera de una etiqueta de índice de
fila o columna
i = df.index.get_loc('fila_etiqueta')
Trap: index.get_loc() devuelve un entero para un único
Selección de filas mediante un coincidencia. Si no es una coincidencia única, puede
índice
idx = df[df['col'] >= 2].index devolver una rebanada/máscara.
print(df.ix[idx])
Obtener la posición entera de las filas que cumplen la
condición
a = np.where(df['col'] >= 2) #matriz numpy
Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
on twitter]. 6
Seleccionar una porción de filas por
posición entera Comprobar si los valores de índice de fila son
[inclusive-from : exclusive-to [: step]] únicos/monotónicos
if df.index.is_unique: pass # ...
start es 0; end es len(df) b = df.index.is_monotonic_increasing b
df = df[:] # copiar todo el = df.index.is_monotonic_decreasing
df = df[0:2] DataFrame
df = df[2:3] # filas 0 y 1
df = df[-1:] # fila 2 (la tercera fila) #
la última fila Buscar duplicados de índices de filas
df = df[:-1]
# todos menos la if df.index.has_duplicates:
df = df[::2]
última fila print(df.index.duplicated())
Trampa: un solo número entero sin dos puntos es una
# cada 2 filas numeradas
(0 2 ..) Nota: también similar para duplicados de etiquetas de
etiqueta de columna para columnas con
columna.
números enteros.

Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
on twitter]. 7
 Resumen: seleccionar utilizando el índice
Trabajar con células DataFrame
Selección de una celda por etiquetas de fila y columnaUso del índice DataFrame
para seleccionar columnas
valor = df.at['fila',
'columna'] s = df['col_label'] # returns Serie
valor = df.loc['fila', 'col'] df = df[['col_label']] # devuelve DataFrame
# tricky
valor = df['col'].at['row'] df = df[['L1', 'L2']] # seleccionar cols con
lista
Nota: .at[] es la búsqueda escalar más rápida basada en etiquetas
df = d f [índice] # seleccionar cols con un
Establecer una celda por etiquetas de índice df = df[s] #
Nota: scalar devuelve Series;seleccionar con un
list &c devuelve
fila y columna 'columna'] = etiqueta
DataFrame. col Serie
df.at['fila',
valor
df.loc['fila', 'col'] = valor # tricky Utilización del índice DataFrame para seleccionar filas
df['col'].at['row'] = valor df = d f ['de':'inc_a'] # label s l i c e
df = df[3:7] # segmento
Seleccionar y cortar en etiquetas de enteros
df = df.loc['fila1':'fila3', 'col1':'col3'] df = df[df['col'] > 0.5] # Serie booleana
Nota: el "a" de este trozo es inclusivo. df = d f .loc['label'] # etiqueta
única
Establecer una sección transversal por etiquetas df = df.loc[container] # lista/Serie de
df.loc['A':'C', 'col1':'col3'] = np.nan laboratorio df = df.loc['from':'to'] #
df.loc[1:2,'col1':'col2']=np.ceros((2,2)) rebanada inclusiva df = df.loc[bs] #
df.loc[1:2,'A':'C']=othr.loc[1:2,'A':'C'] Serie booleana
Recuerde: "a" inclusivo en el corte df = d f . iloc[0] # entero
Trap: Boolean
simple df = Series
d f . i lgets
o c rows, label Series gets
[ contenedor] # cols.
Seleccionar una celda por posición lista/serie de int df = df.iloc[0:5] #
Utilización
slice del índice DataFrame para seleccionar una
exclusivo
entera
valor = df.iat[9, 3] # [row, col]
sección transversal
df = df.ix[x] # loc then iloc
valor = df.iloc[0, 0] # [row, col]
valor = df.iloc[len(df)-1, len(df.columnas)-1] # r y c pueden ser escalares, listas,
slice df.loc[r, c] # acceso a etiquetas
(fila, columna) df.iloc[r, c] # acceso
entero d f .ix[r, c] # acceso a etiqueta int
Seleccionar un rango de celdas por posición int
fallback df[c].iloc[r] # encadenado -
df = df.iloc[2:4, 2:4] # subconjunto de también para .loc
df df = df.iloc[:5, :5] # esquina
Utilizar el índice del DataFrame para seleccionar una
superior izquierda
s = df.iloc[5, :] # devuelve fila como celda
Serie df exclusivo
= df.iloc[5:6, # r y c deben ser etiquetas o enteros
Nota: "a" - igual :]
que# el
devuelve
troceado fila
de como
Serie d f . a t [r, c] # rápido escalar label
listas en python.
accessor df.iat[r, c] # fast scalar int
accessor df[c].iat[r] # encadenado -
Ajuste de celda por posición entera
también para .at
df.iloc[0, 0] = valor # [row, col]
df.iat[7, 8] = valor Métodos de indexación de DataFrame
v = d f .get_value(r, c ) # obtener por
Establecer el rango de celdas por posición f i l a , c o l df = df.set_value(r,c,v) # set
entera
df.iloc[0:3, 0:5] = valor df.iloc[1:3, by row, c o l df = d f .xs(key, axis) #
1:4] = np.ones((2, 3)) obtener sección transversal df =
df.iloc[1:3, 1:4] = np.zeros((2, 3)) d f .filter(items, like, regex, a x i s )
df.iloc[1:3, 1:4] = np.array([[1, 1, 1], df = df.select(crit, eje) (.loc, .iloc, .ix, .at
Nota: los atributos de indexación
[2, 2, 2]])
.iat) pueden utilizarse para obtener y establecer
valores en el DataFrame.
Recuerde: exclusivo en el corte Nota: los atributos de indexación .loc, iloc y .ix pueden
aceptar objetos python slice. Pero .at y .iat no.
.ix para la indexación mixta de etiquetas y
Nota: .loc también puede aceptar argumentos de serie
posiciones
valor enteras'col1']
= df.ix[5, booleanos Evitar: encadenamiento en la forma
df = df.ix[1:5, 'col1':'col3'] df[col_indexer][row_indexer] Trampa: los trozos de
etiquetas son inclusivos, los trozos de enteros son
exclusivos.

Algunos atributos y métodos del índice

Vistas y copias b = idx.is_monotonic_decreasing
b = idx.is_monotonic_increasing
b = idx.has_duplicates
i -=@Mark_Graph
Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com i d x .nlevels # número de niveles 8
on twitter].
de índice idx = idx.astype(dtype)# cambiar
Del manual: Establecer una copia puede causar errores
sutiles. Las reglas sobre cuándo se devuelve una vista
de los datos dependen de NumPy. Siempre que una
matriz de etiquetas o un vector booleano están
involucrados en la operación de indexación, el resultado
será una copia.

Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
on twitter]. 9
 Trampa: Los valores NaN en la clave de grupo se
Unir/Combinar DataFrames descartan automáticamente - nunca habrá un grupo NA.
Tres formas de unir dos DataFrames: El mecanismo "groupby" de pandas nos permite dividir
• fusión (una operación de unión similar a la de una los datos en grupos, aplicar una función a cada grupo de
base de datos/SQL) forma independiente y luego combinar los resultados.
• concat (apilar uno al lado del otro o uno encima del
otro) Iteración de grupos: normalmente no es necesaria
• combine_first (junta los dos, eligiendo los para nombre, grupo en gb:
valores de uno sobre los del otro) print (nombre, grupo)
Fusión de índices Seleccionar un grupo
df_new = pd.merge(left=df1, right=df2, dfa = df.groupby('cat').get_group('a') dfb
how='outer', left_index=True, = df.groupby('cat').get_group('b')
Cómo: 'izquierda', 'derecha', 'exterior',
right_index=True)
'interior'
Cómo: exterior=unión/todos; Aplicar una función de agregación
interior=intersección # aplicar a una columna ...
s = df.groupby('cat')['col1'].sum()
Fusión de columnas s=
df_new = pd.merge(left=df1, right=df2, d f . g r o u p b y ('cat')['col1'].agg(np.sum) #
how='left', left_on='col1', aplicar a cada columna del DataFrame s =
right_on='col2') d f .groupby('cat').agg(np.sum)
Trampa: Al unir columnas, los índices de la columna df_summary = df.groupby('cat').describe()
Los DataFrames pasados se ignoran. df_row_1s = df.groupby('cat').head(1)
Trampa: las fusiones de muchos a muchos en una
columna pueden provocar una explosión de los datos Nota: las funciones de agregación reducen la
asociados. dimensión en uno - incluyen: media, suma, tamaño,
recuento, std, var, sem, describir, primero, último, min,
Unir en índices (otra forma de fusionar) max
df_new = df1.join(other=df2, on='col1',
how='exterior') Aplicación de múltiples funciones de agregación
df_new = df1.join(other=df2,on=['a','b'], gb = df.groupby('cat')
how='exterior') # aplicar múltiples funciones a una
Nota: DataFrame.join() une índices por defecto. columna dfx = gb['col2'].agg([np.sum,
DataFrame.merge() une columnas comunes por np.mean]) # aplicar múltiples fns a
defecto. múltiples cols dfy = gb.agg({
'cat': np.count_nonzero,
La concatenación simple suele ser la mejor 'col1': [np.sum, np.mean, np.std],
'col2': [np.min, np.max]
df=pd.concat([df1,df2],axis=0)#arriba/aba
jo df = df1.append([df2, df3]) })
#arriba/abajo Nota: gb['col2'] es la abreviatura de df.groupby('cat')['col2'],
df=pd.concat([df1,df2],axis=1)#izquierda/
Trampa: puede acabar con filas o columnas sin necesidad de reagrupación.
derecha
duplicadas
Nota: concat tiene un parámetro Funciones de transformación
ignore_index # transformar a puntuaciones z de grupo,
que tienen # una media de grupo de 0, y
Combinar_primero una desviación estándar de 1. zscore =
df = df1.combinar_primero(otro=df2) lambda x: (x-x.mean())/x.std() dfz =
df.groupby('cat').transform(zscore) #
# multicombinar con python reduce() df reemplazar los datos perdidos con la
= reduce(lambda x, y: media de grupo mean_r = lambda x:
x.combinar_primero(y), x.fillna(x.mean())
[df1, df2, df3, df4, df5]) dfm = df.groupby('cat').transform(media_r)
Utiliza los valores no nulos de df1. El índice del Nota: puede aplicar múltiples funciones de
DataFrame combinado será la unión de los índices transformación de forma similar a las funciones de
de df1 y df2. agregación múltiple anteriores,

Aplicación de funciones de filtrado

Las funciones de filtrado permiten realizar selecciones
en función de si cada grupo cumple los criterios
especificados
Agrupar: Dividir-Aplicar-Combinar # seleccionar grupos con más de 10
miembros eleven = lambda x:
(len(x['col1']) >= 11) df11 =
Agrupación df.groupby('cat').filter(eleven)
gb = df.groupby('cat') # por una
Agrupar por un índice de filas (índice no jerárquico)
c o l u m n a gb = df.groupby(['c1','c2']) #
Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
por 2 cols gb = df.groupby(level=0) #
on twitter]. 10
 df = df.set_index(keys='cat')
s = df.groupby(level=0)['col1'].sum()
dfg = df.groupby(level=0).sum()
Nota: groupby() devuelve un objeto pandas groupby
Nota: el atributo .groups del objeto groupby contiene
un mapeo de diccionario de los grupos.

Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
on twitter]. 11
 Tablas dinámicas: trabajar con datos largos y
anchos Trabajar con fechas, horas y sus índices
var_name='Partido', id_vars=['Fecha',
Estas funciones funcionan con índices jerárquicos o
'Encuestador', 'Estado'])
multinivel y, a menudo, los crean;
(el MultiIndex de pandas es potente y complejo). Nota: Consulte la documentación, hay muchos
argumentos para estos métodos.
Pivotar, desapilar, apilar y fundir
Las tablas dinámicas pasan de datos de formato largo a
formato ancho
# Empecemos con datos en formato
largo from StringIO import StringIO #
python2.7 #from io import StringIO #
python 3 data =
"""Fecha,Encuestador,Estado,Partido,E
st 13/03/2014, Newspoll, NSW, red,
25 13/03/2014,
Newspoll, N S W , azul, 28
13/03/2014, Newspoll, Vic, rojo, 24
13/03/2014, Newspoll, Vic, azul, 23
13/03/2014, Galaxy, NSW, rojo, 23
13/03/2014, G a l a x y , NSW, azul,
24 13/03/2014,
Galaxy, Vic, rojo, 26
13/03/2014, G a l a x y , Vic, azul,
25 13/03/2014,
Galaxy, Qld, rojo, 21
13/03/2014, G a l a x y , Qld, azul,
27""" df =
pd.read_csv(StringIO(data),
header=0, skipinitialspace=True)

# pivotar a formato ancho en la columna

'Partido' # 1º: establecer un MultiIndex
para otras cols df1 =
df.set_index(['Fecha', 'Encuestador',
'Estado'])
# 2nd: do the pivot
wide1 = df1.pivot(columns='Partido')

# descompilar a formato ancho en Estado

/ Partido # 1er: MultiIndex todo menos
los valores col df2 =
df.set_index(['Fecha',
'Encuestador',
Estado", "Partido"])
# 2nd: unstack a column to go wide on it wide2
= df2.unstack('State')
wide3 = df2.unstack() # pop last index

# Usa stack() para volver al formato largo

long1 = wide1.stack()
# A continuación, utilice reset_index()
para eliminar el # MultiIndex.
long2 = long1.reset_index()

# O fundir() de vuelta al
formato largo # 1º: aplanar el
índice de la columna
wide1.columns = ['_'.join(col).strip()
for col in wide1.columns.values]
# 2º: eliminar el MultiIndex wdf =
wide1.reset_index()
# 3rd: melt away
long3 = pd.melt(wdf, value_vars=
['Est_azul', 'Est_rojo'],
Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
on twitter]. 12
Fechas y tiempo - puntos y lapsos Nota: Aunque los periodos constituyen un índice muy útil,
Con su enfoque en datos de series temporales, pueden ser menos útiles en una serie.
pandas tiene un conjunto de herramientas para la
gestión de fechas y tiempo: ya sea como un punto en De cadenas no estándar a marcas de tiempo
el tiempo (un Timestamp) o como un lapso de tiempo t = ['09:08:55.7654-ENE092002',
(un Período). '15:42:02.6589-FEB082016']
s = pd.Series(pd.to_datetime(t,
t = pd.Timestamp('2013-01-01')
format="%H:%M:%S.%f-%b%d%Y"))
t = pd.Timestamp('2013-01-01 21:15:06')
t = pd.Timestamp('2013-01-01 21:15:06.7') También: %B = nombre completo del mes; %m = mes
p = pd.Period('2013-01-01', freq='M') numérico;
Nota: Las marcas de tiempo deben estar entre %y = año sin siglo; y más ...
1678 y 2261 años. (Compruebe Timestamp.max y
Fechas y hora - sellos y espacios como índices
Timestamp.min). Un índice de Timestamps es un
Una serie de marcas de tiempo o periodos DatetimeIndex. Un índice de Periodos es un
ts = ['2015-04-01', '2014-04-02'] date_strs = ['2014-01-01', '2014-04-01',
PeriodIndex.
'2014-07-01', '2014-10-01']
# Serie de marcas de tiempo (bueno)
s = pd.to_datetime(pd.Series(ts)) dti = pd.DatetimeIndex(date_strs)

# Series de Periodos (difíciles de pid = pd.PeriodIndex(date_strs, freq='D')

hacer) s = pd.Series( pim = pd.PeriodIndex(date_strs, freq='M')
[pd.Period(x, freq='M') for x in ts] ) piq = pd.PeriodIndex(date_strs, freq='Q')
s = pd.Series(pd.PeriodIndex(ts,freq='D'))
print (pid[1] - p i d [0]) # 90 días
print ( pim[1] - pim[0]) # 3 meses
print ( piq[1] - piq[0]) # 1
Sugerencia: a menos que trabaje con menos de
trimestre
segundos, prefiera PeriodIndex a DateTimeImdex.
time_strs = ['2015-01-01 02:10:40.12345',
'2015-01-01 02:10:50.67890']
pis = pd.PeriodIndex(time_strs, freq='U')

df.index = pd.period_range('2015-01',
periods=len(df), freq='M')

dti = pd.to_datetime(['04-01-2012'],
dayfirst=True) # Formato de fecha
australiano
pi = pd.period_range('1960-01-01',
'2015-12-31', freq='M')

Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
on twitter]. 13
Constantes de frecuencia del periodo (no es una lista Muestreo ascendente y descendente
completa) # upsample from quarterly to monthly
Nombre Descripción pi = pd.period_range('1960Q1',
U Microsegundo periods=220, freq='Q')
L Milisegundo df = DataFrame(np.random.rand(len(pi),5),
S Segundo index=pi)
T Minuto dfm = df.resample('M', convention='end')
H Hora # use ffill o bfill para rellenar con
D Día natural valores
B Día laborable
W-{MON, TUE, ...} Semana que termina el ... # Muestreo descendente de mensual a
trimestral dfq = dfm.resample('Q',
MS Calendario de inicio de mes
how='sum')
M Calendario fin de mes
QS-{JAN, FEB, ...} Inicio de trimestre con inicio de Husos horarios
año (QS - diciembre) t = ['2015-06-30 00:00:00',
Q-{JAN, FEB, ...} Final de trimestre con final de '2015-12-31 00:00:00']
año (Q - diciembre) dti = pd.to_datetime(t
AS-{JAN, FEB, ...} Comienzo del año (AS - ).tz_localize('Australia/Canberra')
diciembre) dti = dti.tz_convert('UTC')
A-{JAN, FEB, ...} Fin de año (A - diciembre) ts = pd.Timestamp('now',
tz='Europa/Londres')
De DatetimeIndex a objetos datetime de Python
dti = pd.DatetimeIndex(pd.date_range( # obtener una lista de todas
start='1/1/2011', periods=4, freq='M')) las zonas horarias import pyzt
s = Serie([1,2,3,4], index=dti) for tz in pytz.all_timezones:
na = dti.to_pydatetime() # numpy array print tz
na = s.index.to_pydatetime() # matriz numpy Nota: por defecto, las marcas de tiempo se crean sin
información de zona horaria.
Fechas y horas de Frome a Python
df['fecha'] = [x.fecha() for x in df['TS']] Selección de filas con un índice de series temporales
df['tiempo'] = [x.tiempo() for x in df['TS']] # empezar con los datos de
Nota: convierte a datatime.date o datetime.time. Pero no reproducción anteriores idx =
convierte a datetime.datetime. pd.period_range('2015-01',
periods=len(df), freq='M')
De DatetimeIndex a PeriodIndex y viceversa df.index = idx
df = DataFrame(np.random.randn(20,3))
df.index = pd.date_range('2015-01-01', february_selector = (df.index.month == 2)
periods=len(df), freq='M') february_data = df[february_selector]
dfp = df.to_period(freq='M')
dft = dfp.to_timestamp() q1_data = df[(df.index.mes >= 1) & (df.index.mes
Nota: de periodo a marca de tiempo por defecto es el <= 3)]
punto en el tiempo al inicio del periodo.
mayornov_data = df[(df.index.month == 5) |
Trabajar con un (df.index.month == 11)]
PeriodIndex
pi = pd.period_range('1960-01','2015-12',
freq='M') También:=año,
totales mes, día [del mes], hora, minuto, segundo,
df.groupby(df.index.year).sum()
na = p i . valores # numpy array de enteros día de la semana [Lun=0 .. Dom=6], semana del mes,
lp = pi.tolist() # python lista de Periodos semana del año [numerados a partir de 1], la semana
sp = Series(pi) # pandas Series de empieza el lunes], día del año [a partir de 1], ...
Periodos ss = Series(pi).astype(str) # S de
strs Atributo Series.dt
ls = Series(pi).astype(str).tolist() Las columnas de DataFrame que contienen objetos de
tipo datetime pueden manipularse con el atributo de
Obtener un intervalo de acceso .dt
marcas de tiempo
t = ['2012-04-14 04:06:56.307000',
dr = pd.date_range('2013-01-01',
'2011-05-14 06:14:24.457000',
'2013-12-31', freq='D')
'2010-06-14 08:23:07.520000']
Tratamiento de errores con fechas
# una serie de marcas de tiempo
s = pd.Series(pd.to_datetime(t))
print(s.dtype) # datetime64[ns]
print(s.dt.second) # 56, 24, 7
print(s.dt.mes) # 4, 5, 6
# a Serie de periodos de tiempo
s = pd.Series(pd.PeriodIndex(t,freq='Q'))
print(s.dtype)
Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph # datetime64[ns]
on twitter]. print(s.dt.quarter) 2, 2, 2 14
# 1er ejemplo devuelve cadena no
Timestamp t = pd.to_datetime('2014-02-
30')
# 2º ejemplo devuelve NaT (no un tiempo)
t = pd.to_datetime('2014-02-30', coerce=True)
# NaT like NaN tests True for isnull()
b = pd.isnull(t) # --> True

La cola de una serie temporal DataFrame

df = df.last("5M") # los últimos cinco meses

Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
on twitter]. 15
 Múltiples histogramas (superpuestos o apilados)
ax = df.plot.hist(bins=25, alpha=0.5) # o...
Trazado a partir del DataFrame ax = df.plot.hist(bins=25, stacked=True)
# seguido del código de trazado estándar
Importar matplotlib, elegir un estilo matplotlib anterior
import matplotlib.pyplot as plt
print(plt.style.available)
plt.style.use('ggplot')

Falsificar algunos datos (que reutilizamos

repetidamente)
a = np.random.normal(0,1,999)
b = np.random.normal(1,2,999)
c = np.random.normal(2,3,999)
df = pd.DataFrame([a,b,c]).T
df.columns =['A', 'B', 'C']

Gráfico lineal
df1 = df.cumsum()
ax = df1.plot()

# de aquí para abajo - salida estándar

ax.set_title('Título') Gráficos de barras
ax.set_xlabel('Eje X') bins = np.linspace(-10,15,26)
ax.set_ylabel('Eje Y') binned = pd.DataFrame()
for x in df.columns:
fig = ax.figure y=pd.cut(df[x],bins,labels=bins[:-1])
fig.set_size_inches(8, 3) y=y.value_counts().sort_index()
fig.tight_layout(pad=1) binned = pd.concat([binned,y],axis=1)
fig.savefig('filename.png', dpi=125) binned.index = binned.index.astype(float)
binned.index += (np.diff(bins) / 2.0)
plt.close() ax = binned.plot.bar(stacked=False,
width=0.8) # para el ancho de la barra
# seguido del código de trazado estándar
anterior

Diagrama de cajas
ax = df.plot.box(vert=False)
# seguido del código de trazado estándar Barras horizontales
anterior ax = binned['A'][(binned.index >= -4) &
(binned.index <= 4)].plot.barh()
# seguido del código de trazado estándar
anterior

ax = df.plot.box(column='c1', by='c2')

Histograma
Diagrama de densidad
ax = df['A'].plot.hist(bins=20) ax = df.plot.kde()
# seguido del código de trazado estándar # seguido del código de trazado estándar
anterior anterior

Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
on twitter]. 16
Diagrama de dispersión Una línea y una barra en el mismo gráfico
ax = df.plot.scatter(x='A', y='C') En matplotlib, los gráficos de barras visualizan datos
# seguido del código de trazado estándar categóricos o discretos. Los gráficos de líneas
anterior visualizan datos continuos. Esto hace que sea difícil
obtener barras y líneas en el mismo gráfico.
Normalmente, los gráficos combinados tienen
demasiadas etiquetas, y/o las líneas y barras están
desalineadas o faltan. Es necesario engañar a
matplotlib un poco ... pandas hace este truco más fácil
# empezar con datos falsos de
crecimiento porcentual s =
pd.Series(np.random.normal(
1.02, 0.015, 40))
Gráfico circular s = s.cumprod()
dfg = (pd.concat([s / s.shift(1),
s = pd.Series(datos=[10, 20, 30],
s / s.shift(4)], axis=1) * 100) - 100
index = ['perros', 'gatos',
dfg.columns = ['Trimestral', 'Anual']
'pájaros']) ax =
dfg.index = pd.period_range('2010-Q1',
s.plot.pie(autopct='%.1f')
periods=len(dfg), freq='Q')
# seguido de la salida estándar del
# reindexar con enteros desde 0;
gráfico ... ax.set_title('Gráfico circular')
mantener viejo viejo = dfg.index
ax.set_aspect(1) # hacerlo redondo
dfg.index = range(len(dfg))
ax.set_ylabel('') # eliminar por defecto
# traza la línea desde pandas
fig = ax.figure
ax = dfg['Anual'].plot(color='azul',
fig.set_size_inches(8, 3)
label='Crecimiento anual')
fig.savefig('filename.png', dpi=125)
# traza las barras de pandas
plt.close(fig)
dfg['Quarter'].plot.bar(ax=ax,
label='Crecimiento Q/Q', width=0.8)

# reetiquetar el eje x de forma más

apropiada ticks =
dfg.index[((dfg.index+0)%4)==0] labs =
pd.Series(old[ticks]).astype(str)
ax.set_xticks(ticks)
ax.set_xticklabels(labs.str.replace('Q',
'\nQ'), rotation=0)
Cambiar el rango trazado
# fijar el rango del eje x ... omitir 1ª
ax.set_xlim([-5, 5]) ax.set_xlim([0.5,len(dfg)-0.5])
# para algunos espacios en blanco en # añade la leyenda
el gráfico ... lower, upper = l=ax.legend(loc='best',fontsize='small')
ax.get_ylim() ax.set_ylim([lower-1,
upper+1]) # ax.set_title('Fake Growth Data')
ax.set_xlabel('Quarter')
Añadir una nota a pie de página al gráfico
ax.set_ylabel('Percent')
# después del fig.tight_layout(pad=1)
anterior fig = ax.figure
fig.text(0.99, 0.01, 'Nota al fig.set_size_inches(8, 3)
pie', ha='derecha', fig.tight_layout(pad=1)
va='abajo', fontsize='x- fig.savefig('filename.png', dpi=125)
pequeño',
fontstyle='cursiva', color='#999999') plt.close()

Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
on twitter]. 17
 Trabajar con datos omitidos y no finitos Trabajar con datos categóricos

Trabajar con datos que faltan Datos categóricos

Pandas utiliza la construcción not-a-number (np.nan y La serie pandas tiene un tipo de datos similar a los
float('nan')) para indicar datos que faltan. El valor None factores de R para codificar datos categóricos.
de Python también puede aparecer en los datos. s = Series(['a','b','a','c','b','d','a'],
También se trata como dato faltante; al igual que la dtype='categoría')
construcción de pandas not-a-time (pandas.NaT). df['B'] = df['A'].astype('categoría')
Nota: la clave aquí es especificar el tipo de dato
Datos que faltan en una serie "categoría". Nota: las categorías se ordenarán al crearse si
s = Series( [8,None,float('nan'),np.nan]) se pueden ordenar. Esto puede desactivarse. Ver
#[8, NaN, NaN, NaN] ordenación más abajo.
s.isnull() #[Falso, Cierto Cierto Verdad]
, , Convertir de nuevo al tipo de datos original
s.notnull()#[Verd Falso, Falso, Falso] s = Series(['a','b','a','c','b','d','a'],
adero, dtype='categoría')
s.fillna(0)#[8, 0, 0, 0] s = s.astype('cadena')
Datos que faltan en un DataFrame Ordenar, reordenar y clasificar
df = df.dropna() # elimina todas las filas s = Series(list('abc'), dtype='category')
con NaN df = df.dropna(axis=1) # lo mismo print (s.cat.ordered)
para cols df=df.dropna(how='all') # s=s.cat.reorder_categories(['b','c','a'])
elimina todas las filas NaN s = s.sort()
df=df.dropna(thresh=2) # elimina 2+ NaN en s.cat.ordered = False
r # sólo elimina filas si hay NaN en una col Trampa: la categoría debe estar ordenada para que se
Recodificación de
especificada df los
= datos que faltan clasifique
df.fillna(0, inplace=True)
df.dropna(df['col'].notnull())# np.nan � 0
s = df['col'].fillna(0) # np.nan � 0 Renombrar categorías
df = df.replace(r'\s+', np.nan, s = Series(list('abc'), dtype='category')
regex=True) # espacio en blanco p.nan s.cat.categories = [1, 2, 3] # en su lugar
�n s = s.cat.rename_categories([4,5,6])
# usando una comprensión ...
Números no finitos s.cat.categories = ['Grupo ' + str(i)
Con números de coma flotante, pandas for i in s.cat.categories]
proporciona infinito positivo y negativo. Trampa: las categorías deben tener un nombre único
s = Series([float('inf'), float('-inf'),
np.inf, -np.inf]) Añadir nuevas categorías
Pandas trata las comparaciones de enteros con más s = s.cat.añadir_categorías([4])
o menos infinito como se espera.
Eliminar categorías
Pruebas de números finitos s = s.cat.remove_categories([4])
(utilizando los datos del ejemplo anterior) s.cat.remove_unused_categories() #inplace
b = np.isfinite(s)

Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
on twitter]. 18
 Regresión
Trabajar con cuerdas
import statsmodels.formula.api as sm
resultado = sm.ols(formula="col1 ~ col2
Trabajar con cuerdas +
# supongamos que df['col'] es una serie col3", data=df).fit()
de cadenas s = df['col'].str.lower() print (result.params)
s = df['col'].str.upper() print (resultado.resumen())
s = df['col'].str.len() Ejemplo sencillo de alisado mediante una aplicación
rodante
# el siguiente conjunto funciona como k3x5 = np.array([1,2,3,3,3,2,1]) / 15.0
Python df['col'] += 'suffix' # añadir s = df['A'].rolling(window=len(k3x5),
df['col'] *= 2 # duplicar min_periods=len(k3x5),
s = df['col1'] + df['col2'] # concatenar center=True).apply(
func=lambda x: (x * k3x5).sum())
La mayoría de las funciones de cadena de Python se replican en# corrige los datos finales que faltan ...
los objetos DataFrame y Series de pandas. unsmoothed s =
df['A'].where(s.isnull(), other=s)
Expresiones regulares
s=
Nota de precaución
d f [ ' c o l ' ] . s t r .contains('regex') s
= df['col'].str.startswith('regex') s Esta hoja de trucos ha sido confeccionada por
= df['col'].str.endswith('regex') incansables robots que recorren los oscuros recovecos
s = df['col'].str.replace('antiguo',
Nota: pandas tiene muchos más métodos 'nuevo') de Internet en busca de mitos ursinos y anginos de una
df['b']
regex. = df.a.str.extract('(patrón)') legendaria tierra de leche y miel donde se rumorea que
los pandas y las pitones retozan juntos. No se garantiza
que las narraciones hayan sido captadas y transcritas
Estadísticas básicas con exactitud. Utilice estas notas bajo su propia
responsabilidad. Queda advertido. No seré responsable
de lo que le ocurra a usted y a sus seres queridos
Resumen estadístico cuando sus ojos empiecen a ver lo que aquí está
escrito.
s = d f ['col1'].describe()
df1 = df.describe()
Versión: Esta hoja de trucos se actualizó por última
vez teniendo en cuenta Python 3.6 y pandas 0.19.2.
DataFrame - métodos estadísticos clave
df.corr() # correlación por pares Errores: Si encuentra algún error, envíeme un correo
df.cov() cols electrónico a [email protected]; (pero, por
df.kurt() # covarianza por pares cols
favor, no corrija mi uso de las convenciones
df.mad() # curtosis sobre cols (def)
ortográficas del inglés australiano).
df.sem() # desviación media absoluta
df.var() # error estándar de la
media
# varianza sobre cols (def)
Recuento de valores
s = df['col1'].value_counts()

Tabulación cruzada (recuento de frecuencias)

ct = pd.crosstab(index=df['a'],
cols=df['b'])

Cuantiles y clasificación
cuantos = [0,05, 0,25, 0,5, 0,75, 0,95]
q = df.cuantil(cuantos)
r = df.rank()

Histograma
count, bins = np.histogram(df['col1'])
count, bins = np.histogram(df['col'],
bins=5)
count, bins = np.histogram(df['col1'],
bins=[-3,-2,-1,0,1,2,3,4])

Versión 30 de abril de 2017 - [Borrador - Mark Graph - mark dot the dot graph at gmail dot com - @Mark_Graph
on twitter]. 19