Python dataframe con ejemplos

Para obtener información de los datos, debe jugar con ellos un poco…

Es importante poder extraer, filtrar y transformar datos de DataFrames para profundizar en los datos que realmente importan. La biblioteca de pandas tiene muchas técnicas que hacen que este proceso sea eficiente e intuitivo.

En este artículo enumeraré esas técnicas con ejemplos de código y algunas explicaciones. Comencemos.

DataFrame es una estructura de datos etiquetada bidimensional con columnas de tipos potencialmente diferentes.  Generalmente es el objeto pandas más utilizado.

Indexando Python dataframe

Para extraer datos de pandas DataFrame podemos usar indexación directa o accesores.

Podemos seleccionar las filas y columnas necesarias utilizando sus etiquetas:

df['column_name']['row_name']

Tenga en cuenta el orden en este tipo de indexación: primero especifique la etiqueta de la columna y luego la fila. Pero la verdad es que los conjuntos de datos son raros y pequeños, mientras que en la vida real trabajamos con maquinaria mucho más pesada.

Es mucho mejor seleccionar datos usando los accesores  .loc y .iloc . La diferencia entre ellos es que .loc acepta etiquetas y .iloc – índices. También cuando usamos los accesores primero especificamos filas y luego columnas.

Por lo tanto, para seleccionar un solo valor mediante los accesores.

Debería hacer lo siguiente:

df.loc['rowname', 'colname']
df.iloc[rowindex, colindex] ==> df.iloc [4, 2]

Usando la indexación podemos seleccionar un solo valor, Serie o Marco de datos de un Marco de datos (perdón por la tautología).

Arriba hemos mostrado cómo seleccionar un valor. Para subseleccionar algunas columnas, simplemente pase la lista anidada de sus etiquetas y se devolverá el DataFrame:

df_new = df[['colname1','colname2']]

Si desea seleccionar filas específicas, agregue sus índices y obtendrá un python dataframe nuevamente . Esta técnica se llama división:

df_new = df[['colname1','colname2']] [1:4]

Para seleccionar una Serie, debe seleccionar una sola columna con todas o un rango de filas:

df['colname'] df.loc [:,'colname']
df.iloc[:, 2]

Los dos puntos significan que queremos seleccionar todas las filas o todas las columnas – df.loc[:,:] o df.iloc[:,:] devolverá todos los valores.

Y poco a poco llegamos al corte – seleccionando rangos específicos de nuestros datos. Para dividir una Serie, solo agregue un rango de filas que desee seleccionar utilizando sus índices:

df['colname'] [5:10]

Y no se olvide de la opción de rango en Python, primer elemento incluido, segundo excluido. Por lo tanto, el código anterior devolverá las filas con los índices 5, 6, 7, 8 y 9. Y los índices comienzan desde 0.

El corte de los cuadros de datos funciona de la misma manera. Con un solo matiz. Cuando se utiliza .loc (etiquetas) se incluyen ambos bordes.

Por ejemplo, seleccione filas de la etiqueta ‘row1’ para etiquetar ‘row4’ o del índice de fila 1 al índice 4 y todas las columnas:

df.loc['row1':'row4', :]
df.iloc[1:4, :]

La primera línea de código seleccionará row1, row2, row3 y row4. Mientras que la segunda row1, row2 y row3 solamente.

Seleccione las columnas de la etiqueta ‘col1’ para etiquetar ‘col4’ o de la columna índice 1 al índice 4 y todas las filas:

df.loc['col1':'col4', :]
df.iloc[1:4, :]

Seleccione las filas de la etiqueta ‘row1’ para etiquetar ‘row4’ o de la fila índice 1 al índice 4 y las columnas de la etiqueta ‘col1’ a la etiqueta ‘col4’ o de la columna índice 1 al índice 4:

df.loc['row1':'row4', 'col1':'col4']
df.iloc[1:4,1:4]

Para seleccionar columnas o filas específicas que no están dentro de un rango, use una lista:

df.loc['row2':'row5', ['col1','col3']]
df.iloc[[2,5]1: 3]

Filtrado de marcos de datos

El filtrado es una herramienta más general para seleccionar partes de los datos en función de las propiedades de interés de los datos en sí y no en los índices o etiquetas.

Los DataFrames tienen varios métodos para filtrar. La idea subyacente de todos estos métodos es una serie booleana.

El df [‘col1’]> 20 (asumimos que col1 es de tipo entero) devolverá una serie booleana donde esta condición es verdadera.

Entonces, para seleccionar parte de un python dataframe donde los valores de col1 son mayores que 20 usaremos el siguiente código:

df[df['col1']> 20]
# asignar variable también funciona
  condition = df['col1']> 20
  df[condition]

Podemos combinar esos filtros utilizando operadores lógicos estándar (y – &, o – |, no -!). Observe el uso de paréntesis para estas operaciones.

df [(df['col1']> 25) & (df ['col2'] <30)] # lógica y
df [(df['col1']> 25) | (df ​​['col2'] <30)] # lógica o
df [!(df['col1']> 25)] # lógica no

Casi siempre los conjuntos de datos tienen valores de cero o NaN y definitivamente queremos saber dónde están . Para seleccionar columnas que no tengan ningún valor faltante o cero, podemos usar el método .all() (todos los datos están presentes):

df.loc[:,df.all()]

Si queremos encontrar una columna que tenga al menos un valor distinto de cero (cualquiera), esto ayudará:

df.loc[:,df.any()]

Para seleccionar columnas con cualquier NaN:

df.loc[:,df.isnull().any()]

Selecciona columnas sin NaNs:

df.loc[:,df.notnull().all()]

Podemos eliminar esas filas que contienen NaNs, pero es un juego peligroso.

Dejarlo por lo general no es una solución:

df.dropna (how='any') # si alguno en una fila es NaN, se eliminará
df.dropna (how='all') # si todos los valores en una fila son NaN, se eliminará

La belleza del filtrado es que en realidad podemos seleccionar o modificar los valores de una columna en función de otra. Por ejemplo, podemos seleccionar valores de col1 donde col2 es mayor que 35 y actualizar esos valores agregando 5 a cada uno:

# Buscar una columna basada en otra 
  df ['col1'] [df['col2'] > 35]
# Modificar una columna basada en otra 
  df ['col1'] [df['col2']> 35] + = 5

Y esto nos lleva a la siguiente parte:

Transformando los marcos de datos

Una vez que seleccionamos o filtramos nuestros datos queremos transformarlos de alguna manera. La mejor manera de hacerlo es con métodos heredados a python dataframe o funciones universales numpy, que transforman toda la columna de datos en forma de elementos.

Los ejemplos serían pandas ‘ .floordiv() (de la documentación:’ División entera del marco de datos y otro, en lo que respecta a elementos ‘) o numpy’s .floor_divide() (doc:’ Return the mayor entero menor o igual a la división de las entradas. ‘).

Si esas funciones no estuvieran disponibles, podríamos escribir el nuestro y usarlo con el método .apply().

def some_func (x):
    return x * 2
    df.apply(some_func) - # actualiza cada entrada de un DataFrame sin ningún bucle
  # lambda también funciona
    df.apply(lambda n: n*2) - # lo mismo..

Estas funciones no devuelven transformaciones, por lo que debemos almacenarlas explícitamente:

df['new_col'] = df.apply(lambda n: n*2)

Si el índice es una cadena, tiene un acceso .str que nos permite modificar todo el índice a la vez:

df.index.str.upper()

Además, no podemos usar .apply() método en el índice: la alternativa es .map()

df.index = df.index.map(str.lower)

Pero .map() también se puede usar en columnas. Por ejemplo:

# Crear el diccionario red_vs_blue
  red_vs_blue = {'val1':'blue', 'val2':'red'}
# Usa el diccionario para asignar el 'col1' columna a la nueva columna df ['color']
  df ['color'] = df['col1'].map(red_vs_blue)

Las operaciones aritméticas en Series y DataFrames funcionan directamente. La siguiente expresión creará una nueva columna donde cada valor con índice n es una suma de valores con índice n de ‘col3’ y ‘col7 ‘.

df['col1'] = df['col3'] + df['col7']

Aquí haremos una pausa. Una vez que hayamos comprendido los conceptos básicos del trabajo con Python DataFrames, profundizaremos en técnicas de indexación más avanzadas en la siguiente parte.

Mientras tanto, adore la ciencia de datos y sonría más. Debemos ser positivos, ya que tenemos el mejor trabajo del siglo XXI 😀