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.