Python Pandas - Guía rápida
Pandas es una biblioteca de Python de código abierto que proporciona una herramienta de análisis y manipulación de datos de alto rendimiento utilizando sus poderosas estructuras de datos. El nombre Pandas se deriva de la palabra Panel Data, una econometría de datos multidimensionales.
En 2008, el desarrollador Wes McKinney comenzó a desarrollar pandas cuando necesitaba una herramienta flexible y de alto rendimiento para el análisis de datos.
Antes de Pandas, Python se usaba principalmente para la preparación y procesamiento de datos. Contribuyó muy poco al análisis de datos. Pandas resolvió este problema. Con Pandas, podemos lograr cinco pasos típicos en el procesamiento y análisis de datos, independientemente del origen de los datos: cargar, preparar, manipular, modelar y analizar.
Python con Pandas se utiliza en una amplia gama de campos, incluidos los dominios académicos y comerciales, que incluyen finanzas, economía, estadísticas, análisis, etc.
Características clave de los pandas
- Objeto DataFrame rápido y eficiente con indexación predeterminada y personalizada.
- Herramientas para cargar datos en objetos de datos en memoria desde diferentes formatos de archivo.
- Alineación de datos y manejo integrado de datos faltantes.
- Remodelación y rotación de conjuntos de fechas.
- División, indexación y subconjunto basado en etiquetas de grandes conjuntos de datos.
- Las columnas de una estructura de datos se pueden eliminar o insertar.
- Agrupar por datos para agregación y transformaciones.
- Fusión y unión de datos de alto rendimiento.
- Funcionalidad de series temporales.
La distribución estándar de Python no viene incluida con el módulo Pandas. Una alternativa ligera es instalar NumPy utilizando el popular instalador de paquetes de Python,pip.
pip install pandas
Si instala el paquete Anaconda Python, Pandas se instalará de forma predeterminada con lo siguiente:
Ventanas
Anaconda (desde https://www.continuum.io) es una distribución gratuita de Python para la pila SciPy. También está disponible para Linux y Mac.
Canopy (https://www.enthought.com/products/canopy/) está disponible como distribución gratuita y comercial con una pila completa de SciPy para Windows, Linux y Mac.
Python(x, y) es una distribución gratuita de Python con SciPy stack y Spyder IDE para el sistema operativo Windows. (Descargable desdehttp://python-xy.github.io/)
Linux
Los administradores de paquetes de las respectivas distribuciones de Linux se utilizan para instalar uno o más paquetes en la pila SciPy.
For Ubuntu Users
sudo apt-get install python-numpy python-scipy python-matplotlibipythonipythonnotebook
python-pandas python-sympy python-nose
For Fedora Users
sudo yum install numpyscipy python-matplotlibipython python-pandas sympy
python-nose atlas-devel
Pandas se ocupa de las siguientes tres estructuras de datos:
- Series
- DataFrame
- Panel
Estas estructuras de datos se construyen sobre la matriz Numpy, lo que significa que son rápidas.
Dimensión y descripción
La mejor manera de pensar en estas estructuras de datos es que la estructura de datos de mayor dimensión es un contenedor de su estructura de datos de menor dimensión. Por ejemplo, DataFrame es un contenedor de Series, Panel es un contenedor de DataFrame.
Estructura de datos | Dimensiones | Descripción |
---|---|---|
Serie | 1 | Matriz homogénea etiquetada 1D, tamaño inmutable. |
Marcos de datos | 2 | Estructura tabular de tamaño mutable etiquetada en 2D general con columnas potencialmente heterogéneas. |
Panel | 3 | Matriz general con etiqueta 3D, tamaño mutable. |
La construcción y el manejo de matrices bidimensionales es una tarea tediosa, el usuario tiene la carga de considerar la orientación del conjunto de datos al escribir funciones. Pero al usar las estructuras de datos de Pandas, se reduce el esfuerzo mental del usuario.
Por ejemplo, con datos tabulares (DataFrame) es más útil semánticamente pensar en el index (las filas) y el columns en lugar del eje 0 y el eje 1.
Mutabilidad
Todas las estructuras de datos de Pandas tienen valor mutable (se pueden cambiar) y, excepto Series, todas son de tamaño mutable. La serie es de tamaño inmutable.
Note- DataFrame se utiliza ampliamente y es una de las estructuras de datos más importantes. El panel se usa mucho menos.
Serie
La serie es una estructura similar a una matriz unidimensional con datos homogéneos. Por ejemplo, la siguiente serie es una colección de números enteros 10, 23, 56,…
10 | 23 | 56 | 17 | 52 | 61 | 73 | 90 | 26 | 72 |
Puntos clave
- Datos homogéneos
- Tamaño inmutable
- Valores de datos mutables
Marco de datos
DataFrame es una matriz bidimensional con datos heterogéneos. Por ejemplo,
Nombre | Años | Género | Clasificación |
---|---|---|---|
Steve | 32 | Masculino | 3,45 |
Lia | 28 | Hembra | 4.6 |
Vin | 45 | Masculino | 3.9 |
Katie | 38 | Hembra | 2,78 |
La tabla representa los datos de un equipo de ventas de una organización con su calificación de desempeño general. Los datos se representan en filas y columnas. Cada columna representa un atributo y cada fila representa a una persona.
Tipo de datos de columnas
Los tipos de datos de las cuatro columnas son los siguientes:
Columna | Tipo |
---|---|
Nombre | Cuerda |
Años | Entero |
Género | Cuerda |
Clasificación | Flotador |
Puntos clave
- Datos heterogéneos
- Tamaño mutable
- Datos mutables
Panel
El panel es una estructura de datos tridimensional con datos heterogéneos. Es difícil representar el panel en representación gráfica. Pero un panel se puede ilustrar como un contenedor de DataFrame.
Puntos clave
- Datos heterogéneos
- Tamaño mutable
- Datos mutables
La serie es una matriz etiquetada unidimensional capaz de contener datos de cualquier tipo (entero, cadena, flotante, objetos de Python, etc.). Las etiquetas de los ejes se denominan colectivamente índice.
pandas.Series
Se puede crear una serie pandas usando el siguiente constructor:
pandas.Series( data, index, dtype, copy)
Los parámetros del constructor son los siguientes:
No Señor | Descripción de parámetros |
---|---|
1 | data los datos toman varias formas como ndarray, lista, constantes |
2 | index Los valores de índice deben ser únicos y con capacidad hash, de la misma longitud que los datos. Defectonp.arange(n) si no se pasa ningún índice. |
3 | dtype dtype es para el tipo de datos. Si es Ninguno, se inferirá el tipo de datos |
4 | copy Copiar datos. Falso predeterminado |
Se puede crear una serie usando varias entradas como:
- Array
- Dict
- Valor escalar o constante
Crea una serie vacía
Una serie básica que se puede crear es una serie vacía.
Ejemplo
#import the pandas library and aliasing as pd
import pandas as pd
s = pd.Series()
print s
Sus output es como sigue -
Series([], dtype: float64)
Crea una serie a partir de ndarray
Si los datos son ndarray, el índice pasado debe tener la misma longitud. Si no se pasa ningún índice, el índice predeterminado serárange(n) dónde n es la longitud de la matriz, es decir, [0,1,2,3…. range(len(array))-1].
Ejemplo 1
#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
s = pd.Series(data)
print s
Sus output es como sigue -
0 a
1 b
2 c
3 d
dtype: object
No pasamos ningún índice, por lo que de forma predeterminada, asignó los índices que van de 0 a len(data)-1, es decir, de 0 a 3.
Ejemplo 2
#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
s = pd.Series(data,index=[100,101,102,103])
print s
Sus output es como sigue -
100 a
101 b
102 c
103 d
dtype: object
Pasamos los valores del índice aquí. Ahora podemos ver los valores indexados personalizados en la salida.
Crear una serie a partir de dict
UN dictse puede pasar como entrada y si no se especifica ningún índice, las claves del diccionario se toman en un orden ordenado para construir el índice. Siindex se pasa, los valores en los datos correspondientes a las etiquetas en el índice se extraerán.
Ejemplo 1
#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data)
print s
Sus output es como sigue -
a 0.0
b 1.0
c 2.0
dtype: float64
Observe - Las claves de diccionario se utilizan para construir índices.
Ejemplo 2
#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data,index=['b','c','d','a'])
print s
Sus output es como sigue -
b 1.0
c 2.0
d NaN
a 0.0
dtype: float64
Observe - El orden del índice se mantiene y el elemento que falta se rellena con NaN (no es un número).
Crear una serie a partir de escalar
Si los datos son un valor escalar, se debe proporcionar un índice. El valor se repetirá para coincidir con la longitud deindex
#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
s = pd.Series(5, index=[0, 1, 2, 3])
print s
Sus output es como sigue -
0 5
1 5
2 5
3 5
dtype: int64
Acceso a datos de series con posición
Se puede acceder a los datos de la serie de forma similar a la de un ndarray.
Ejemplo 1
Recupera el primer elemento. Como ya sabemos, el conteo comienza desde cero para la matriz, lo que significa que el primer elemento se almacena en la posición cero y así sucesivamente.
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#retrieve the first element
print s[0]
Sus output es como sigue -
1
Ejemplo 2
Recupera los tres primeros elementos de la serie. Si se inserta un: delante de él, se extraerán todos los elementos de ese índice en adelante. Si se utilizan dos parámetros (con: entre ellos), los elementos entre los dos índices (sin incluir el índice de parada)
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#retrieve the first three element
print s[:3]
Sus output es como sigue -
a 1
b 2
c 3
dtype: int64
Ejemplo 3
Recupera los últimos tres elementos.
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#retrieve the last three element
print s[-3:]
Sus output es como sigue -
c 3
d 4
e 5
dtype: int64
Recuperar datos mediante etiqueta (índice)
Una serie es como un tamaño fijo dict ya que puede obtener y establecer valores por etiqueta de índice.
Ejemplo 1
Recupere un solo elemento usando el valor de la etiqueta de índice.
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#retrieve a single element
print s['a']
Sus output es como sigue -
1
Ejemplo 2
Recupere varios elementos mediante una lista de valores de etiqueta de índice.
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#retrieve multiple elements
print s[['a','c','d']]
Sus output es como sigue -
a 1
c 3
d 4
dtype: int64
Ejemplo 3
Si no se incluye una etiqueta, se genera una excepción.
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#retrieve multiple elements
print s['f']
Sus output es como sigue -
…
KeyError: 'f'
Un marco de datos es una estructura de datos bidimensional, es decir, los datos se alinean de forma tabular en filas y columnas.
Características de DataFrame
- Potencialmente, las columnas son de diferentes tipos
- Tamaño: mutable
- Ejes etiquetados (filas y columnas)
- Puede realizar operaciones aritméticas en filas y columnas
Estructura
Supongamos que estamos creando un marco de datos con los datos del estudiante.
Puede pensar en ello como una tabla SQL o una representación de datos de hoja de cálculo.
pandas.DataFrame
Se puede crear un DataFrame de pandas usando el siguiente constructor:
pandas.DataFrame( data, index, columns, dtype, copy)
Los parámetros del constructor son los siguientes:
No Señor | Descripción de parámetros |
---|---|
1 | data los datos toman varias formas como ndarray, series, mapas, listas, dict, constantes y también otro DataFrame. |
2 | index Para las etiquetas de fila, el índice que se utilizará para el marco resultante es opcional predeterminado np.arange (n) si no se pasa ningún índice. |
3 | columns Para las etiquetas de columna, la sintaxis predeterminada opcional es - np.arange (n). Esto solo es cierto si no se pasa ningún índice. |
4 | dtype Tipo de datos de cada columna. |
5 | copy Este comando (o lo que sea) se utiliza para copiar datos, si el valor predeterminado es Falso. |
Crear DataFrame
Se puede crear un DataFrame de pandas usando varias entradas como:
- Lists
- dict
- Series
- Numpy ndarrays
- Otro DataFrame
En las siguientes secciones de este capítulo, veremos cómo crear un DataFrame usando estas entradas.
Crear un marco de datos vacío
Un DataFrame básico, que se puede crear, es un Dataframe vacío.
Ejemplo
#import the pandas library and aliasing as pd
import pandas as pd
df = pd.DataFrame()
print df
Sus output es como sigue -
Empty DataFrame
Columns: []
Index: []
Crear un DataFrame a partir de listas
El DataFrame se puede crear usando una sola lista o una lista de listas.
Ejemplo 1
import pandas as pd
data = [1,2,3,4,5]
df = pd.DataFrame(data)
print df
Sus output es como sigue -
0
0 1
1 2
2 3
3 4
4 5
Ejemplo 2
import pandas as pd
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'])
print df
Sus output es como sigue -
Name Age
0 Alex 10
1 Bob 12
2 Clarke 13
Ejemplo 3
import pandas as pd
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'],dtype=float)
print df
Sus output es como sigue -
Name Age
0 Alex 10.0
1 Bob 12.0
2 Clarke 13.0
Note - Observa, el dtype El parámetro cambia el tipo de columna Edad a punto flotante.
Cree un DataFrame a partir de Dict of ndarrays / Lists
Todos ndarraysdebe tener la misma longitud. Si se pasa el índice, entonces la longitud del índice debe ser igual a la longitud de las matrices.
Si no se pasa ningún índice, por defecto, el índice será rango (n), donde n es la longitud de la matriz.
Ejemplo 1
import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data)
print df
Sus output es como sigue -
Age Name
0 28 Tom
1 34 Jack
2 29 Steve
3 42 Ricky
Note- Observar los valores 0,1,2,3. Son el índice predeterminado asignado a cada uno que usa el rango de función (n).
Ejemplo 2
Creemos ahora un DataFrame indexado usando matrices.
import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data, index=['rank1','rank2','rank3','rank4'])
print df
Sus output es como sigue -
Age Name
rank1 28 Tom
rank2 34 Jack
rank3 29 Steve
rank4 42 Ricky
Note - Observa, el index El parámetro asigna un índice a cada fila.
Crear un marco de datos a partir de la lista de dictados
La lista de diccionarios se puede pasar como datos de entrada para crear un DataFrame. Las claves del diccionario se toman por defecto como nombres de columna.
Ejemplo 1
El siguiente ejemplo muestra cómo crear un DataFrame pasando una lista de diccionarios.
import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data)
print df
Sus output es como sigue -
a b c
0 1 2 NaN
1 5 10 20.0
Note - Observe, se agrega NaN (No es un número) en las áreas faltantes.
Ejemplo 2
El siguiente ejemplo muestra cómo crear un DataFrame pasando una lista de diccionarios y los índices de fila.
import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data, index=['first', 'second'])
print df
Sus output es como sigue -
a b c
first 1 2 NaN
second 5 10 20.0
Ejemplo 3
El siguiente ejemplo muestra cómo crear un DataFrame con una lista de diccionarios, índices de fila e índices de columna.
import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
#With two column indices, values same as dictionary keys
df1 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b'])
#With two column indices with one index with other name
df2 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b1'])
print df1
print df2
Sus output es como sigue -
#df1 output
a b
first 1 2
second 5 10
#df2 output
a b1
first 1 NaN
second 5 NaN
Note- Observe, df2 DataFrame se crea con un índice de columna diferente a la clave del diccionario; por lo tanto, agregó los NaN en su lugar. Considerando que, df1 se crea con índices de columna igual que las claves del diccionario, por lo que se adjunta NaN.
Crear un DataFrame a partir de Dict of Series
El Diccionario de Series se puede pasar para formar un DataFrame. El índice resultante es la unión de todos los índices de la serie aprobados.
Ejemplo
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print df
Sus output es como sigue -
one two
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4
Note - Observe, para la serie uno, no hay etiqueta ‘d’ pasado, pero en el resultado, para el d etiqueta, NaN se adjunta con NaN.
Ahora entendamos column selection, additiony deletion a través de ejemplos.
Selección de columna
Comprenderemos esto seleccionando una columna del DataFrame.
Ejemplo
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print df ['one']
Sus output es como sigue -
a 1.0
b 2.0
c 3.0
d NaN
Name: one, dtype: float64
Adición de columnas
Comprenderemos esto agregando una nueva columna a un marco de datos existente.
Ejemplo
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
# Adding a new column to an existing DataFrame object with column label by passing new series
print ("Adding a new column by passing as Series:")
df['three']=pd.Series([10,20,30],index=['a','b','c'])
print df
print ("Adding a new column using the existing columns in DataFrame:")
df['four']=df['one']+df['three']
print df
Sus output es como sigue -
Adding a new column by passing as Series:
one two three
a 1.0 1 10.0
b 2.0 2 20.0
c 3.0 3 30.0
d NaN 4 NaN
Adding a new column using the existing columns in DataFrame:
one two three four
a 1.0 1 10.0 11.0
b 2.0 2 20.0 22.0
c 3.0 3 30.0 33.0
d NaN 4 NaN NaN
Eliminación de columnas
Las columnas se pueden eliminar o saltar; tomemos un ejemplo para entender cómo.
Ejemplo
# Using the previous DataFrame, we will delete a column
# using del function
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd']),
'three' : pd.Series([10,20,30], index=['a','b','c'])}
df = pd.DataFrame(d)
print ("Our dataframe is:")
print df
# using del function
print ("Deleting the first column using DEL function:")
del df['one']
print df
# using pop function
print ("Deleting another column using POP function:")
df.pop('two')
print df
Sus output es como sigue -
Our dataframe is:
one three two
a 1.0 10.0 1
b 2.0 20.0 2
c 3.0 30.0 3
d NaN NaN 4
Deleting the first column using DEL function:
three two
a 10.0 1
b 20.0 2
c 30.0 3
d NaN 4
Deleting another column using POP function:
three
a 10.0
b 20.0
c 30.0
d NaN
Selección, adición y eliminación de filas
Ahora entenderemos la selección, adición y eliminación de filas a través de ejemplos. Comencemos por el concepto de selección.
Selección por etiqueta
Las filas se pueden seleccionar pasando la etiqueta de fila a un loc función.
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print df.loc['b']
Sus output es como sigue -
one 2.0
two 2.0
Name: b, dtype: float64
El resultado es una serie con etiquetas como nombres de columna del DataFrame. Y, el Nombre de la serie es la etiqueta con la que se recupera.
Selección por ubicación de entero
Las filas se pueden seleccionar pasando la ubicación del número entero a un iloc función.
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print df.iloc[2]
Sus output es como sigue -
one 3.0
two 3.0
Name: c, dtype: float64
Filas de rebanadas
Se pueden seleccionar varias filas usando el operador ':'.
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print df[2:4]
Sus output es como sigue -
one two
c 3.0 3
d NaN 4
Suma de filas
Agregue nuevas filas a un DataFrame usando el appendfunción. Esta función agregará las filas al final.
import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
df = df.append(df2)
print df
Sus output es como sigue -
a b
0 1 2
1 3 4
0 5 6
1 7 8
Eliminación de filas
Use la etiqueta de índice para eliminar o quitar filas de un DataFrame. Si la etiqueta está duplicada, se eliminarán varias filas.
Si observa, en el ejemplo anterior, las etiquetas están duplicadas. Dejemos caer una etiqueta y veremos cuántas filas se eliminarán.
import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
df = df.append(df2)
# Drop rows with label 0
df = df.drop(0)
print df
Sus output es como sigue -
a b
1 3 4
1 7 8
En el ejemplo anterior, se descartaron dos filas porque esas dos contienen la misma etiqueta 0.
UN paneles un contenedor de datos 3D. El terminoPanel data se deriva de la econometría y es parcialmente responsable del nombre pandas - pan(el)-da(ta)-s.
Los nombres de los 3 ejes están destinados a dar algún significado semántico a la descripción de operaciones que involucran datos de panel. Ellos son -
items - eje 0, cada elemento corresponde a un DataFrame contenido en su interior.
major_axis - eje 1, es el índice (filas) de cada uno de los DataFrames.
minor_axis - eje 2, son las columnas de cada uno de los DataFrames.
pandas.Panel ()
Se puede crear un Panel usando el siguiente constructor:
pandas.Panel(data, items, major_axis, minor_axis, dtype, copy)
Los parámetros del constructor son los siguientes:
Parámetro | Descripción |
---|---|
datos | Los datos toman varias formas como ndarray, series, mapas, listas, dict, constantes y también otro DataFrame |
artículos | eje = 0 |
eje_mayor | eje = 1 |
eje_minor | eje = 2 |
dtype | Tipo de datos de cada columna |
Copiar | Copiar datos. Defecto,false |
Crear panel
Un panel se puede crear usando varias formas como:
- De ndarrays
- De dict de DataFrames
Desde 3D ndarray
# creating an empty panel
import pandas as pd
import numpy as np
data = np.random.rand(2,4,5)
p = pd.Panel(data)
print p
Sus output es como sigue -
<class 'pandas.core.panel.Panel'>
Dimensions: 2 (items) x 4 (major_axis) x 5 (minor_axis)
Items axis: 0 to 1
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 4
Note - Observe las dimensiones del panel vacío y el panel de arriba, todos los objetos son diferentes.
De dict of DataFrame Objects
#creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),
'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p
Sus output es como sigue -
Dimensions: 2 (items) x 4 (major_axis) x 3 (minor_axis)
Items axis: Item1 to Item2
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 2
Crear un panel vacío
Se puede crear un panel vacío usando el constructor Panel de la siguiente manera:
#creating an empty panel
import pandas as pd
p = pd.Panel()
print p
Sus output es como sigue -
<class 'pandas.core.panel.Panel'>
Dimensions: 0 (items) x 0 (major_axis) x 0 (minor_axis)
Items axis: None
Major_axis axis: None
Minor_axis axis: None
Seleccionar los datos del panel
Seleccione los datos del panel usando -
- Items
- Major_axis
- Minor_axis
Usar elementos
# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),
'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p['Item1']
Sus output es como sigue -
0 1 2
0 0.488224 -0.128637 0.930817
1 0.417497 0.896681 0.576657
2 -2.775266 0.571668 0.290082
3 -0.400538 -0.144234 1.110535
Tenemos dos elementos y recuperamos el elemento 1. El resultado es un DataFrame con 4 filas y 3 columnas, que son lasMajor_axis y Minor_axis dimensiones.
Usando major_axis
Se puede acceder a los datos utilizando el método panel.major_axis(index).
# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),
'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p.major_xs(1)
Sus output es como sigue -
Item1 Item2
0 0.417497 0.748412
1 0.896681 -0.557322
2 0.576657 NaN
Usando minor_axis
Se puede acceder a los datos utilizando el método panel.minor_axis(index).
# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),
'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p.minor_xs(1)
Sus output es como sigue -
Item1 Item2
0 -0.128637 -1.047032
1 0.896681 -0.557322
2 0.571668 0.431953
3 -0.144234 1.302466
Note - Observe los cambios en las dimensiones.
A estas alturas, aprendimos sobre las tres estructuras de datos de Pandas y cómo crearlas. Nos centraremos principalmente en los objetos DataFrame debido a su importancia en el procesamiento de datos en tiempo real y también discutiremos algunas otras estructuras de datos.
Funcionalidad básica de la serie
No Señor. | Atributo o método y descripción |
---|---|
1 | axes Devuelve una lista de las etiquetas del eje de fila. |
2 | dtype Devuelve el dtype del objeto. |
3 | empty Devuelve True si la serie está vacía. |
4 | ndim Devuelve el número de dimensiones de los datos subyacentes, por definición 1. |
5 | size Devuelve el número de elementos de los datos subyacentes. |
6 | values Devuelve la serie como ndarray. |
7 | head() Devuelve las primeras n filas. |
8 | tail() Devuelve las últimas n filas. |
Creemos ahora una Serie y veamos todas las operaciones de atributos tabulados anteriores.
Ejemplo
import pandas as pd
import numpy as np
#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print s
Sus output es como sigue -
0 0.967853
1 -0.148368
2 -1.395906
3 -1.758394
dtype: float64
ejes
Devuelve la lista de las etiquetas de la serie.
import pandas as pd
import numpy as np
#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print ("The axes are:")
print s.axes
Sus output es como sigue -
The axes are:
[RangeIndex(start=0, stop=4, step=1)]
El resultado anterior es un formato compacto de una lista de valores de 0 a 5, es decir, [0,1,2,3,4].
vacío
Devuelve el valor booleano que indica si el objeto está vacío o no. Verdadero indica que el objeto está vacío.
import pandas as pd
import numpy as np
#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print ("Is the Object empty?")
print s.empty
Sus output es como sigue -
Is the Object empty?
False
ndim
Devuelve el número de dimensiones del objeto. Por definición, una serie es una estructura de datos 1D, por lo que devuelve
import pandas as pd
import numpy as np
#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print s
print ("The dimensions of the object:")
print s.ndim
Sus output es como sigue -
0 0.175898
1 0.166197
2 -0.609712
3 -1.377000
dtype: float64
The dimensions of the object:
1
Talla
Devuelve el tamaño (longitud) de la serie.
import pandas as pd
import numpy as np
#Create a series with 4 random numbers
s = pd.Series(np.random.randn(2))
print s
print ("The size of the object:")
print s.size
Sus output es como sigue -
0 3.078058
1 -1.207803
dtype: float64
The size of the object:
2
valores
Devuelve los datos reales de la serie como una matriz.
import pandas as pd
import numpy as np
#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print s
print ("The actual data series is:")
print s.values
Sus output es como sigue -
0 1.787373
1 -0.605159
2 0.180477
3 -0.140922
dtype: float64
The actual data series is:
[ 1.78737302 -0.60515881 0.18047664 -0.1409218 ]
La cabeza de la cola
Para ver una pequeña muestra de un objeto Series o DataFrame, use los métodos head () y tail ().
head() devuelve el primero nfilas (observe los valores del índice). El número predeterminado de elementos para mostrar es cinco, pero puede pasar un número personalizado.
import pandas as pd
import numpy as np
#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print ("The original series is:")
print s
print ("The first two rows of the data series:")
print s.head(2)
Sus output es como sigue -
The original series is:
0 0.720876
1 -0.765898
2 0.479221
3 -0.139547
dtype: float64
The first two rows of the data series:
0 0.720876
1 -0.765898
dtype: float64
tail() devuelve el último nfilas (observe los valores del índice). El número predeterminado de elementos para mostrar es cinco, pero puede pasar un número personalizado.
import pandas as pd
import numpy as np
#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print ("The original series is:")
print s
print ("The last two rows of the data series:")
print s.tail(2)
Sus output es como sigue -
The original series is:
0 -0.655091
1 -0.881407
2 -0.608592
3 -2.341413
dtype: float64
The last two rows of the data series:
2 -0.608592
3 -2.341413
dtype: float64
Funcionalidad básica de DataFrame
Entendamos ahora qué es la funcionalidad básica de DataFrame. Las siguientes tablas enumeran los atributos o métodos importantes que ayudan en la funcionalidad básica de DataFrame.
No Señor. | Atributo o método y descripción |
---|---|
1 | T Transpone filas y columnas. |
2 | axes Devuelve una lista con las etiquetas del eje de fila y las etiquetas del eje de columna como únicos miembros. |
3 | dtypes Devuelve los dtypes de este objeto. |
4 | empty Verdadero si NDFrame está completamente vacío [sin elementos]; si alguno de los ejes tiene longitud 0. |
5 | ndim Número de ejes / dimensiones de matriz. |
6 | shape Devuelve una tupla que representa la dimensionalidad del DataFrame. |
7 | size Número de elementos del NDFrame. |
8 | values Representación voluminosa de NDFrame. |
9 | head() Devuelve las primeras n filas. |
10 | tail() Devuelve las últimas n filas. |
Creemos ahora un DataFrame y veamos cómo funcionan los atributos mencionados anteriormente.
Ejemplo
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data series is:")
print df
Sus output es como sigue -
Our data series is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
T (transponer)
Devuelve la transposición del DataFrame. Las filas y columnas se intercambiarán.
import pandas as pd
import numpy as np
# Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
# Create a DataFrame
df = pd.DataFrame(d)
print ("The transpose of the data series is:")
print df.T
Sus output es como sigue -
The transpose of the data series is:
0 1 2 3 4 5 6
Age 25 26 25 23 30 29 23
Name Tom James Ricky Vin Steve Smith Jack
Rating 4.23 3.24 3.98 2.56 3.2 4.6 3.8
ejes
Devuelve la lista de etiquetas de eje de fila y etiquetas de eje de columna.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Row axis labels and column axis labels are:")
print df.axes
Sus output es como sigue -
Row axis labels and column axis labels are:
[RangeIndex(start=0, stop=7, step=1), Index([u'Age', u'Name', u'Rating'],
dtype='object')]
dtipos
Devuelve el tipo de datos de cada columna.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("The data types of each column are:")
print df.dtypes
Sus output es como sigue -
The data types of each column are:
Age int64
Name object
Rating float64
dtype: object
vacío
Devuelve el valor booleano que indica si el objeto está vacío o no; Verdadero indica que el objeto está vacío.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Is the object empty?")
print df.empty
Sus output es como sigue -
Is the object empty?
False
ndim
Devuelve el número de dimensiones del objeto. Por definición, DataFrame es un objeto 2D.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The dimension of the object is:")
print df.ndim
Sus output es como sigue -
Our object is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The dimension of the object is:
2
forma
Devuelve una tupla que representa la dimensionalidad del DataFrame. Tupla (a, b), donde a representa el número de filas yb representa el número de columnas.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The shape of the object is:")
print df.shape
Sus output es como sigue -
Our object is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The shape of the object is:
(7, 3)
Talla
Devuelve el número de elementos del DataFrame.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The total number of elements in our object is:")
print df.size
Sus output es como sigue -
Our object is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The total number of elements in our object is:
21
valores
Devuelve los datos reales en el DataFrame como un NDarray.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The actual data in our data frame is:")
print df.values
Sus output es como sigue -
Our object is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The actual data in our data frame is:
[[25 'Tom' 4.23]
[26 'James' 3.24]
[25 'Ricky' 3.98]
[23 'Vin' 2.56]
[30 'Steve' 3.2]
[29 'Smith' 4.6]
[23 'Jack' 3.8]]
La cabeza de la cola
Para ver una pequeña muestra de un objeto DataFrame, use el head() y métodos tail (). head() devuelve el primero nfilas (observe los valores del índice). El número predeterminado de elementos para mostrar es cinco, pero puede pasar un número personalizado.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data frame is:")
print df
print ("The first two rows of the data frame is:")
print df.head(2)
Sus output es como sigue -
Our data frame is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The first two rows of the data frame is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
tail() devuelve el último nfilas (observe los valores del índice). El número predeterminado de elementos para mostrar es cinco, pero puede pasar un número personalizado.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data frame is:")
print df
print ("The last two rows of the data frame is:")
print df.tail(2)
Sus output es como sigue -
Our data frame is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The last two rows of the data frame is:
Age Name Rating
5 29 Smith 4.6
6 23 Jack 3.8
Una gran cantidad de métodos calculan colectivamente estadísticas descriptivas y otras operaciones relacionadas en DataFrame. La mayoría de estas son agregaciones comosum(), mean(), pero algunos de ellos, como sumsum(), producir un objeto del mismo tamaño. En general, estos métodos requierenaxisargumento, como ndarray. {sum, std, ...}, pero el eje se puede especificar por nombre o entero
DataFrame - "índice" (eje = 0, predeterminado), "columnas" (eje = 1)
Creemos un DataFrame y usemos este objeto a lo largo de este capítulo para todas las operaciones.
Ejemplo
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df
Sus output es como sigue -
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
7 34 Lee 3.78
8 40 David 2.98
9 30 Gasper 4.80
10 51 Betina 4.10
11 46 Andres 3.65
suma()
Devuelve la suma de los valores del eje solicitado. Por defecto, el eje es el índice (eje = 0).
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.sum()
Sus output es como sigue -
Age 382
Name TomJamesRickyVinSteveSmithJackLeeDavidGasperBe...
Rating 44.92
dtype: object
Cada columna individual se agrega individualmente (se agregan cadenas).
eje = 1
Esta sintaxis dará el resultado que se muestra a continuación.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.sum(1)
Sus output es como sigue -
0 29.23
1 29.24
2 28.98
3 25.56
4 33.20
5 33.60
6 26.80
7 37.78
8 42.98
9 34.80
10 55.10
11 49.65
dtype: float64
media()
Devuelve el valor medio.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.mean()
Sus output es como sigue -
Age 31.833333
Rating 3.743333
dtype: float64
std ()
Devuelve la desviación estándar de Bressel de las columnas numéricas.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.std()
Sus output es como sigue -
Age 9.232682
Rating 0.661628
dtype: float64
Funciones y descripción
Entendamos ahora las funciones en Estadísticas descriptivas en Python Pandas. La siguiente tabla enumera las funciones importantes:
No Señor. | Función | Descripción |
---|---|---|
1 | contar() | Número de observaciones no nulas |
2 | suma() | Suma de valores |
3 | media() | Media de valores |
4 | mediana() | Mediana de valores |
5 | modo() | Modo de valores |
6 | std () | Desviación estándar de los valores |
7 | min () | Valor mínimo |
8 | max () | Valor máximo |
9 | abdominales() | Valor absoluto |
10 | pinchar() | Producto de valores |
11 | cumsum () | Suma acumulada |
12 | cumprod () | Producto acumulativo |
Note- Dado que DataFrame es una estructura de datos heterogénea. Las operaciones genéricas no funcionan con todas las funciones.
Funciones como sum(), cumsum()trabajar con elementos de datos de cadena tanto numéricos como de caracteres (o) sin ningún error. Aunquen En la práctica, las agregaciones de caracteres nunca se usan en general, estas funciones no arrojan ninguna excepción.
Funciones como abs(), cumprod() lanzar una excepción cuando el DataFrame contiene datos de caracteres o cadenas porque tales operaciones no se pueden realizar.
Resumen de datos
los describe() La función calcula un resumen de estadísticas pertenecientes a las columnas de DataFrame.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.describe()
Sus output es como sigue -
Age Rating
count 12.000000 12.000000
mean 31.833333 3.743333
std 9.232682 0.661628
min 23.000000 2.560000
25% 25.000000 3.230000
50% 29.500000 3.790000
75% 35.500000 4.132500
max 51.000000 4.800000
Esta función da mean, std y IQRvalores. Y la función excluye las columnas de caracteres y un resumen dado sobre las columnas numéricas.'include'es el argumento que se utiliza para transmitir la información necesaria sobre qué columnas deben considerarse para resumir. Toma la lista de valores; por defecto, 'número'.
- object - Resume columnas de cadena
- number - Resume columnas numéricas
- all - Resume todas las columnas juntas (no debe pasarlo como un valor de lista)
Ahora, use la siguiente declaración en el programa y verifique la salida:
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.describe(include=['object'])
Sus output es como sigue -
Name
count 12
unique 12
top Ricky
freq 1
Ahora, use la siguiente declaración y verifique el resultado:
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df. describe(include='all')
Sus output es como sigue -
Age Name Rating
count 12.000000 12 12.000000
unique NaN 12 NaN
top NaN Ricky NaN
freq NaN 1 NaN
mean 31.833333 NaN 3.743333
std 9.232682 NaN 0.661628
min 23.000000 NaN 2.560000
25% 25.000000 NaN 3.230000
50% 29.500000 NaN 3.790000
75% 35.500000 NaN 4.132500
max 51.000000 NaN 4.800000
Para aplicar sus propias funciones o las de otra biblioteca a los objetos Pandas, debe conocer los tres métodos importantes. Los métodos se comentan a continuación. El método apropiado a usar depende de si su función espera operar en un DataFrame completo, en filas o columnas, o en elementos.
- Aplicación de la función de tabla: pipe ()
- Aplicación de la función de fila o columna: aplicar ()
- Aplicación de función inteligente de elementos: applymap ()
Aplicación de función de tabla
Las operaciones personalizadas se pueden realizar pasando la función y el número apropiado de parámetros como argumentos de canalización. Por lo tanto, la operación se realiza en todo el DataFrame.
Por ejemplo, agregue un valor 2 a todos los elementos del DataFrame. Luego,
función sumadora
La función sumadora agrega dos valores numéricos como parámetros y devuelve la suma.
def adder(ele1,ele2):
return ele1+ele2
Ahora usaremos la función personalizada para realizar operaciones en el DataFrame.
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.pipe(adder,2)
Veamos el programa completo -
import pandas as pd
import numpy as np
def adder(ele1,ele2):
return ele1+ele2
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.pipe(adder,2)
print df.apply(np.mean)
Sus output es como sigue -
col1 col2 col3
0 2.176704 2.219691 1.509360
1 2.222378 2.422167 3.953921
2 2.241096 1.135424 2.696432
3 2.355763 0.376672 1.182570
4 2.308743 2.714767 2.130288
Aplicación de función de fila o columna
Las funciones arbitrarias se pueden aplicar a lo largo de los ejes de un DataFrame o Panel usando el apply()método, que, como los métodos de estadística descriptiva, toma un argumento de eje opcional. De forma predeterminada, la operación se realiza en columnas, tomando cada columna como una matriz.
Ejemplo 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(np.mean)
print df.apply(np.mean)
Sus output es como sigue -
col1 -0.288022
col2 1.044839
col3 -0.187009
dtype: float64
Pasando axis parámetro, las operaciones se pueden realizar por filas.
Ejemplo 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(np.mean,axis=1)
print df.apply(np.mean)
Sus output es como sigue -
col1 0.034093
col2 -0.152672
col3 -0.229728
dtype: float64
Ejemplo 3
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(lambda x: x.max() - x.min())
print df.apply(np.mean)
Sus output es como sigue -
col1 -0.167413
col2 -0.370495
col3 -0.707631
dtype: float64
Aplicación de la función Element Wise
No todas las funciones se pueden vectorizar (ni las matrices NumPy que devuelven otra matriz ni ningún valor), los métodos applymap() en DataFrame y analogously map() on Series acepta cualquier función de Python que tome un solo valor y devuelva un solo valor.
Ejemplo 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
# My custom function
df['col1'].map(lambda x:x*100)
print df.apply(np.mean)
Sus output es como sigue -
col1 0.480742
col2 0.454185
col3 0.266563
dtype: float64
Ejemplo 2
import pandas as pd
import numpy as np
# My custom function
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.applymap(lambda x:x*100)
print df.apply(np.mean)
Sus output es como sigue -
col1 0.395263
col2 0.204418
col3 -0.795188
dtype: float64
Reindexingcambia las etiquetas de fila y columna de un DataFrame. Para indexar medios para conformar los datos para que coincida con un determinado conjunto de etiquetas a lo largo de un eje particular.
Se pueden realizar múltiples operaciones mediante la indexación como:
Reordene los datos existentes para que coincidan con un nuevo conjunto de etiquetas.
Inserte marcadores de valor faltante (NA) en ubicaciones de etiquetas donde no existían datos para la etiqueta.
Ejemplo
import pandas as pd
import numpy as np
N=20
df = pd.DataFrame({
'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
'x': np.linspace(0,stop=N-1,num=N),
'y': np.random.rand(N),
'C': np.random.choice(['Low','Medium','High'],N).tolist(),
'D': np.random.normal(100, 10, size=(N)).tolist()
})
#reindex the DataFrame
df_reindexed = df.reindex(index=[0,2,5], columns=['A', 'C', 'B'])
print df_reindexed
Sus output es como sigue -
A C B
0 2016-01-01 Low NaN
2 2016-01-03 High NaN
5 2016-01-06 Low NaN
Reindexar para alinear con otros objetos
Es posible que desee tomar un objeto y volver a indexar sus ejes para etiquetarlo igual que otro objeto. Considere el siguiente ejemplo para entender lo mismo.
Ejemplo
import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.random.randn(10,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(7,3),columns=['col1','col2','col3'])
df1 = df1.reindex_like(df2)
print df1
Sus output es como sigue -
col1 col2 col3
0 -2.467652 -1.211687 -0.391761
1 -0.287396 0.522350 0.562512
2 -0.255409 -0.483250 1.866258
3 -1.150467 -0.646493 -0.222462
4 0.152768 -2.056643 1.877233
5 -1.155997 1.528719 -1.343719
6 -1.015606 -1.245936 -0.295275
Note - Aquí, el df1 DataFrame se modifica y se vuelve a indexar como df2. Los nombres de las columnas deben coincidir o, de lo contrario, se agregará NAN para toda la etiqueta de la columna.
Llenado mientras se vuelve a indexar
reindex() toma un método de parámetro opcional que es un método de relleno con los siguientes valores:
pad/ffill - Rellenar valores hacia adelante
bfill/backfill - Rellenar valores al revés
nearest - Llenar a partir de los valores de índice más cercanos
Ejemplo
import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])
# Padding NAN's
print df2.reindex_like(df1)
# Now Fill the NAN's with preceding Values
print ("Data Frame with Forward Fill:")
print df2.reindex_like(df1,method='ffill')
Sus output es como sigue -
col1 col2 col3
0 1.311620 -0.707176 0.599863
1 -0.423455 -0.700265 1.133371
2 NaN NaN NaN
3 NaN NaN NaN
4 NaN NaN NaN
5 NaN NaN NaN
Data Frame with Forward Fill:
col1 col2 col3
0 1.311620 -0.707176 0.599863
1 -0.423455 -0.700265 1.133371
2 -0.423455 -0.700265 1.133371
3 -0.423455 -0.700265 1.133371
4 -0.423455 -0.700265 1.133371
5 -0.423455 -0.700265 1.133371
Note - Las últimas cuatro filas están acolchadas.
Límites de llenado mientras se reindexa
El argumento de límite proporciona un control adicional sobre el llenado durante la reindexación. El límite especifica el recuento máximo de coincidencias consecutivas. Consideremos el siguiente ejemplo para entender lo mismo:
Ejemplo
import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])
# Padding NAN's
print df2.reindex_like(df1)
# Now Fill the NAN's with preceding Values
print ("Data Frame with Forward Fill limiting to 1:")
print df2.reindex_like(df1,method='ffill',limit=1)
Sus output es como sigue -
col1 col2 col3
0 0.247784 2.128727 0.702576
1 -0.055713 -0.021732 -0.174577
2 NaN NaN NaN
3 NaN NaN NaN
4 NaN NaN NaN
5 NaN NaN NaN
Data Frame with Forward Fill limiting to 1:
col1 col2 col3
0 0.247784 2.128727 0.702576
1 -0.055713 -0.021732 -0.174577
2 -0.055713 -0.021732 -0.174577
3 NaN NaN NaN
4 NaN NaN NaN
5 NaN NaN NaN
Note- Observe, solo la séptima fila se llena con la sexta fila anterior. Luego, las filas se dejan como están.
Renombrar
El método rename () le permite volver a etiquetar un eje basándose en algún mapeo (un dict o Series) o una función arbitraria.
Consideremos el siguiente ejemplo para entender esto:
import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
print df1
print ("After renaming the rows and columns:")
print df1.rename(columns={'col1' : 'c1', 'col2' : 'c2'},
index = {0 : 'apple', 1 : 'banana', 2 : 'durian'})
Sus output es como sigue -
col1 col2 col3
0 0.486791 0.105759 1.540122
1 -0.990237 1.007885 -0.217896
2 -0.483855 -1.645027 -1.194113
3 -0.122316 0.566277 -0.366028
4 -0.231524 -0.721172 -0.112007
5 0.438810 0.000225 0.435479
After renaming the rows and columns:
c1 c2 col3
apple 0.486791 0.105759 1.540122
banana -0.990237 1.007885 -0.217896
durian -0.483855 -1.645027 -1.194113
3 -0.122316 0.566277 -0.366028
4 -0.231524 -0.721172 -0.112007
5 0.438810 0.000225 0.435479
El método rename () proporciona una inplaceparámetro con nombre, que por defecto es Falso y copia los datos subyacentes. Pasarinplace=True para cambiar el nombre de los datos en su lugar.
El comportamiento de la iteración básica sobre los objetos Pandas depende del tipo. Cuando se itera sobre una serie, se considera como una matriz y la iteración básica produce los valores. Otras estructuras de datos, como DataFrame y Panel, siguen lasdict-like convención de iterar sobre el keys de los objetos.
En resumen, iteración básica (para i en objeto) produce -
Series - valores
DataFrame - etiquetas de columna
Panel - etiquetas de artículos
Iterando un DataFrame
La iteración de un DataFrame da nombres de columna. Consideremos el siguiente ejemplo para entender lo mismo.
import pandas as pd
import numpy as np
N=20
df = pd.DataFrame({
'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
'x': np.linspace(0,stop=N-1,num=N),
'y': np.random.rand(N),
'C': np.random.choice(['Low','Medium','High'],N).tolist(),
'D': np.random.normal(100, 10, size=(N)).tolist()
})
for col in df:
print col
Sus output es como sigue -
A
C
D
x
y
Para iterar sobre las filas del DataFrame, podemos usar las siguientes funciones:
iteritems() - iterar sobre los pares (clave, valor)
iterrows() - iterar sobre las filas como pares (índice, serie)
itertuples() - iterar sobre las filas como nombres de tuplas
iteritems ()
Itera sobre cada columna como clave, par de valores con etiqueta como clave y valor de columna como un objeto Serie.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns=['col1','col2','col3'])
for key,value in df.iteritems():
print key,value
Sus output es como sigue -
col1 0 0.802390
1 0.324060
2 0.256811
3 0.839186
Name: col1, dtype: float64
col2 0 1.624313
1 -1.033582
2 1.796663
3 1.856277
Name: col2, dtype: float64
col3 0 -0.022142
1 -0.230820
2 1.160691
3 -0.830279
Name: col3, dtype: float64
Observe, cada columna se itera por separado como un par clave-valor en una serie.
iterrows ()
iterrows () devuelve el iterador que produce cada valor de índice junto con una serie que contiene los datos en cada fila.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for row_index,row in df.iterrows():
print row_index,row
Sus output es como sigue -
0 col1 1.529759
col2 0.762811
col3 -0.634691
Name: 0, dtype: float64
1 col1 -0.944087
col2 1.420919
col3 -0.507895
Name: 1, dtype: float64
2 col1 -0.077287
col2 -0.858556
col3 -0.663385
Name: 2, dtype: float64
3 col1 -1.638578
col2 0.059866
col3 0.493482
Name: 3, dtype: float64
Note Porque iterrows()iterar sobre las filas, no conserva el tipo de datos en la fila. 0,1,2 son los índices de fila y col1, col2, col3 son índices de columna.
itertuples ()
El método itertuples () devolverá un iterador que producirá una tupla con nombre para cada fila del DataFrame. El primer elemento de la tupla será el valor de índice correspondiente de la fila, mientras que los valores restantes son los valores de la fila.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for row in df.itertuples():
print row
Sus output es como sigue -
Pandas(Index=0, col1=1.5297586201375899, col2=0.76281127433814944, col3=-
0.6346908238310438)
Pandas(Index=1, col1=-0.94408735763808649, col2=1.4209186418359423, col3=-
0.50789517967096232)
Pandas(Index=2, col1=-0.07728664756791935, col2=-0.85855574139699076, col3=-
0.6633852507207626)
Pandas(Index=3, col1=0.65734942534106289, col2=-0.95057710432604969,
col3=0.80344487462316527)
Note- No intente modificar ningún objeto durante la iteración. La iteración está destinada a la lectura y el iterador devuelve una copia del objeto original (una vista), por lo que los cambios no se reflejarán en el objeto original.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for index, row in df.iterrows():
row['a'] = 10
print df
Sus output es como sigue -
col1 col2 col3
0 -1.739815 0.735595 -0.295589
1 0.635485 0.106803 1.527922
2 -0.939064 0.547095 0.038585
3 -1.016509 -0.116580 -0.523158
Observe, no se reflejan cambios.
Hay dos tipos de clasificación disponibles en Pandas. Ellos son -
- Por etiqueta
- Por valor real
Consideremos un ejemplo con salida.
import pandas as pd
import numpy as np
unsorted_df=pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
mns=['col2','col1'])
print unsorted_df
Sus output es como sigue -
col2 col1
1 -2.063177 0.537527
4 0.142932 -0.684884
6 0.012667 -0.389340
2 -0.548797 1.848743
3 -1.044160 0.837381
5 0.385605 1.300185
9 1.031425 -1.002967
8 -0.407374 -0.435142
0 2.237453 -1.067139
7 -1.445831 -1.701035
En unsorted_df, la labels y el valuesestán sin clasificar. Veamos cómo se pueden ordenar estos.
Por etiqueta
Utilizando el sort_index(), pasando los argumentos del eje y el orden de clasificación, DataFrame se puede ordenar. De forma predeterminada, la clasificación se realiza en las etiquetas de fila en orden ascendente.
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
mns = ['col2','col1'])
sorted_df=unsorted_df.sort_index()
print sorted_df
Sus output es como sigue -
col2 col1
0 0.208464 0.627037
1 0.641004 0.331352
2 -0.038067 -0.464730
3 -0.638456 -0.021466
4 0.014646 -0.737438
5 -0.290761 -1.669827
6 -0.797303 -0.018737
7 0.525753 1.628921
8 -0.567031 0.775951
9 0.060724 -0.322425
Orden de clasificación
Al pasar el valor booleano al parámetro ascendente, se puede controlar el orden de clasificación. Consideremos el siguiente ejemplo para entender lo mismo.
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
mns = ['col2','col1'])
sorted_df = unsorted_df.sort_index(ascending=False)
print sorted_df
Sus output es como sigue -
col2 col1
9 0.825697 0.374463
8 -1.699509 0.510373
7 -0.581378 0.622958
6 -0.202951 0.954300
5 -1.289321 -1.551250
4 1.302561 0.851385
3 -0.157915 -0.388659
2 -1.222295 0.166609
1 0.584890 -0.291048
0 0.668444 -0.061294
Ordenar las columnas
Al pasar el argumento del eje con un valor 0 o 1, la clasificación se puede realizar en las etiquetas de las columnas. Por defecto, eje = 0, ordenar por fila. Consideremos el siguiente ejemplo para entender lo mismo.
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
mns = ['col2','col1'])
sorted_df=unsorted_df.sort_index(axis=1)
print sorted_df
Sus output es como sigue -
col1 col2
1 -0.291048 0.584890
4 0.851385 1.302561
6 0.954300 -0.202951
2 0.166609 -1.222295
3 -0.388659 -0.157915
5 -1.551250 -1.289321
9 0.374463 0.825697
8 0.510373 -1.699509
0 -0.061294 0.668444
7 0.622958 -0.581378
Por valor
Como la clasificación de índices, sort_values()es el método para ordenar por valores. Acepta un argumento 'por' que utilizará el nombre de la columna del DataFrame con el que se ordenarán los valores.
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by='col1')
print sorted_df
Sus output es como sigue -
col1 col2
1 1 3
2 1 2
3 1 4
0 2 1
Observe, los valores de col1 se ordenan y el valor de col2 y el índice de fila respectivos se alterarán junto con col1. Por lo tanto, se ven desordenados.
'by' El argumento toma una lista de valores de columna.
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by=['col1','col2'])
print sorted_df
Sus output es como sigue -
col1 col2
2 1 2
1 1 3
3 1 4
0 2 1
Algoritmo de clasificación
sort_values()proporciona una disposición para elegir el algoritmo entre mergesort, heapsort y quicksort. Mergesort es el único algoritmo estable.
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by='col1' ,kind='mergesort')
print sorted_df
Sus output es como sigue -
col1 col2
1 1 3
2 1 2
3 1 4
0 2 1
En este capítulo, discutiremos las operaciones de cadena con nuestra Serie / Índice básico. En los capítulos siguientes, aprenderemos cómo aplicar estas funciones de cadena en el DataFrame.
Pandas proporciona un conjunto de funciones de cadena que facilitan la operación con datos de cadena. Lo más importante es que estas funciones ignoran (o excluyen) los valores faltantes / NaN.
Casi todos estos métodos funcionan con funciones de cadena de Python (consulte: https://docs.python.org/3/library/stdtypes.html#string-methods). Por lo tanto, convierta el objeto de serie en un objeto de cadena y luego realice la operación.
Veamos ahora cómo se realiza cada operación.
No Señor | Función descriptiva |
---|---|
1 | lower() Convierte las cadenas de la serie / índice a minúsculas. |
2 | upper() Convierte las cadenas de Series / Index a mayúsculas. |
3 | len() Calcula la longitud de la cadena (). |
4 | strip() Ayuda a eliminar los espacios en blanco (incluida la nueva línea) de cada cadena en la Serie / índice de ambos lados. |
5 | split(' ') Divide cada cuerda con el patrón dado. |
6 | cat(sep=' ') Concatena los elementos de serie / índice con un separador dado. |
7 | get_dummies() Devuelve el DataFrame con valores One-Hot Encoded. |
8 | contains(pattern) Devuelve un valor booleano Verdadero para cada elemento si la subcadena contiene en el elemento; de lo contrario, es Falso. |
9 | replace(a,b) Reemplaza el valor a con el valor b. |
10 | repeat(value) Repite cada elemento con un número específico de veces. |
11 | count(pattern) Devuelve el recuento de aparición del patrón en cada elemento. |
12 | startswith(pattern) Devuelve verdadero si el elemento de la Serie / Índice comienza con el patrón. |
13 | endswith(pattern) Devuelve verdadero si el elemento de la Serie / Índice termina con el patrón. |
14 | find(pattern) Devuelve la primera posición de la primera aparición del patrón. |
15 | findall(pattern) Devuelve una lista de todas las ocurrencias del patrón. |
dieciséis | swapcase Cambia el caso inferior / superior. |
17 | islower() Comprueba si todos los caracteres de cada cadena de la Serie / Índice están en minúsculas o no. Devuelve booleano |
18 | isupper() Comprueba si todos los caracteres de cada cadena de la Serie / Índice están en mayúsculas o no. Devuelve booleano. |
19 | isnumeric() Comprueba si todos los caracteres de cada cadena de la Serie / Índice son numéricos. Devuelve booleano. |
Creemos ahora una serie y veamos cómo funcionan todas las funciones anteriores.
import pandas as pd
import numpy as np
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s
Sus output es como sigue -
0 Tom
1 William Rick
2 John
3 Alber@t
4 NaN
5 1234
6 Steve Smith
dtype: object
inferior()
import pandas as pd
import numpy as np
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s.str.lower()
Sus output es como sigue -
0 tom
1 william rick
2 john
3 alber@t
4 NaN
5 1234
6 steve smith
dtype: object
Superior()
import pandas as pd
import numpy as np
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s.str.upper()
Sus output es como sigue -
0 TOM
1 WILLIAM RICK
2 JOHN
3 ALBER@T
4 NaN
5 1234
6 STEVE SMITH
dtype: object
len ()
import pandas as pd
import numpy as np
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s.str.len()
Sus output es como sigue -
0 3.0
1 12.0
2 4.0
3 7.0
4 NaN
5 4.0
6 10.0
dtype: float64
tira()
import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("After Stripping:")
print s.str.strip()
Sus output es como sigue -
0 Tom
1 William Rick
2 John
3 Alber@t
dtype: object
After Stripping:
0 Tom
1 William Rick
2 John
3 Alber@t
dtype: object
split (patrón)
import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("Split Pattern:")
print s.str.split(' ')
Sus output es como sigue -
0 Tom
1 William Rick
2 John
3 Alber@t
dtype: object
Split Pattern:
0 [Tom, , , , , , , , , , ]
1 [, , , , , William, Rick]
2 [John]
3 [Alber@t]
dtype: object
gato (sep = patrón)
import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.cat(sep='_')
Sus output es como sigue -
Tom _ William Rick_John_Alber@t
get_dummies ()
import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.get_dummies()
Sus output es como sigue -
William Rick Alber@t John Tom
0 0 0 0 1
1 1 0 0 0
2 0 0 1 0
3 0 1 0 0
contiene ()
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.contains(' ')
Sus output es como sigue -
0 True
1 True
2 False
3 False
dtype: bool
reemplazar (a, b)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("After replacing @ with $:") print s.str.replace('@','$')
Sus output es como sigue -
0 Tom
1 William Rick
2 John
3 Alber@t
dtype: object
After replacing @ with $: 0 Tom 1 William Rick 2 John 3 Alber$t
dtype: object
repetir (valor)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.repeat(2)
Sus output es como sigue -
0 Tom Tom
1 William Rick William Rick
2 JohnJohn
3 Alber@tAlber@t
dtype: object
contar (patrón)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print ("The number of 'm's in each string:")
print s.str.count('m')
Sus output es como sigue -
The number of 'm's in each string:
0 1
1 1
2 0
3 0
comienza con (patrón)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print ("Strings that start with 'T':")
print s.str. startswith ('T')
Sus output es como sigue -
0 True
1 False
2 False
3 False
dtype: bool
termina con (patrón)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print ("Strings that end with 't':")
print s.str.endswith('t')
Sus output es como sigue -
Strings that end with 't':
0 False
1 False
2 False
3 True
dtype: bool
encontrar (patrón)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.find('e')
Sus output es como sigue -
0 -1
1 -1
2 -1
3 3
dtype: int64
"-1" indica que no existe tal patrón disponible en el elemento.
findall (patrón)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.findall('e')
Sus output es como sigue -
0 []
1 []
2 []
3 [e]
dtype: object
La lista nula ([]) indica que no existe tal patrón disponible en el elemento.
swapcase ()
import pandas as pd
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.swapcase()
Sus output es como sigue -
0 tOM
1 wILLIAM rICK
2 jOHN
3 aLBER@T
dtype: object
es bajo()
import pandas as pd
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.islower()
Sus output es como sigue -
0 False
1 False
2 False
3 False
dtype: bool
isupper ()
import pandas as pd
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.isupper()
Sus output es como sigue -
0 False
1 False
2 False
3 False
dtype: bool
isnumeric ()
import pandas as pd
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.isnumeric()
Sus output es como sigue -
0 False
1 False
2 False
3 False
dtype: bool
Pandas proporciona API para personalizar algunos aspectos de su comportamiento, la visualización se utiliza principalmente.
La API se compone de cinco funciones relevantes. Ellos son -
- get_option()
- set_option()
- reset_option()
- describe_option()
- option_context()
Entendamos ahora cómo operan las funciones.
get_option (param)
get_option toma un solo parámetro y devuelve el valor como se indica en la salida a continuación:
display.max_rows
Muestra el número de valor predeterminado. El intérprete lee este valor y muestra las filas con este valor como límite superior para mostrar.
import pandas as pd
print pd.get_option("display.max_rows")
Sus output es como sigue -
60
display.max_columns
Muestra el número de valor predeterminado. El intérprete lee este valor y muestra las filas con este valor como límite superior para mostrar.
import pandas as pd
print pd.get_option("display.max_columns")
Sus output es como sigue -
20
Aquí, 60 y 20 son los valores de los parámetros de configuración predeterminados.
set_option (parámetro, valor)
set_option toma dos argumentos y establece el valor del parámetro como se muestra a continuación:
display.max_rows
Utilizando set_option(), podemos cambiar el número predeterminado de filas que se mostrarán.
import pandas as pd
pd.set_option("display.max_rows",80)
print pd.get_option("display.max_rows")
Sus output es como sigue -
80
display.max_columns
Utilizando set_option(), podemos cambiar el número predeterminado de filas que se mostrarán.
import pandas as pd
pd.set_option("display.max_columns",30)
print pd.get_option("display.max_columns")
Sus output es como sigue -
30
reset_option (param)
reset_option toma un argumento y devuelve el valor al valor predeterminado.
display.max_rows
Usando reset_option (), podemos volver a cambiar el valor al número predeterminado de filas que se mostrarán.
import pandas as pd
pd.reset_option("display.max_rows")
print pd.get_option("display.max_rows")
Sus output es como sigue -
60
describe_option (parámetro)
describe_option imprime la descripción del argumento.
display.max_rows
Usando reset_option (), podemos volver a cambiar el valor al número predeterminado de filas que se mostrarán.
import pandas as pd
pd.describe_option("display.max_rows")
Sus output es como sigue -
display.max_rows : int
If max_rows is exceeded, switch to truncate view. Depending on
'large_repr', objects are either centrally truncated or printed as
a summary view. 'None' value means unlimited.
In case python/IPython is running in a terminal and `large_repr`
equals 'truncate' this can be set to 0 and pandas will auto-detect
the height of the terminal and print a truncated object which fits
the screen height. The IPython notebook, IPython qtconsole, or
IDLE do not run in a terminal and hence it is not possible to do
correct auto-detection.
[default: 60] [currently: 60]
option_context ()
option_context administrador de contexto se utiliza para establecer la opción en with statementtemporalmente. Los valores de las opciones se restauran automáticamente cuando sale delwith block -
display.max_rows
Usando option_context (), podemos establecer el valor temporalmente.
import pandas as pd
with pd.option_context("display.max_rows",10):
print(pd.get_option("display.max_rows"))
print(pd.get_option("display.max_rows"))
Sus output es como sigue -
10
10
Vea la diferencia entre la primera y la segunda declaración impresa. La primera declaración imprime el valor establecido poroption_context() que es temporal dentro del with contextsí mismo. Después de lawith context, la segunda declaración de impresión imprime el valor configurado.
Parámetros de uso frecuente
No Señor | Descripción de parámetros |
---|---|
1 | display.max_rows Muestra el número máximo de filas para mostrar |
2 | 2 display.max_columns Muestra el número máximo de columnas para mostrar |
3 | display.expand_frame_repr Muestra DataFrames para ampliar páginas |
4 | display.max_colwidth Muestra el ancho máximo de columna |
5 | display.precision Muestra precisión para números decimales |
En este capítulo, discutiremos cómo cortar y cortar la fecha y, en general, obtener el subconjunto del objeto pandas.
Los operadores de indexación de Python y NumPy "[]" y el operador de atributo "." proporcionan un acceso rápido y fácil a las estructuras de datos de Pandas en una amplia gama de casos de uso. Sin embargo, dado que el tipo de datos a los que se accede no se conoce de antemano, el uso directo de operadores estándar tiene algunos límites de optimización. Para el código de producción, le recomendamos que aproveche los métodos optimizados de acceso a datos de pandas que se explican en este capítulo.
Pandas ahora admite tres tipos de indexación de ejes múltiples; los tres tipos se mencionan en la siguiente tabla:
No Señor | Indexación y descripción |
---|---|
1 | .loc() Basado en etiquetas |
2 | .iloc() Basado en enteros |
3 | .ix() Basado en etiquetas y enteros |
.loc ()
Los pandas proporcionan varios métodos para tener puramente label based indexing. Al cortar, también se incluye el límite inicial. Los números enteros son etiquetas válidas, pero se refieren a la etiqueta y no a la posición.
.loc() tiene múltiples métodos de acceso como -
- Una sola etiqueta escalar
- Una lista de etiquetas
- Un objeto de corte
- Una matriz booleana
loctoma dos operadores individuales / lista / rango separados por ','. El primero indica la fila y el segundo indica las columnas.
Ejemplo 1
#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])
#select all rows for a specific column
print df.loc[:,'A']
Sus output es como sigue -
a 0.391548
b -0.070649
c -0.317212
d -2.162406
e 2.202797
f 0.613709
g 1.050559
h 1.122680
Name: A, dtype: float64
Ejemplo 2
# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])
# Select all rows for multiple columns, say list[]
print df.loc[:,['A','C']]
Sus output es como sigue -
A C
a 0.391548 0.745623
b -0.070649 1.620406
c -0.317212 1.448365
d -2.162406 -0.873557
e 2.202797 0.528067
f 0.613709 0.286414
g 1.050559 0.216526
h 1.122680 -1.621420
Ejemplo 3
# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])
# Select few rows for multiple columns, say list[]
print df.loc[['a','b','f','h'],['A','C']]
Sus output es como sigue -
A C
a 0.391548 0.745623
b -0.070649 1.620406
f 0.613709 0.286414
h 1.122680 -1.621420
Ejemplo 4
# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])
# Select range of rows for all columns
print df.loc['a':'h']
Sus output es como sigue -
A B C D
a 0.391548 -0.224297 0.745623 0.054301
b -0.070649 -0.880130 1.620406 1.419743
c -0.317212 -1.929698 1.448365 0.616899
d -2.162406 0.614256 -0.873557 1.093958
e 2.202797 -2.315915 0.528067 0.612482
f 0.613709 -0.157674 0.286414 -0.500517
g 1.050559 -2.272099 0.216526 0.928449
h 1.122680 0.324368 -1.621420 -0.741470
Ejemplo 5
# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])
# for getting values with a boolean array
print df.loc['a']>0
Sus output es como sigue -
A False
B True
C False
D False
Name: a, dtype: bool
.iloc ()
Pandas proporciona varios métodos para obtener una indexación basada exclusivamente en números enteros. Como Python y Numpy, estos son0-based indexación.
Los diversos métodos de acceso son los siguientes:
- Un entero
- Una lista de enteros
- Un rango de valores
Ejemplo 1
# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# select all rows for a specific column
print df.iloc[:4]
Sus output es como sigue -
A B C D
0 0.699435 0.256239 -1.270702 -0.645195
1 -0.685354 0.890791 -0.813012 0.631615
2 -0.783192 -0.531378 0.025070 0.230806
3 0.539042 -1.284314 0.826977 -0.026251
Ejemplo 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# Integer slicing
print df.iloc[:4]
print df.iloc[1:5, 2:4]
Sus output es como sigue -
A B C D
0 0.699435 0.256239 -1.270702 -0.645195
1 -0.685354 0.890791 -0.813012 0.631615
2 -0.783192 -0.531378 0.025070 0.230806
3 0.539042 -1.284314 0.826977 -0.026251
C D
1 -0.813012 0.631615
2 0.025070 0.230806
3 0.826977 -0.026251
4 1.423332 1.130568
Ejemplo 3
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# Slicing through list of values
print df.iloc[[1, 3, 5], [1, 3]]
print df.iloc[1:3, :]
print df.iloc[:,1:3]
Sus output es como sigue -
B D
1 0.890791 0.631615
3 -1.284314 -0.026251
5 -0.512888 -0.518930
A B C D
1 -0.685354 0.890791 -0.813012 0.631615
2 -0.783192 -0.531378 0.025070 0.230806
B C
0 0.256239 -1.270702
1 0.890791 -0.813012
2 -0.531378 0.025070
3 -1.284314 0.826977
4 -0.460729 1.423332
5 -0.512888 0.581409
6 -1.204853 0.098060
7 -0.947857 0.641358
.ix ()
Además de puramente basado en etiquetas y basado en números enteros, Pandas proporciona un método híbrido para selecciones y subconjuntos del objeto usando el operador .ix ().
Ejemplo 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# Integer slicing
print df.ix[:4]
Sus output es como sigue -
A B C D
0 0.699435 0.256239 -1.270702 -0.645195
1 -0.685354 0.890791 -0.813012 0.631615
2 -0.783192 -0.531378 0.025070 0.230806
3 0.539042 -1.284314 0.826977 -0.026251
Ejemplo 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# Index slicing
print df.ix[:,'A']
Sus output es como sigue -
0 0.699435
1 -0.685354
2 -0.783192
3 0.539042
4 -1.044209
5 -1.415411
6 1.062095
7 0.994204
Name: A, dtype: float64
Uso de notaciones
Obtener valores del objeto Pandas con indexación de ejes múltiples utiliza la siguiente notación:
Objeto | Indexadores | Tipo de retorno |
---|---|---|
Serie | s.loc [indexador] | Valor escalar |
Marco de datos | df.loc [row_index, col_index] | Objeto de serie |
Panel | p.loc [item_index, major_index, minor_index] | p.loc [item_index, major_index, minor_index] |
Note − .iloc() & .ix() aplica las mismas opciones de indexación y valor de retorno.
Veamos ahora cómo se puede realizar cada operación en el objeto DataFrame. Usaremos el operador de indexación básico '[]' -
Ejemplo 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df['A']
Sus output es como sigue -
0 -0.478893
1 0.391931
2 0.336825
3 -1.055102
4 -0.165218
5 -0.328641
6 0.567721
7 -0.759399
Name: A, dtype: float64
Note - Podemos pasar una lista de valores a [] para seleccionar esas columnas.
Ejemplo 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df[['A','B']]
Sus output es como sigue -
A B
0 -0.478893 -0.606311
1 0.391931 -0.949025
2 0.336825 0.093717
3 -1.055102 -0.012944
4 -0.165218 1.550310
5 -0.328641 -0.226363
6 0.567721 -0.312585
7 -0.759399 -0.372696
Ejemplo 3
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df[2:2]
Sus output es como sigue -
Columns: [A, B, C, D]
Index: []
Acceso a atributos
Las columnas se pueden seleccionar utilizando el operador de atributo '.'.
Ejemplo
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df.A
Sus output es como sigue -
0 -0.478893
1 0.391931
2 0.336825
3 -1.055102
4 -0.165218
5 -0.328641
6 0.567721
7 -0.759399
Name: A, dtype: float64
Los métodos estadísticos ayudan a comprender y analizar el comportamiento de los datos. Ahora aprenderemos algunas funciones estadísticas, que podemos aplicar en objetos Pandas.
Cambio porcentual
Series, DatFrames y Panel, todos tienen la función pct_change(). Esta función compara cada elemento con su elemento anterior y calcula el porcentaje de cambio.
import pandas as pd
import numpy as np
s = pd.Series([1,2,3,4,5,4])
print s.pct_change()
df = pd.DataFrame(np.random.randn(5, 2))
print df.pct_change()
Sus output es como sigue -
0 NaN
1 1.000000
2 0.500000
3 0.333333
4 0.250000
5 -0.200000
dtype: float64
0 1
0 NaN NaN
1 -15.151902 0.174730
2 -0.746374 -1.449088
3 -3.582229 -3.165836
4 15.601150 -1.860434
Por defecto, el pct_change()opera en columnas; si desea aplicar la misma fila, utiliceaxis=1() argumento.
Covarianza
La covarianza se aplica a los datos de la serie. El objeto Serie tiene un método cov para calcular la covarianza entre objetos en serie. NA se excluirá automáticamente.
Serie Cov
import pandas as pd
import numpy as np
s1 = pd.Series(np.random.randn(10))
s2 = pd.Series(np.random.randn(10))
print s1.cov(s2)
Sus output es como sigue -
-0.12978405324
El método de covarianza cuando se aplica en un DataFrame, calcula cov entre todas las columnas.
import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.randn(10, 5), columns=['a', 'b', 'c', 'd', 'e'])
print frame['a'].cov(frame['b'])
print frame.cov()
Sus output es como sigue -
-0.58312921152741437
a b c d e
a 1.780628 -0.583129 -0.185575 0.003679 -0.136558
b -0.583129 1.297011 0.136530 -0.523719 0.251064
c -0.185575 0.136530 0.915227 -0.053881 -0.058926
d 0.003679 -0.523719 -0.053881 1.521426 -0.487694
e -0.136558 0.251064 -0.058926 -0.487694 0.960761
Note - Observe el cov Entre a y b columna en la primera declaración y el mismo es el valor devuelto por cov en DataFrame.
Correlación
La correlación muestra la relación lineal entre dos matrices de valores (series). Hay varios métodos para calcular la correlación, como pearson (predeterminado), spearman y kendall.
import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.randn(10, 5), columns=['a', 'b', 'c', 'd', 'e'])
print frame['a'].corr(frame['b'])
print frame.corr()
Sus output es como sigue -
-0.383712785514
a b c d e
a 1.000000 -0.383713 -0.145368 0.002235 -0.104405
b -0.383713 1.000000 0.125311 -0.372821 0.224908
c -0.145368 0.125311 1.000000 -0.045661 -0.062840
d 0.002235 -0.372821 -0.045661 1.000000 -0.403380
e -0.104405 0.224908 -0.062840 -0.403380 1.000000
Si alguna columna no numérica está presente en el DataFrame, se excluye automáticamente.
Clasificación de datos
Clasificación de datos produce una clasificación para cada elemento en la matriz de elementos. En caso de empates, asigna el rango medio.
import pandas as pd
import numpy as np
s = pd.Series(np.random.np.random.randn(5), index=list('abcde'))
s['d'] = s['b'] # so there's a tie
print s.rank()
Sus output es como sigue -
a 1.0
b 3.5
c 2.0
d 3.5
e 5.0
dtype: float64
El rango toma opcionalmente un parámetro ascendente que por defecto es verdadero; cuando es falso, los datos se clasifican de forma inversa, y los valores más grandes asignan una clasificación más pequeña.
Rank admite diferentes métodos de desempate, especificados con el parámetro de método:
average - rango promedio del grupo empatado
min - rango más bajo en el grupo
max - rango más alto en el grupo
first - rangos asignados en el orden en que aparecen en la matriz
Para trabajar con datos numéricos, los Pandas proporcionan pocas variantes, como pesos móviles, en expansión y en movimiento exponencial para las estadísticas de ventanas. Entre estos se encuentransum, mean, median, variance, covariance, correlation, etc.
Ahora aprenderemos cómo cada uno de estos se puede aplicar en objetos DataFrame.
Función .rolling ()
Esta función se puede aplicar a una serie de datos. Especifica elwindow=n argumento y aplique la función estadística apropiada encima de él.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df.rolling(window=3).mean()
Sus output es como sigue -
A B C D
2000-01-01 NaN NaN NaN NaN
2000-01-02 NaN NaN NaN NaN
2000-01-03 0.434553 -0.667940 -1.051718 -0.826452
2000-01-04 0.628267 -0.047040 -0.287467 -0.161110
2000-01-05 0.398233 0.003517 0.099126 -0.405565
2000-01-06 0.641798 0.656184 -0.322728 0.428015
2000-01-07 0.188403 0.010913 -0.708645 0.160932
2000-01-08 0.188043 -0.253039 -0.818125 -0.108485
2000-01-09 0.682819 -0.606846 -0.178411 -0.404127
2000-01-10 0.688583 0.127786 0.513832 -1.067156
Note - Dado que el tamaño de la ventana es 3, para los dos primeros elementos hay nulos y desde el tercero el valor será el promedio de la n, n-1 y n-2elementos. Por lo tanto, también podemos aplicar varias funciones como se mencionó anteriormente.
Función .expanding ()
Esta función se puede aplicar a una serie de datos. Especifica elmin_periods=n argumento y aplique la función estadística apropiada encima de él.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df.expanding(min_periods=3).mean()
Sus output es como sigue -
A B C D
2000-01-01 NaN NaN NaN NaN
2000-01-02 NaN NaN NaN NaN
2000-01-03 0.434553 -0.667940 -1.051718 -0.826452
2000-01-04 0.743328 -0.198015 -0.852462 -0.262547
2000-01-05 0.614776 -0.205649 -0.583641 -0.303254
2000-01-06 0.538175 -0.005878 -0.687223 -0.199219
2000-01-07 0.505503 -0.108475 -0.790826 -0.081056
2000-01-08 0.454751 -0.223420 -0.671572 -0.230215
2000-01-09 0.586390 -0.206201 -0.517619 -0.267521
2000-01-10 0.560427 -0.037597 -0.399429 -0.376886
Función .ewm ()
ewmse aplica a una serie de datos. Especifique cualquiera de los com, span,halflifeargumento y aplique la función estadística apropiada encima de él. Asigna los pesos de forma exponencial.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df.ewm(com=0.5).mean()
Sus output es como sigue -
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 0.865131 -0.453626 -1.137961 0.058747
2000-01-03 -0.132245 -0.807671 -0.308308 -1.491002
2000-01-04 1.084036 0.555444 -0.272119 0.480111
2000-01-05 0.425682 0.025511 0.239162 -0.153290
2000-01-06 0.245094 0.671373 -0.725025 0.163310
2000-01-07 0.288030 -0.259337 -1.183515 0.473191
2000-01-08 0.162317 -0.771884 -0.285564 -0.692001
2000-01-09 1.147156 -0.302900 0.380851 -0.607976
2000-01-10 0.600216 0.885614 0.569808 -1.110113
Las funciones de ventana se utilizan principalmente para encontrar las tendencias dentro de los datos de forma gráfica suavizando la curva. Si hay mucha variación en los datos cotidianos y hay muchos puntos de datos disponibles, entonces tomar las muestras y graficar es un método y aplicar los cálculos de la ventana y graficar el gráfico en los resultados es otro método. Con estos métodos, podemos suavizar la curva o la tendencia.
Una vez que el rodamiento, la expansión y ewm se crean objetos, hay varios métodos disponibles para realizar agregaciones de datos.
Aplicar agregaciones en DataFrame
Creemos un DataFrame y apliquemos agregaciones en él.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r
Sus output es como sigue -
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 0.790670 -0.387854 -0.668132 0.267283
2000-01-03 -0.575523 -0.965025 0.060427 -2.179780
2000-01-04 1.669653 1.211759 -0.254695 1.429166
2000-01-05 0.100568 -0.236184 0.491646 -0.466081
2000-01-06 0.155172 0.992975 -1.205134 0.320958
2000-01-07 0.309468 -0.724053 -1.412446 0.627919
2000-01-08 0.099489 -1.028040 0.163206 -1.274331
2000-01-09 1.639500 -0.068443 0.714008 -0.565969
2000-01-10 0.326761 1.479841 0.664282 -1.361169
Rolling [window=3,min_periods=1,center=False,axis=0]
Podemos agregar pasando una función a todo el DataFrame, o seleccionar una columna a través del estándar get item método.
Aplicar agregación en un marco de datos completo
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r.aggregate(np.sum)
Sus output es como sigue -
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
Aplicar agregación en una sola columna de un marco de datos
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r['A'].aggregate(np.sum)
Sus output es como sigue -
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
2000-01-01 1.088512
2000-01-02 1.879182
2000-01-03 1.303660
2000-01-04 1.884801
2000-01-05 1.194699
2000-01-06 1.925393
2000-01-07 0.565208
2000-01-08 0.564129
2000-01-09 2.048458
2000-01-10 2.065750
Freq: D, Name: A, dtype: float64
Aplicar agregación en varias columnas de un marco de datos
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r[['A','B']].aggregate(np.sum)
Sus output es como sigue -
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
A B
2000-01-01 1.088512 -0.650942
2000-01-02 1.879182 -1.038796
2000-01-03 1.303660 -2.003821
2000-01-04 1.884801 -0.141119
2000-01-05 1.194699 0.010551
2000-01-06 1.925393 1.968551
2000-01-07 0.565208 0.032738
2000-01-08 0.564129 -0.759118
2000-01-09 2.048458 -1.820537
2000-01-10 2.065750 0.383357
Aplicar múltiples funciones en una sola columna de un DataFrame
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r['A'].aggregate([np.sum,np.mean])
Sus output es como sigue -
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
sum mean
2000-01-01 1.088512 1.088512
2000-01-02 1.879182 0.939591
2000-01-03 1.303660 0.434553
2000-01-04 1.884801 0.628267
2000-01-05 1.194699 0.398233
2000-01-06 1.925393 0.641798
2000-01-07 0.565208 0.188403
2000-01-08 0.564129 0.188043
2000-01-09 2.048458 0.682819
2000-01-10 2.065750 0.688583
Aplicar múltiples funciones en múltiples columnas de un DataFrame
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r[['A','B']].aggregate([np.sum,np.mean])
Sus output es como sigue -
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
A B
sum mean sum mean
2000-01-01 1.088512 1.088512 -0.650942 -0.650942
2000-01-02 1.879182 0.939591 -1.038796 -0.519398
2000-01-03 1.303660 0.434553 -2.003821 -0.667940
2000-01-04 1.884801 0.628267 -0.141119 -0.047040
2000-01-05 1.194699 0.398233 0.010551 0.003517
2000-01-06 1.925393 0.641798 1.968551 0.656184
2000-01-07 0.565208 0.188403 0.032738 0.010913
2000-01-08 0.564129 0.188043 -0.759118 -0.253039
2000-01-09 2.048458 0.682819 -1.820537 -0.606846
2000-01-10 2.065750 0.688583 0.383357 0.127786
Aplicar diferentes funciones a diferentes columnas de un marco de datos
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(3, 4),
index = pd.date_range('1/1/2000', periods=3),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r.aggregate({'A' : np.sum,'B' : np.mean})
Sus output es como sigue -
A B C D
2000-01-01 -1.575749 -1.018105 0.317797 0.545081
2000-01-02 -0.164917 -1.361068 0.258240 1.113091
2000-01-03 1.258111 1.037941 -0.047487 0.867371
A B
2000-01-01 -1.575749 -1.018105
2000-01-02 -1.740666 -1.189587
2000-01-03 -0.482555 -0.447078
La falta de datos siempre es un problema en escenarios de la vida real. Áreas como el aprendizaje automático y la minería de datos enfrentan problemas graves en la precisión de las predicciones de sus modelos debido a la mala calidad de los datos causada por valores perdidos. En estas áreas, el tratamiento de los valores perdidos es un punto importante de enfoque para hacer que sus modelos sean más precisos y válidos.
¿Cuándo y por qué se pierden los datos?
Consideremos una encuesta en línea para un producto. Muchas veces, las personas no comparten toda la información relacionada con ellos. Pocas personas comparten su experiencia, pero no cuánto tiempo están usando el producto; pocas personas comparten cuánto tiempo usan el producto, su experiencia pero no su información de contacto. Así, de una u otra forma siempre falta una parte de los datos, y esto es muy común en tiempo real.
Veamos ahora cómo podemos manejar los valores perdidos (digamos NA o NaN) usando Pandas.
# import the pandas library
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df
Sus output es como sigue -
one two three
a 0.077988 0.476149 0.965836
b NaN NaN NaN
c -0.390208 -0.551605 -2.301950
d NaN NaN NaN
e -2.000303 -0.788201 1.510072
f -0.930230 -0.670473 1.146615
g NaN NaN NaN
h 0.085100 0.532791 0.887415
Usando la reindexación, hemos creado un DataFrame con valores perdidos. En la salida,NaN medio Not a Number.
Verificar valores perdidos
Para facilitar la detección de valores perdidos (y en diferentes tipos de matriz), Pandas proporciona la isnull() y notnull() funciones, que también son métodos en objetos Series y DataFrame -
Ejemplo 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df['one'].isnull()
Sus output es como sigue -
a False
b True
c False
d True
e False
f False
g True
h False
Name: one, dtype: bool
Ejemplo 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df['one'].notnull()
Sus output es como sigue -
a True
b False
c True
d False
e True
f True
g False
h True
Name: one, dtype: bool
Cálculos con datos faltantes
- Al sumar datos, NA se tratará como cero
- Si todos los datos son NA, entonces el resultado será NA
Ejemplo 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df['one'].sum()
Sus output es como sigue -
2.02357685917
Ejemplo 2
import pandas as pd
import numpy as np
df = pd.DataFrame(index=[0,1,2,3,4,5],columns=['one','two'])
print df['one'].sum()
Sus output es como sigue -
nan
Limpieza / llenado de datos faltantes
Pandas proporciona varios métodos para limpiar los valores faltantes. La función fillna puede “completar” los valores NA con datos no nulos de un par de formas, que hemos ilustrado en las siguientes secciones.
Reemplazar NaN con un valor escalar
El siguiente programa muestra cómo se puede reemplazar "NaN" por "0".
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(3, 3), index=['a', 'c', 'e'],columns=['one',
'two', 'three'])
df = df.reindex(['a', 'b', 'c'])
print df
print ("NaN replaced with '0':")
print df.fillna(0)
Sus output es como sigue -
one two three
a -0.576991 -0.741695 0.553172
b NaN NaN NaN
c 0.744328 -1.735166 1.749580
NaN replaced with '0':
one two three
a -0.576991 -0.741695 0.553172
b 0.000000 0.000000 0.000000
c 0.744328 -1.735166 1.749580
Aquí, estamos llenando con valor cero; en su lugar, también podemos completar con cualquier otro valor.
Rellenar NA hacia adelante y hacia atrás
Usando los conceptos de llenado discutidos en el Capítulo de ReIndexación, completaremos los valores faltantes.
No Señor | Método y acción |
---|---|
1 | pad/fill Métodos de relleno Adelante |
2 | bfill/backfill Rellenar métodos al revés |
Ejemplo 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.fillna(method='pad')
Sus output es como sigue -
one two three
a 0.077988 0.476149 0.965836
b 0.077988 0.476149 0.965836
c -0.390208 -0.551605 -2.301950
d -0.390208 -0.551605 -2.301950
e -2.000303 -0.788201 1.510072
f -0.930230 -0.670473 1.146615
g -0.930230 -0.670473 1.146615
h 0.085100 0.532791 0.887415
Ejemplo 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.fillna(method='backfill')
Sus output es como sigue -
one two three
a 0.077988 0.476149 0.965836
b -0.390208 -0.551605 -2.301950
c -0.390208 -0.551605 -2.301950
d -2.000303 -0.788201 1.510072
e -2.000303 -0.788201 1.510072
f -0.930230 -0.670473 1.146615
g 0.085100 0.532791 0.887415
h 0.085100 0.532791 0.887415
Eliminar valores perdidos
Si simplemente desea excluir los valores faltantes, utilice el dropna función junto con el axisargumento. Por defecto, eje = 0, es decir, a lo largo de la fila, lo que significa que si cualquier valor dentro de una fila es NA, se excluye toda la fila.
Ejemplo 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.dropna()
Sus output es como sigue -
one two three
a 0.077988 0.476149 0.965836
c -0.390208 -0.551605 -2.301950
e -2.000303 -0.788201 1.510072
f -0.930230 -0.670473 1.146615
h 0.085100 0.532791 0.887415
Ejemplo 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.dropna(axis=1)
Sus output es como sigue -
Empty DataFrame
Columns: [ ]
Index: [a, b, c, d, e, f, g, h]
Reemplazar valores faltantes (o) genéricos
Muchas veces, tenemos que reemplazar un valor genérico con algún valor específico. Podemos lograr esto aplicando el método de reemplazo.
Reemplazar NA con un valor escalar es un comportamiento equivalente del fillna() función.
Ejemplo 1
import pandas as pd
import numpy as np
df = pd.DataFrame({'one':[10,20,30,40,50,2000], 'two':[1000,0,30,40,50,60]})
print df.replace({1000:10,2000:60})
Sus output es como sigue -
one two
0 10 10
1 20 0
2 30 30
3 40 40
4 50 50
5 60 60
Ejemplo 2
import pandas as pd
import numpy as np
df = pd.DataFrame({'one':[10,20,30,40,50,2000], 'two':[1000,0,30,40,50,60]})
print df.replace({1000:10,2000:60})
Sus output es como sigue -
one two
0 10 10
1 20 0
2 30 30
3 40 40
4 50 50
5 60 60
Ninguna groupbyLa operación implica una de las siguientes operaciones en el objeto original. Ellos son -
Splitting el objeto
Applying Una función
Combining Los resultados
En muchas situaciones, dividimos los datos en conjuntos y aplicamos alguna funcionalidad en cada subconjunto. En la funcionalidad de aplicar, podemos realizar las siguientes operaciones:
Aggregation - calcular una estadística de resumen
Transformation - realizar alguna operación específica de grupo
Filtration - descartar los datos con alguna condición
Creemos ahora un objeto DataFrame y realicemos todas las operaciones en él:
#import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
print df
Sus output es como sigue -
Points Rank Team Year
0 876 1 Riders 2014
1 789 2 Riders 2015
2 863 2 Devils 2014
3 673 3 Devils 2015
4 741 3 Kings 2014
5 812 4 kings 2015
6 756 1 Kings 2016
7 788 1 Kings 2017
8 694 2 Riders 2016
9 701 4 Royals 2014
10 804 1 Royals 2015
11 690 2 Riders 2017
Dividir datos en grupos
El objeto Pandas se puede dividir en cualquiera de sus objetos. Hay varias formas de dividir un objeto como:
- obj.groupby('key')
- obj.groupby(['key1','key2'])
- obj.groupby(key,axis=1)
Veamos ahora cómo se pueden aplicar los objetos de agrupación al objeto DataFrame
Ejemplo
# import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
print df.groupby('Team')
Sus output es como sigue -
<pandas.core.groupby.DataFrameGroupBy object at 0x7fa46a977e50>
Ver grupos
# import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
print df.groupby('Team').groups
Sus output es como sigue -
{'Kings': Int64Index([4, 6, 7], dtype='int64'),
'Devils': Int64Index([2, 3], dtype='int64'),
'Riders': Int64Index([0, 1, 8, 11], dtype='int64'),
'Royals': Int64Index([9, 10], dtype='int64'),
'kings' : Int64Index([5], dtype='int64')}
Ejemplo
Group by con varias columnas -
# import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
print df.groupby(['Team','Year']).groups
Sus output es como sigue -
{('Kings', 2014): Int64Index([4], dtype='int64'),
('Royals', 2014): Int64Index([9], dtype='int64'),
('Riders', 2014): Int64Index([0], dtype='int64'),
('Riders', 2015): Int64Index([1], dtype='int64'),
('Kings', 2016): Int64Index([6], dtype='int64'),
('Riders', 2016): Int64Index([8], dtype='int64'),
('Riders', 2017): Int64Index([11], dtype='int64'),
('Devils', 2014): Int64Index([2], dtype='int64'),
('Devils', 2015): Int64Index([3], dtype='int64'),
('kings', 2015): Int64Index([5], dtype='int64'),
('Royals', 2015): Int64Index([10], dtype='int64'),
('Kings', 2017): Int64Index([7], dtype='int64')}
Iterando a través de grupos
Con el groupby objeto en mano, podemos iterar a través del objeto similar a itertools.obj.
# import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
grouped = df.groupby('Year')
for name,group in grouped:
print name
print group
Sus output es como sigue -
2014
Points Rank Team Year
0 876 1 Riders 2014
2 863 2 Devils 2014
4 741 3 Kings 2014
9 701 4 Royals 2014
2015
Points Rank Team Year
1 789 2 Riders 2015
3 673 3 Devils 2015
5 812 4 kings 2015
10 804 1 Royals 2015
2016
Points Rank Team Year
6 756 1 Kings 2016
8 694 2 Riders 2016
2017
Points Rank Team Year
7 788 1 Kings 2017
11 690 2 Riders 2017
Por defecto, el groupby El objeto tiene el mismo nombre de etiqueta que el nombre del grupo.
Seleccionar un grupo
Utilizando el get_group() método, podemos seleccionar un solo grupo.
# import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
grouped = df.groupby('Year')
print grouped.get_group(2014)
Sus output es como sigue -
Points Rank Team Year
0 876 1 Riders 2014
2 863 2 Devils 2014
4 741 3 Kings 2014
9 701 4 Royals 2014
Agregaciones
Una función agregada devuelve un único valor agregado para cada grupo. Una vez elgroup by se crea un objeto, se pueden realizar varias operaciones de agregación en los datos agrupados.
Uno obvio es la agregación a través del agregado o equivalente agg método -
# import the pandas library
import pandas as pd
import numpy as np
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
grouped = df.groupby('Year')
print grouped['Points'].agg(np.mean)
Sus output es como sigue -
Year
2014 795.25
2015 769.50
2016 725.00
2017 739.00
Name: Points, dtype: float64
Otra forma de ver el tamaño de cada grupo es aplicando la función size () -
import pandas as pd
import numpy as np
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
Attribute Access in Python Pandas
grouped = df.groupby('Team')
print grouped.agg(np.size)
Sus output es como sigue -
Points Rank Year
Team
Devils 2 2 2
Kings 3 3 3
Riders 4 4 4
Royals 2 2 2
kings 1 1 1
Aplicar múltiples funciones de agregación a la vez
Con Series agrupadas, también puede pasar un list o dict of functions para hacer agregación y generar DataFrame como salida -
# import the pandas library
import pandas as pd
import numpy as np
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
grouped = df.groupby('Team')
print grouped['Points'].agg([np.sum, np.mean, np.std])
Sus output es como sigue -
Team sum mean std
Devils 1536 768.000000 134.350288
Kings 2285 761.666667 24.006943
Riders 3049 762.250000 88.567771
Royals 1505 752.500000 72.831998
kings 812 812.000000 NaN
Transformaciones
La transformación en un grupo o una columna devuelve un objeto indexado del mismo tamaño que el que se está agrupando. Por lo tanto, la transformación debe devolver un resultado del mismo tamaño que el de un fragmento de grupo.
# import the pandas library
import pandas as pd
import numpy as np
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
grouped = df.groupby('Team')
score = lambda x: (x - x.mean()) / x.std()*10
print grouped.transform(score)
Sus output es como sigue -
Points Rank Year
0 12.843272 -15.000000 -11.618950
1 3.020286 5.000000 -3.872983
2 7.071068 -7.071068 -7.071068
3 -7.071068 7.071068 7.071068
4 -8.608621 11.547005 -10.910895
5 NaN NaN NaN
6 -2.360428 -5.773503 2.182179
7 10.969049 -5.773503 8.728716
8 -7.705963 5.000000 3.872983
9 -7.071068 7.071068 -7.071068
10 7.071068 -7.071068 7.071068
11 -8.157595 5.000000 11.618950
Filtración
La filtración filtra los datos según un criterio definido y devuelve el subconjunto de datos. losfilter() La función se utiliza para filtrar los datos.
import pandas as pd
import numpy as np
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
print df.groupby('Team').filter(lambda x: len(x) >= 3)
Sus output es como sigue -
Points Rank Team Year
0 876 1 Riders 2014
1 789 2 Riders 2015
4 741 3 Kings 2014
6 756 1 Kings 2016
7 788 1 Kings 2017
8 694 2 Riders 2016
11 690 2 Riders 2017
En la condición de filtro anterior, estamos pidiendo que devuelvan los equipos que han participado tres o más veces en IPL.
Pandas tiene operaciones de unión en memoria con todas las funciones y alto rendimiento idiomáticamente muy similares a las bases de datos relacionales como SQL.
Pandas proporciona una sola función, merge, como punto de entrada para todas las operaciones de unión de bases de datos estándar entre objetos DataFrame -
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True)
Aquí, hemos utilizado los siguientes parámetros:
left - Un objeto DataFrame.
right - Otro objeto DataFrame.
on- Columnas (nombres) para unirse. Debe encontrarse en los objetos DataFrame izquierdo y derecho.
left_on- Columnas del DataFrame izquierdo para usar como claves. Pueden ser nombres de columnas o matrices con una longitud igual a la longitud del DataFrame.
right_on- Columnas del DataFrame correcto para usar como claves. Pueden ser nombres de columnas o matrices con una longitud igual a la longitud del DataFrame.
left_index - si True,use el índice (etiquetas de fila) del DataFrame izquierdo como su (s) clave (s) de unión. En el caso de un DataFrame con un MultiIndex (jerárquico), el número de niveles debe coincidir con el número de claves de combinación del DataFrame correcto.
right_index - Mismo uso que left_index para el DataFrame correcto.
how- Uno de 'izquierda', 'derecha', 'exterior', 'interior'. Por defecto es inner. Cada método se describe a continuación.
sort- Ordene el DataFrame de resultado por las claves de combinación en orden lexicográfico. El valor predeterminado es Verdadero, si se establece en Falso mejorará sustancialmente el rendimiento en muchos casos.
Creemos ahora dos DataFrames diferentes y realicemos las operaciones de fusión en ellos.
# import the pandas library
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame(
{'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print left
print right
Sus output es como sigue -
Name id subject_id
0 Alex 1 sub1
1 Amy 2 sub2
2 Allen 3 sub4
3 Alice 4 sub6
4 Ayoung 5 sub5
Name id subject_id
0 Billy 1 sub2
1 Brian 2 sub4
2 Bran 3 sub3
3 Bryce 4 sub6
4 Betty 5 sub5
Fusionar dos DataFrames en una clave
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left,right,on='id')
Sus output es como sigue -
Name_x id subject_id_x Name_y subject_id_y
0 Alex 1 sub1 Billy sub2
1 Amy 2 sub2 Brian sub4
2 Allen 3 sub4 Bran sub3
3 Alice 4 sub6 Bryce sub6
4 Ayoung 5 sub5 Betty sub5
Fusionar dos DataFrames en varias claves
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left,right,on=['id','subject_id'])
Sus output es como sigue -
Name_x id subject_id Name_y
0 Alice 4 sub6 Bryce
1 Ayoung 5 sub5 Betty
Fusionar usando el argumento 'cómo'
los howEl argumento para fusionar especifica cómo determinar qué claves se incluirán en la tabla resultante. Si una combinación de teclas no aparece en las tablas de la izquierda o de la derecha, los valores de la tabla combinada serán NA.
Aquí hay un resumen de how opciones y sus nombres equivalentes SQL -
Método de fusión | Equivalente de SQL | Descripción |
---|---|---|
izquierda | IZQUIERDA COMBINACIÓN EXTERNA | Usar teclas del objeto izquierdo |
derecho | UNIÓN EXTERIOR DERECHA | Usar claves del objeto correcto |
exterior | UNIÓN EXTERIOR COMPLETA | Usar unión de llaves |
interior | UNIR INTERNAMENTE | Usar intersección de llaves |
Unión a la izquierda
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='left')
Sus output es como sigue -
Name_x id_x subject_id Name_y id_y
0 Alex 1 sub1 NaN NaN
1 Amy 2 sub2 Billy 1.0
2 Allen 3 sub4 Brian 2.0
3 Alice 4 sub6 Bryce 4.0
4 Ayoung 5 sub5 Betty 5.0
Unión derecha
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='right')
Sus output es como sigue -
Name_x id_x subject_id Name_y id_y
0 Amy 2.0 sub2 Billy 1
1 Allen 3.0 sub4 Brian 2
2 Alice 4.0 sub6 Bryce 4
3 Ayoung 5.0 sub5 Betty 5
4 NaN NaN sub3 Bran 3
Unión externa
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, how='outer', on='subject_id')
Sus output es como sigue -
Name_x id_x subject_id Name_y id_y
0 Alex 1.0 sub1 NaN NaN
1 Amy 2.0 sub2 Billy 1.0
2 Allen 3.0 sub4 Brian 2.0
3 Alice 4.0 sub6 Bryce 4.0
4 Ayoung 5.0 sub5 Betty 5.0
5 NaN NaN sub3 Bran 3.0
Unir internamente
La unión se realizará en index. La operación de unión respeta el objeto en el que se llama. Entonces,a.join(b) no es igual a b.join(a).
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='inner')
Sus output es como sigue -
Name_x id_x subject_id Name_y id_y
0 Amy 2 sub2 Billy 1
1 Allen 3 sub4 Brian 2
2 Alice 4 sub6 Bryce 4
3 Ayoung 5 sub5 Betty 5
Pandas ofrece varias facilidades para combinar fácilmente Series, DataFramey Panel objetos.
pd.concat(objs,axis=0,join='outer',join_axes=None,
ignore_index=False)
objs - Se trata de una secuencia o asignación de objetos Series, DataFrame o Panel.
axis - {0, 1, ...}, por defecto 0. Este es el eje para concatenar.
join- {'interior', 'exterior'}, predeterminado 'exterior'. Cómo manejar índices en otros ejes. Exterior para unión e interior para intersección.
ignore_index- booleano, por defecto Falso. Si es Verdadero, no use los valores de índice en el eje de concatenación. El eje resultante se etiquetará como 0, ..., n - 1.
join_axes- Esta es la lista de objetos Index. Índices específicos para usar para los otros (n-1) ejes en lugar de realizar una lógica de conjunto interno / externo.
Concatenar objetos
los concatLa función hace todo el trabajo pesado de realizar operaciones de concatenación a lo largo de un eje. Creemos diferentes objetos y hagamos concatenaciones.
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print pd.concat([one,two])
Sus output es como sigue -
Marks_scored Name subject_id
1 98 Alex sub1
2 90 Amy sub2
3 87 Allen sub4
4 69 Alice sub6
5 78 Ayoung sub5
1 89 Billy sub2
2 80 Brian sub4
3 79 Bran sub3
4 97 Bryce sub6
5 88 Betty sub5
Supongamos que quisiéramos asociar claves específicas con cada una de las piezas del DataFrame cortado. Podemos hacer esto usando elkeys argumento -
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print pd.concat([one,two],keys=['x','y'])
Sus output es como sigue -
x 1 98 Alex sub1
2 90 Amy sub2
3 87 Allen sub4
4 69 Alice sub6
5 78 Ayoung sub5
y 1 89 Billy sub2
2 80 Brian sub4
3 79 Bran sub3
4 97 Bryce sub6
5 88 Betty sub5
El índice de la resultante se duplica; cada índice se repite.
Si el objeto resultante tiene que seguir su propia indexación, establezca ignore_index a True.
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print pd.concat([one,two],keys=['x','y'],ignore_index=True)
Sus output es como sigue -
Marks_scored Name subject_id
0 98 Alex sub1
1 90 Amy sub2
2 87 Allen sub4
3 69 Alice sub6
4 78 Ayoung sub5
5 89 Billy sub2
6 80 Brian sub4
7 79 Bran sub3
8 97 Bryce sub6
9 88 Betty sub5
Observe, el índice cambia completamente y las claves también se anulan.
Si es necesario agregar dos objetos axis=1, luego se agregarán las nuevas columnas.
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print pd.concat([one,two],axis=1)
Sus output es como sigue -
Marks_scored Name subject_id Marks_scored Name subject_id
1 98 Alex sub1 89 Billy sub2
2 90 Amy sub2 80 Brian sub4
3 87 Allen sub4 79 Bran sub3
4 69 Alice sub6 97 Bryce sub6
5 78 Ayoung sub5 88 Betty sub5
Concatenar usando agregar
Un atajo útil para concat son los métodos de instancia adjunta en Series y DataFrame. Estos métodos en realidad son anteriores a la concat. Se concatenan a lo largoaxis=0, a saber, el índice -
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print one.append(two)
Sus output es como sigue -
Marks_scored Name subject_id
1 98 Alex sub1
2 90 Amy sub2
3 87 Allen sub4
4 69 Alice sub6
5 78 Ayoung sub5
1 89 Billy sub2
2 80 Brian sub4
3 79 Bran sub3
4 97 Bryce sub6
5 88 Betty sub5
los append La función también puede tomar varios objetos -
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print one.append([two,one,two])
Sus output es como sigue -
Marks_scored Name subject_id
1 98 Alex sub1
2 90 Amy sub2
3 87 Allen sub4
4 69 Alice sub6
5 78 Ayoung sub5
1 89 Billy sub2
2 80 Brian sub4
3 79 Bran sub3
4 97 Bryce sub6
5 88 Betty sub5
1 98 Alex sub1
2 90 Amy sub2
3 87 Allen sub4
4 69 Alice sub6
5 78 Ayoung sub5
1 89 Billy sub2
2 80 Brian sub4
3 79 Bran sub3
4 97 Bryce sub6
5 88 Betty sub5
Series de tiempo
Pandas proporciona una herramienta sólida para el tiempo de trabajo con datos de series temporales, especialmente en el sector financiero. Al trabajar con datos de series de tiempo, con frecuencia nos encontramos con lo siguiente:
- Generando secuencia de tiempo
- Convierte la serie temporal a diferentes frecuencias.
Pandas proporciona un conjunto de herramientas relativamente compacto y autónomo para realizar las tareas anteriores.
Obtener la hora actual
datetime.now() le da la fecha y hora actual.
import pandas as pd
print pd.datetime.now()
Sus output es como sigue -
2017-05-11 06:10:13.393147
Crear una marca de tiempo
Los datos con marcas de tiempo son el tipo más básico de datos de series temporales que asocian valores con puntos en el tiempo. Para los objetos pandas, significa usar los puntos en el tiempo. Tomemos un ejemplo:
import pandas as pd
print pd.Timestamp('2017-03-01')
Sus output es como sigue -
2017-03-01 00:00:00
También es posible convertir tiempos de época enteros o flotantes. La unidad predeterminada para estos son nanosegundos (ya que así se almacenan las marcas de tiempo). Sin embargo, a menudo las épocas se almacenan en otra unidad que se puede especificar. Tomemos otro ejemplo
import pandas as pd
print pd.Timestamp(1587687255,unit='s')
Sus output es como sigue -
2020-04-24 00:14:15
Crea un rango de tiempo
import pandas as pd
print pd.date_range("11:00", "13:30", freq="30min").time
Sus output es como sigue -
[datetime.time(11, 0) datetime.time(11, 30) datetime.time(12, 0)
datetime.time(12, 30) datetime.time(13, 0) datetime.time(13, 30)]
Cambiar la frecuencia del tiempo
import pandas as pd
print pd.date_range("11:00", "13:30", freq="H").time
Sus output es como sigue -
[datetime.time(11, 0) datetime.time(12, 0) datetime.time(13, 0)]
Conversión a marcas de tiempo
Para convertir una serie o un objeto similar a una lista de objetos similares a una fecha, por ejemplo, cadenas, épocas o una mezcla, puede utilizar el to_datetimefunción. Cuando se pasa, devuelve una Serie (con el mismo índice), mientras que unalist-like se convierte en un DatetimeIndex. Eche un vistazo al siguiente ejemplo:
import pandas as pd
print pd.to_datetime(pd.Series(['Jul 31, 2009','2010-01-10', None]))
Sus output es como sigue -
0 2009-07-31
1 2010-01-10
2 NaT
dtype: datetime64[ns]
NaT medio Not a Time (equivalente a NaN)
Tomemos otro ejemplo.
import pandas as pd
print pd.to_datetime(['2005/11/23', '2010.12.31', None])
Sus output es como sigue -
DatetimeIndex(['2005-11-23', '2010-12-31', 'NaT'], dtype='datetime64[ns]', freq=None)
Al extender la serie temporal, las funciones de fecha juegan un papel importante en el análisis de datos financieros. Al trabajar con datos de fecha, con frecuencia nos encontramos con lo siguiente:
- Generando secuencia de fechas
- Convierta la serie de fechas a diferentes frecuencias
Crea un rango de fechas
Utilizando el date.range()función especificando los períodos y la frecuencia, podemos crear la serie de fechas. De forma predeterminada, la frecuencia del rango es Días.
import pandas as pd
print pd.date_range('1/1/2011', periods=5)
Sus output es como sigue -
DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
dtype='datetime64[ns]', freq='D')
Cambiar la frecuencia de la fecha
import pandas as pd
print pd.date_range('1/1/2011', periods=5,freq='M')
Sus output es como sigue -
DatetimeIndex(['2011-01-31', '2011-02-28', '2011-03-31', '2011-04-30', '2011-05-31'],
dtype='datetime64[ns]', freq='M')
bdate_range
bdate_range () significa rangos de fechas comerciales. A diferencia de date_range (), excluye sábado y domingo.
import pandas as pd
print pd.date_range('1/1/2011', periods=5)
Sus output es como sigue -
DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
dtype='datetime64[ns]', freq='D')
Observe, después del 3 de marzo, la fecha salta al 6 de marzo excluyendo el 4 y el 5. Solo revisa tu calendario para ver los días.
Funciones de conveniencia como date_range y bdate_rangeutilizar una variedad de alias de frecuencia. La frecuencia predeterminada para date_range es un día calendario, mientras que la predeterminada para bdate_range es un día hábil.
import pandas as pd
start = pd.datetime(2011, 1, 1)
end = pd.datetime(2011, 1, 5)
print pd.date_range(start, end)
Sus output es como sigue -
DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
dtype='datetime64[ns]', freq='D')
Desplazamiento de alias
Se dan varios alias de cadena a frecuencias de series temporales comunes útiles. Nos referiremos a estos alias como alias de compensación.
Alias | Descripción | Alias | Descripción |
---|---|---|---|
segundo | frecuencia del día laboral | BQS | frecuencia de inicio del trimestre comercial |
re | frecuencia del día calendario | UN | frecuencia de finalización anual (año) |
W | frecuencia semanal | licenciado en Letras | frecuencia de fin de año comercial |
METRO | frecuencia de fin de mes | BAS | frecuencia de inicio del año comercial |
SM | frecuencia de fin de mes | BH | frecuencia del horario comercial |
BM | frecuencia de fin de mes laboral | H | frecuencia horaria |
em | frecuencia de inicio del mes | T, min | minuciosamente frecuencia |
SMS | Frecuencia de inicio de SMS semestral | S | en segundo lugar frecuencia |
BMS | frecuencia de inicio del mes laboral | L, ms | milisegundos |
Q | frecuencia de cuarto de final | U, nosotros | microsegundos |
BQ | frecuencia de cierre del trimestre comercial | norte | nanosegundos |
QS | cuarto de frecuencia de inicio |
Timedeltas son diferencias en los tiempos, expresadas en unidades de diferencia, por ejemplo, días, horas, minutos, segundos. Pueden ser tanto positivos como negativos.
Podemos crear objetos Timedelta usando varios argumentos como se muestra a continuación:
Cuerda
Al pasar un literal de cadena, podemos crear un objeto timedelta.
import pandas as pd
print pd.Timedelta('2 days 2 hours 15 minutes 30 seconds')
Sus output es como sigue -
2 days 02:15:30
Entero
Al pasar un valor entero con la unidad, un argumento crea un objeto Timedelta.
import pandas as pd
print pd.Timedelta(6,unit='h')
Sus output es como sigue -
0 days 06:00:00
Compensación de datos
Las compensaciones de datos como: semanas, días, horas, minutos, segundos, milisegundos, microsegundos, nanosegundos también se pueden utilizar en la construcción.
import pandas as pd
print pd.Timedelta(days=2)
Sus output es como sigue -
2 days 00:00:00
to_timedelta ()
Usando el nivel superior pd.to_timedelta, puede convertir un escalar, una matriz, una lista o una serie de un formato / valor de timedelta reconocido en un tipo de Timedelta. Construirá Series si la entrada es una Serie, un escalar si la entrada es similar a un escalar; de lo contrario, generará unaTimedeltaIndex.
import pandas as pd
print pd.Timedelta(days=2)
Sus output es como sigue -
2 days 00:00:00
Operaciones
Puede operar en Series / DataFrames y construir timedelta64[ns] Series mediante operaciones de resta en datetime64[ns] Serie o marcas de tiempo.
Creemos ahora un DataFrame con Timedelta y objetos de fecha y hora y realicemos algunas operaciones aritméticas en él:
import pandas as pd
s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
print df
Sus output es como sigue -
A B
0 2012-01-01 0 days
1 2012-01-02 1 days
2 2012-01-03 2 days
Operaciones de adición
import pandas as pd
s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
df['C']=df['A']+df['B']
print df
Sus output es como sigue -
A B C
0 2012-01-01 0 days 2012-01-01
1 2012-01-02 1 days 2012-01-03
2 2012-01-03 2 days 2012-01-05
Operación de resta
import pandas as pd
s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
df['C']=df['A']+df['B']
df['D']=df['C']+df['B']
print df
Sus output es como sigue -
A B C D
0 2012-01-01 0 days 2012-01-01 2012-01-01
1 2012-01-02 1 days 2012-01-03 2012-01-04
2 2012-01-03 2 days 2012-01-05 2012-01-07
A menudo, en tiempo real, los datos incluyen las columnas de texto, que son repetitivas. Las características como el género, el país y los códigos siempre son repetitivas. Estos son los ejemplos de datos categóricos.
Las variables categóricas pueden tomar solo un número limitado y generalmente fijo de valores posibles. Además de la longitud fija, los datos categóricos pueden tener un orden pero no pueden realizar operaciones numéricas. Los categóricos son un tipo de datos de Pandas.
El tipo de datos categóricos es útil en los siguientes casos:
Una variable de cadena que consta de solo unos pocos valores diferentes. Convertir una variable de cadena de este tipo en una variable categórica ahorrará algo de memoria.
El orden léxico de una variable no es el mismo que el orden lógico ("uno", "dos", "tres"). Al convertir a categórico y especificar un orden en las categorías, la clasificación y el mínimo / máximo utilizarán el orden lógico en lugar del léxico.
Como señal a otras bibliotecas de Python de que esta columna debe tratarse como una variable categórica (por ejemplo, para utilizar métodos estadísticos adecuados o tipos de gráficos).
Creación de objetos
El objeto categórico se puede crear de varias formas. Las diferentes formas se describen a continuación:
categoría
Especificando el dtype como "categoría" en la creación de objetos pandas.
import pandas as pd
s = pd.Series(["a","b","c","a"], dtype="category")
print s
Sus output es como sigue -
0 a
1 b
2 c
3 a
dtype: category
Categories (3, object): [a, b, c]
El número de elementos que se pasan al objeto de serie es cuatro, pero las categorías son solo tres. Observe lo mismo en las Categorías de salida.
pd.Categorical
Usando el constructor categórico estándar de pandas, podemos crear un objeto de categoría.
pandas.Categorical(values, categories, ordered)
Tomemos un ejemplo:
import pandas as pd
cat = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'])
print cat
Sus output es como sigue -
[a, b, c, a, b, c]
Categories (3, object): [a, b, c]
Tengamos otro ejemplo:
import pandas as pd
cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'])
print cat
Sus output es como sigue -
[a, b, c, a, b, c, NaN]
Categories (3, object): [c, b, a]
Aquí, el segundo argumento significa las categorías. Por lo tanto, cualquier valor que no esté presente en las categorías se tratará comoNaN.
Ahora, eche un vistazo al siguiente ejemplo:
import pandas as pd
cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'],ordered=True)
print cat
Sus output es como sigue -
[a, b, c, a, b, c, NaN]
Categories (3, object): [c < b < a]
Lógicamente, el orden significa que, a es mayor que b y b es mayor que c.
Descripción
Utilizando el .describe() comando en los datos categóricos, obtenemos un resultado similar a un Series o DataFrame del type cuerda.
import pandas as pd
import numpy as np
cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
df = pd.DataFrame({"cat":cat, "s":["a", "c", "c", np.nan]})
print df.describe()
print df["cat"].describe()
Sus output es como sigue -
cat s
count 3 3
unique 2 2
top c c
freq 2 2
count 3
unique 2
top c
freq 2
Name: cat, dtype: object
Obtenga las propiedades de la categoría
obj.cat.categories El comando se usa para obtener el categories of the object.
import pandas as pd
import numpy as np
s = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
print s.categories
Sus output es como sigue -
Index([u'b', u'a', u'c'], dtype='object')
obj.ordered El comando se usa para obtener el orden del objeto.
import pandas as pd
import numpy as np
cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
print cat.ordered
Sus output es como sigue -
False
La función regresó false porque no hemos especificado ningún pedido.
Cambio de nombre de categorías
El cambio de nombre de las categorías se realiza asignando nuevos valores al series.cat.categoriesPropiedad series.cat.categories.
import pandas as pd
s = pd.Series(["a","b","c","a"], dtype="category")
s.cat.categories = ["Group %s" % g for g in s.cat.categories]
print s.cat.categories
Sus output es como sigue -
Index([u'Group a', u'Group b', u'Group c'], dtype='object')
Categorías iniciales [a,b,c] son actualizados por el s.cat.categories propiedad del objeto.
Agregar nuevas categorías
Usando el método Categorical.add.categories (), se pueden agregar nuevas categorías.
import pandas as pd
s = pd.Series(["a","b","c","a"], dtype="category")
s = s.cat.add_categories([4])
print s.cat.categories
Sus output es como sigue -
Index([u'a', u'b', u'c', 4], dtype='object')
Eliminar categorías
Utilizando el Categorical.remove_categories() método, las categorías no deseadas se pueden eliminar.
import pandas as pd
s = pd.Series(["a","b","c","a"], dtype="category")
print ("Original object:")
print s
print ("After removal:")
print s.cat.remove_categories("a")
Sus output es como sigue -
Original object:
0 a
1 b
2 c
3 a
dtype: category
Categories (3, object): [a, b, c]
After removal:
0 NaN
1 b
2 c
3 NaN
dtype: category
Categories (2, object): [b, c]
Comparación de datos categóricos
La comparación de datos categóricos con otros objetos es posible en tres casos:
comparar la igualdad (== y! =) con un objeto similar a una lista (lista, Serie, matriz, ...) de la misma longitud que los datos categóricos.
todas las comparaciones (==,! =,>,> =, <y <=) de datos categóricos con otra Serie categórica, cuando se ordenan == Verdadero y las categorías son las mismas.
todas las comparaciones de datos categóricos con un escalar.
Eche un vistazo al siguiente ejemplo:
import pandas as pd
cat = pd.Series([1,2,3]).astype("category", categories=[1,2,3], ordered=True)
cat1 = pd.Series([2,2,2]).astype("category", categories=[1,2,3], ordered=True)
print cat>cat1
Sus output es como sigue -
0 False
1 False
2 True
dtype: bool
Trazado básico: trama
Esta funcionalidad en Series y DataFrame es solo una envoltura simple alrededor del matplotlib libraries plot() método.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10,4),index=pd.date_range('1/1/2000',
periods=10), columns=list('ABCD'))
df.plot()
Sus output es como sigue -
Si el índice consta de fechas, llama gct().autofmt_xdate() para formatear el eje x como se muestra en la ilustración anterior.
Podemos trazar una columna frente a otra usando el x y y palabras clave.
Los métodos de trazado permiten un puñado de estilos de trazado distintos del trazado de líneas predeterminado. Estos métodos se pueden proporcionar como el argumento de palabra clave kind paraplot(). Estos incluyen:
- bar o barh para parcelas de barras
- hist para histograma
- caja para diagrama de caja
- 'área' para parcelas de área
- 'scatter' para diagramas de dispersión
Gráfico de barras
Veamos ahora qué es un gráfico de barras creando uno. Se puede crear un diagrama de barras de la siguiente manera:
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar()
Sus output es como sigue -
Para producir un diagrama de barras apiladas, pass stacked=True -
import pandas as pd
df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar(stacked=True)
Sus output es como sigue -
Para obtener diagramas de barras horizontales, use el barh método -
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.barh(stacked=True)
Sus output es como sigue -
Histogramas
Los histogramas se pueden trazar usando el plot.hist()método. Podemos especificar el número de contenedores.
import pandas as pd
import numpy as np
df = pd.DataFrame({'a':np.random.randn(1000)+1,'b':np.random.randn(1000),'c':
np.random.randn(1000) - 1}, columns=['a', 'b', 'c'])
df.plot.hist(bins=20)
Sus output es como sigue -
Para trazar diferentes histogramas para cada columna, use el siguiente código:
import pandas as pd
import numpy as np
df=pd.DataFrame({'a':np.random.randn(1000)+1,'b':np.random.randn(1000),'c':
np.random.randn(1000) - 1}, columns=['a', 'b', 'c'])
df.diff.hist(bins=20)
Sus output es como sigue -
Diagramas de caja
El diagrama de caja se puede dibujar llamando Series.box.plot() y DataFrame.box.plot()o DataFrame.boxplot() para visualizar la distribución de valores dentro de cada columna.
Por ejemplo, aquí hay una gráfica de caja que representa cinco ensayos de 10 observaciones de una variable aleatoria uniforme en [0,1).
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10, 5), columns=['A', 'B', 'C', 'D', 'E'])
df.plot.box()
Sus output es como sigue -
Parcela de área
La gráfica de área se puede crear usando el Series.plot.area() o la DataFrame.plot.area() métodos.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10, 4), columns=['a', 'b', 'c', 'd'])
df.plot.area()
Sus output es como sigue -
Gráfico de dispersión
El diagrama de dispersión se puede crear usando el DataFrame.plot.scatter() métodos.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(50, 4), columns=['a', 'b', 'c', 'd'])
df.plot.scatter(x='a', y='b')
Sus output es como sigue -
Gráfico circular
El gráfico circular se puede crear usando el DataFrame.plot.pie() método.
import pandas as pd
import numpy as np
df = pd.DataFrame(3 * np.random.rand(4), index=['a', 'b', 'c', 'd'], columns=['x'])
df.plot.pie(subplots=True)
Sus output es como sigue -
los Pandas I/O API es un conjunto de funciones de lectura de nivel superior a las que se accede como pd.read_csv() que generalmente devuelven un objeto Pandas.
Las dos funciones de caballo de batalla para leer archivos de texto (o los archivos planos) son read_csv() y read_table(). Ambos usan el mismo código de análisis para convertir inteligentemente datos tabulares en unDataFrame objeto -
pandas.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer',
names=None, index_col=None, usecols=None
pandas.read_csv(filepath_or_buffer, sep='\t', delimiter=None, header='infer',
names=None, index_col=None, usecols=None
Así es como csv los datos del archivo se parecen a
S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900
Guarde estos datos como temp.csv y realizar operaciones en él.
S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900
Guarde estos datos como temp.csv y realizar operaciones en él.
read.csv
read.csv lee datos de los archivos csv y crea un objeto DataFrame.
import pandas as pd
df=pd.read_csv("temp.csv")
print df
Sus output es como sigue -
S.No Name Age City Salary
0 1 Tom 28 Toronto 20000
1 2 Lee 32 HongKong 3000
2 3 Steven 43 Bay Area 8300
3 4 Ram 38 Hyderabad 3900
índice personalizado
Esto especifica una columna en el archivo csv para personalizar el índice usando index_col.
import pandas as pd
df=pd.read_csv("temp.csv",index_col=['S.No'])
print df
Sus output es como sigue -
S.No Name Age City Salary
1 Tom 28 Toronto 20000
2 Lee 32 HongKong 3000
3 Steven 43 Bay Area 8300
4 Ram 38 Hyderabad 3900
Convertidores
dtype de las columnas se puede pasar como un dict.
import pandas as pd
df = pd.read_csv("temp.csv", dtype={'Salary': np.float64})
print df.dtypes
Sus output es como sigue -
S.No int64
Name object
Age int64
City object
Salary float64
dtype: object
Por defecto, el dtype de la columna Salario es int, pero el resultado lo muestra como float porque hemos lanzado explícitamente el tipo.
Por lo tanto, los datos parecen flotantes:
S.No Name Age City Salary
0 1 Tom 28 Toronto 20000.0
1 2 Lee 32 HongKong 3000.0
2 3 Steven 43 Bay Area 8300.0
3 4 Ram 38 Hyderabad 3900.0
header_names
Especifique los nombres del encabezado utilizando el argumento de nombres.
import pandas as pd
df=pd.read_csv("temp.csv", names=['a', 'b', 'c','d','e'])
print df
Sus output es como sigue -
a b c d e
0 S.No Name Age City Salary
1 1 Tom 28 Toronto 20000
2 2 Lee 32 HongKong 3000
3 3 Steven 43 Bay Area 8300
4 4 Ram 38 Hyderabad 3900
Observe que los nombres de los encabezados se adjuntan con los nombres personalizados, pero el encabezado del archivo no se ha eliminado. Ahora, usamos el argumento del encabezado para eliminar eso.
Si el encabezado está en una fila que no sea la primera, pase el número de fila al encabezado. Esto omitirá las filas anteriores.
import pandas as pd
df=pd.read_csv("temp.csv",names=['a','b','c','d','e'],header=0)
print df
Sus output es como sigue -
a b c d e
0 S.No Name Age City Salary
1 1 Tom 28 Toronto 20000
2 2 Lee 32 HongKong 3000
3 3 Steven 43 Bay Area 8300
4 4 Ram 38 Hyderabad 3900
saltos
skiprows omite el número de filas especificado.
import pandas as pd
df=pd.read_csv("temp.csv", skiprows=2)
print df
Sus output es como sigue -
2 Lee 32 HongKong 3000
0 3 Steven 43 Bay Area 8300
1 4 Ram 38 Hyderabad 3900
Los objetos dispersos se “comprimen” cuando se omite cualquier dato que coincida con un valor específico (NaN / valor perdido, aunque se puede elegir cualquier valor). Un objeto SparseIndex especial rastrea donde los datos se han "dispersado". Esto tendrá mucho más sentido en un ejemplo. Todas las estructuras de datos estándar de Pandas aplican lato_sparse método -
import pandas as pd
import numpy as np
ts = pd.Series(np.random.randn(10))
ts[2:-2] = np.nan
sts = ts.to_sparse()
print sts
Sus output es como sigue -
0 -0.810497
1 -1.419954
2 NaN
3 NaN
4 NaN
5 NaN
6 NaN
7 NaN
8 0.439240
9 -1.095910
dtype: float64
BlockIndex
Block locations: array([0, 8], dtype=int32)
Block lengths: array([2, 2], dtype=int32)
Los objetos dispersos existen por razones de eficiencia de la memoria.
Supongamos ahora que tiene un NA DataFrame grande y ejecute el siguiente código:
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10000, 4))
df.ix[:9998] = np.nan
sdf = df.to_sparse()
print sdf.density
Sus output es como sigue -
0.0001
Cualquier objeto disperso se puede convertir de nuevo a la forma densa estándar llamando to_dense -
import pandas as pd
import numpy as np
ts = pd.Series(np.random.randn(10))
ts[2:-2] = np.nan
sts = ts.to_sparse()
print sts.to_dense()
Sus output es como sigue -
0 -0.810497
1 -1.419954
2 NaN
3 NaN
4 NaN
5 NaN
6 NaN
7 NaN
8 0.439240
9 -1.095910
dtype: float64
Tipos D dispersos
Los datos dispersos deben tener el mismo tipo d que su representación densa. Actualmente,float64, int64 y booldtypesson compatibles. Dependiendo del originaldtype, fill_value default cambios -
float64 - np.nan
int64 - 0
bool - falso
Ejecutemos el siguiente código para entender lo mismo:
import pandas as pd
import numpy as np
s = pd.Series([1, np.nan, np.nan])
print s
s.to_sparse()
print s
Sus output es como sigue -
0 1.0
1 NaN
2 NaN
dtype: float64
0 1.0
1 NaN
2 NaN
dtype: float64
Advertencias significa advertencia y atrapados significa un problema invisible.
Uso de If / Truth Statement con Pandas
Pandas sigue la convención numpy de generar un error cuando intentas convertir algo en un bool. Esto sucede en unif o when usando las operaciones booleanas, y, oro not. No está claro cuál debería ser el resultado. ¿Debería ser verdadero porque no es de longitud cero? ¿Falso porque hay valores falsos? No está claro, por lo que en su lugar, Pandas plantea unValueError -
import pandas as pd
if pd.Series([False, True, False]):
print 'I am True'
Sus output es como sigue -
ValueError: The truth value of a Series is ambiguous.
Use a.empty, a.bool() a.item(),a.any() or a.all().
En ifcondición, no está claro qué hacer con ella. El error sugiere si se debe utilizar unNone o any of those.
import pandas as pd
if pd.Series([False, True, False]).any():
print("I am any")
Sus output es como sigue -
I am any
Para evaluar objetos pandas de un solo elemento en un contexto booleano, use el método .bool() -
import pandas as pd
print pd.Series([True]).bool()
Sus output es como sigue -
True
Booleano bit a bit
Operadores booleanos bit a bit como == y != devolverá una serie booleana, que es casi siempre lo que se requiere de todos modos.
import pandas as pd
s = pd.Series(range(5))
print s==4
Sus output es como sigue -
0 False
1 False
2 False
3 False
4 True
dtype: bool
está en operación
Esto devuelve una serie booleana que muestra si cada elemento de la serie está contenido exactamente en la secuencia de valores pasada.
import pandas as pd
s = pd.Series(list('abc'))
s = s.isin(['a', 'c', 'e'])
print s
Sus output es como sigue -
0 True
1 False
2 True
dtype: bool
Reindexar vs ix Gotcha
Muchos usuarios se encontrarán usando el ix indexing capabilities como un medio conciso de seleccionar datos de un objeto Pandas -
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))
print df
print df.ix[['b', 'c', 'e']]
Sus output es como sigue -
one two three four
a -1.582025 1.335773 0.961417 -1.272084
b 1.461512 0.111372 -0.072225 0.553058
c -1.240671 0.762185 1.511936 -0.630920
d -2.380648 -0.029981 0.196489 0.531714
e 1.846746 0.148149 0.275398 -0.244559
f -1.842662 -0.933195 2.303949 0.677641
one two three four
b 1.461512 0.111372 -0.072225 0.553058
c -1.240671 0.762185 1.511936 -0.630920
e 1.846746 0.148149 0.275398 -0.244559
Esto es, por supuesto, completamente equivalente en este caso a usar el reindex método -
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))
print df
print df.reindex(['b', 'c', 'e'])
Sus output es como sigue -
one two three four
a 1.639081 1.369838 0.261287 -1.662003
b -0.173359 0.242447 -0.494384 0.346882
c -0.106411 0.623568 0.282401 -0.916361
d -1.078791 -0.612607 -0.897289 -1.146893
e 0.465215 1.552873 -1.841959 0.329404
f 0.966022 -0.190077 1.324247 0.678064
one two three four
b -0.173359 0.242447 -0.494384 0.346882
c -0.106411 0.623568 0.282401 -0.916361
e 0.465215 1.552873 -1.841959 0.329404
Algunos podrían concluir que ix y reindexson 100% equivalentes en base a esto. Esto es cierto excepto en el caso de la indexación de enteros. Por ejemplo, la operación anterior se puede expresar alternativamente como:
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))
print df
print df.ix[[1, 2, 4]]
print df.reindex([1, 2, 4])
Sus output es como sigue -
one two three four
a -1.015695 -0.553847 1.106235 -0.784460
b -0.527398 -0.518198 -0.710546 -0.512036
c -0.842803 -1.050374 0.787146 0.205147
d -1.238016 -0.749554 -0.547470 -0.029045
e -0.056788 1.063999 -0.767220 0.212476
f 1.139714 0.036159 0.201912 0.710119
one two three four
b -0.527398 -0.518198 -0.710546 -0.512036
c -0.842803 -1.050374 0.787146 0.205147
e -0.056788 1.063999 -0.767220 0.212476
one two three four
1 NaN NaN NaN NaN
2 NaN NaN NaN NaN
4 NaN NaN NaN NaN
Es importante recordar que reindex is strict label indexing only. Esto puede conducir a algunos resultados potencialmente sorprendentes en casos patológicos donde un índice contiene, digamos, tanto enteros como cadenas.
Dado que muchos usuarios potenciales de Pandas están familiarizados con SQL, esta página está destinada a proporcionar algunos ejemplos de cómo se pueden realizar varias operaciones de SQL utilizando pandas.
import pandas as pd
url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'
tips=pd.read_csv(url)
print tips.head()
Sus output es como sigue -
total_bill tip sex smoker day time size
0 16.99 1.01 Female No Sun Dinner 2
1 10.34 1.66 Male No Sun Dinner 3
2 21.01 3.50 Male No Sun Dinner 3
3 23.68 3.31 Male No Sun Dinner 2
4 24.59 3.61 Female No Sun Dinner 4
SELECCIONE
En SQL, la selección se realiza mediante una lista de columnas separadas por comas que seleccione (o un * para seleccionar todas las columnas) -
SELECT total_bill, tip, smoker, time
FROM tips
LIMIT 5;
Con Pandas, la selección de columnas se realiza pasando una lista de nombres de columnas a su DataFrame -
tips[['total_bill', 'tip', 'smoker', 'time']].head(5)
Veamos el programa completo -
import pandas as pd
url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'
tips=pd.read_csv(url)
print tips[['total_bill', 'tip', 'smoker', 'time']].head(5)
Sus output es como sigue -
total_bill tip smoker time
0 16.99 1.01 No Dinner
1 10.34 1.66 No Dinner
2 21.01 3.50 No Dinner
3 23.68 3.31 No Dinner
4 24.59 3.61 No Dinner
Llamar al DataFrame sin la lista de nombres de columna mostrará todas las columnas (similar a SQL *).
DÓNDE
El filtrado en SQL se realiza mediante una cláusula WHERE.
SELECT * FROM tips WHERE time = 'Dinner' LIMIT 5;
Los DataFrames se pueden filtrar de varias formas; el más intuitivo es el uso de la indexación booleana.
tips[tips['time'] == 'Dinner'].head(5)
Veamos el programa completo -
import pandas as pd
url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'
tips=pd.read_csv(url)
print tips[tips['time'] == 'Dinner'].head(5)
Sus output es como sigue -
total_bill tip sex smoker day time size
0 16.99 1.01 Female No Sun Dinner 2
1 10.34 1.66 Male No Sun Dinner 3
2 21.01 3.50 Male No Sun Dinner 3
3 23.68 3.31 Male No Sun Dinner 2
4 24.59 3.61 Female No Sun Dinner 4
La declaración anterior pasa una serie de objetos True / False al DataFrame, devolviendo todas las filas con True.
Agrupar por
Esta operación obtiene el recuento de registros de cada grupo en un conjunto de datos. Por ejemplo, una consulta que nos muestre la cantidad de propinas dejadas por sexo:
SELECT sex, count(*)
FROM tips
GROUP BY sex;
El equivalente de Pandas sería:
tips.groupby('sex').size()
Veamos el programa completo -
import pandas as pd
url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'
tips=pd.read_csv(url)
print tips.groupby('sex').size()
Sus output es como sigue -
sex
Female 87
Male 157
dtype: int64
N filas superiores
SQL devuelve el top n rows utilizando LIMIT -
SELECT * FROM tips
LIMIT 5 ;
El equivalente de Pandas sería:
tips.head(5)
Veamos el ejemplo completo:
import pandas as pd
url = 'https://raw.github.com/pandas-dev/pandas/master/pandas/tests/data/tips.csv'
tips=pd.read_csv(url)
tips = tips[['smoker', 'day', 'time']].head(5)
print tips
Sus output es como sigue -
smoker day time
0 No Sun Dinner
1 No Sun Dinner
2 No Sun Dinner
3 No Sun Dinner
4 No Sun Dinner
Estas son las pocas operaciones básicas que comparamos y que aprendimos en los capítulos anteriores de la Biblioteca de Pandas.