Módulo 8

Pandas (Panel DataS)

Bibliografía
https://pandas.pydata.org/docs/getting_started/tutorials.html#communitytutorials
https://pandas.pydata.org/Pandas_Cheat_Sheet.pdf
https://pandas.pydata.org/docs/user_guide/10min.html#min

Estructuras Pandas
 Series
 DataFrames
 Estructuras tabulares
Construcción

Series Métodos mas comunes

de Creación pd.Series(data)
de pedidos de información - datos básicos
de Acceso y Selección:
de Manipulación de Datos
de estadísticas y Resumen
de Filtrado y Selección de Datos
de Manipulación de Fechas y Tiempos
DataFrames Métodos mas comunes
de Creación pd.DataFrames(data)
de InOut pd.read_ Ingreso desde archivos externos o mediante Apis (sql)
de InOut pd.to_ Salida a archivos externos o mediante Apis (sql) desde programas esternos
de datos básicos pedidos de información
de datos básicos pedidos de información de Acceso y Selección
de Acceso y Selección
Creación de DataFrames sin etiquetas
Acceso directo
.iloc[ index_fila(s) , index_columnas(s) ]
.iloc listas de index – slicing de index
Creación de DataFrames con etiquetas
Acceso directo
.loc[ etiqueta_fila(s) , etiqueta_columnas(s) ]
.loc listas de etiquetas – slicing de etiquetas
columnas
filtrado
filtrado booleano
de Filtrado y Selección de Datos
filtrado por una columna e inverso
orperadores
Comparación de igualdad. ==
Comparación de desigualdad. !=
Comparaciones de menor / mayor (+ igual) que. <, <=, >, >=
Comprobación de pertenencia a un conjunto isin que recibe una colección de elementos y comprueba si
el valor de la columna se encuentra dentro de ellos.
Negar para realizar la comprobación opuesta ~
and &
or |

de Filtrado y Selección de Datos

filtrado por una columna e inverso
Operadores lógicos & (and / y) , | (or / o) , ~ (not / no)
filtrado por varias columnas e inversos
df[nombre_columna] df.nombre_columna.
Axis
Filter
Like
Isin
Query
select_dtypes
de estadísticas y Resumen
df.min()
df.max()
df.mean()
df.idxmin()
df.idxmax()
df.median()
df.std()
df.count()
df.reindex
df.describe()
df.sum()
df.corr(other)
de Manipulación de Fechas y Tiempos
df.dt.year df.dt.month
df.dt.day
df.dt.strftime(format)
pd.to_datetime(df)
de Manipulación de Datos
df.apply(func)
df.map(dict_or_func)
df.fillna(value)
df.dropna()
df.drop(index)
df.T
Apply
Map
Fillna
Dropna
Drop()
dt.t o dt.transpose().
df.sort_values(by='columna')
concat
Pandas
Pandas (PANel DAtaS) es una biblioteca de Python ampliamente utilizada para el procesamiento de
datos tabulares, datos que están organizados en una estructura de tabla bidimensional.
La utilidad se muestra en las áreas análisis y ciencia de datos debido a su capacidad para trabajar con
datos tabulares de manera eficiente.

Principales estructuras Pandas para trabajar con datos tabulares:

Estructuras Pandas Descripción
Series Son estructuras de datos unidimensional similar a la columna de una tabla. Son
similares a las listas o arrays de NumPy, pero tienen etiquetas y permiten realizar
operaciones de datos complejas y a gran velocidad .
También pueden ser representaciones una sola columna o fila de datos en un
DataFrame.
DataFrame Son las estructura de datos más comunes para almacenar datos tabulares.
Se organizan en filas y columnas donde cada columna puede tener un solo tipo de
datos.
Permite realizar operaciones de filtrado, selección, agregación y transformación
de datos.
Nota: las estructuras Paneles en un principio para datos en 3D en Pandas ha sido marcada como obsoleta
("deprecated") reemplazado por DataFrames anidados.

Los datos tabulares están estructurados de la siguiente manera:

Estructuras tabulares Descripción
Filas y Columnas Los datos tabulares consisten en filas y columnas. Cada fila representa una
observación o un registro, mientras que cada columna representa una variable o
un atributo.
Encabezados de Columna La primera fila o encabezado suele contener los nombres de las columnas, que
describen su contenido o significado.
Datos Homogéneos Todos los datos dentro de una columna son del mismo tipo de datos.
Acceso por Etiqueta Se accede a los datos en una tabla utilizando índices numéricos o etiquetas de
columna y fila. Estas facilitas la manipulación y el análisis de datos, ya que el
texto de una etiqueta suele tener un significado semántico.
·
La ciencia de datos toma estos suele dividirse en etapas. Iniciando la toma de datos, luego la etapas de Extracción,
el Procesado, la Limpieza, y el EDA (Análisis Exploratorio de datos o como se conoce en inglés: Exploratory
Data Franlysis), luego podemos agregar una etapa de Machine Learning e Implantación.

Organización del módulo:

 ingreso de datos a series y dataframes
Trabajaremos con miles o millones de estos
información básica de series y DataFrames
Series de Pandas:
Métodos mas Serie: Ndarray unidimensional con etiquetas de eje (incluidas series de tiempo).
comunes
de Creación: Crea una nueva Serie a partir de una secuencia de datos (listas, matrices, NumPy, diccionarios,
pd.Series(data) etc.).o como porción de un DataFrane
de pedidos de mi_serie.head(n) Devuelve los primeros n elementos de la Serie. Default 5
información mi_serie.tail(n) Devuelve los últimos n elementos de la Serie. Default 5
- datos básicos mi_serie.describe() Devuelve la información básica de cada column, da un resumen
rápido por Series con el conteo, la media, desviación típica, valor
mínimo, valor máximo y percentiles 25%, 50% y 75%.
mi_serie.shape Devuelve el numero de líneas.
mi_serie.info() Devuelve las características básicas, número de columnas, cuáles
son, cuántos registros no nulos tienen cada una y el tipo
mi_serie.values Devuelve la serie como ndarray o ndarray-like según el tipo d.
mi_serie.dtype Devuelve el objeto dtype de los datos subyacentes.
mi_serie.nbytes Devuelve el número de bytes de los datos subyacentes.
mi_serie.ndim Devuelve el número de dimensiones de los datos subyacentes,
por definición 1.
Devuelve el número de elementos de los datos subyacentes.
mi_serie.size
Devuelve los valores únicos en la Serie.
mi_serie.unique()
Devuelve un conteo de ocurrencias de cada valor único.
mi_serie.value_counts()
Devuelve una Serie booleana que indica valores nulos.
mi_serie.isnull()
Devuelve el uso de memoria de la serie.
mi_serie.memory_usage
([index deep])
Devuelve el si tengo nans; permite acelerar de rendimiento
mi_serie.hasnans
Devuelve el de si la serie está vacía.
mi_serie.empty
Devuelve el nombre de la serie.
mi_serie.name
de Acceso y mi_serie[index] Permite acceder a un elemento específico de la Serie por su
Selección: índice.
mi_serie.iloc[index] Permite acceder a un elemento por su posición entera.
mi_serie.loc[label] Permite acceder a un elemento por su etiqueta de índice.
de mi_serie.apply(func) Aplica una función a cada elemento de la Serie.
Manipulación mi_serie.map(dict_or_func) Mapea valores a nuevos valores según un diccionario o función.
de Datos mi_serie.fillna(value) Rellena los valores nulos con el valor especificado.
mi_serie.drop(index) Elimina un elemento por índice o etiqueta.
mi_serie.T Crea la transposición de la serie
de estadísticas mi_serie.min() Permite obtener el elemento mas pequeño de la serie
y Resumen mi_serie.max() Permite obtener el elemento mas grande de la serie
mi_serie.mean() Permite obtener la media de los elemento de la serie
mi_serie.idxmin() Permite ubicar el índice del valor mínimo.
mi_serie.idxmax() Permite ubicar el índice del valor máximo.
mi_serie.median() Permite calcular la mediFran de los valores.
mi_serie.std() Permite obtener la desviación estándar de los elemento de la
serie
mi_serie.count() Permite obtener la cantidad de elemento de la serie
 mi_serie.reindex Permite cambiar el orden de las filas de forma manual
mi_serie.describe() Permite calcular estadísticas descriptivas sobre la Serie.
mi_serie.sum() Permite calcular la suma de los valores de la Serie.
mi_serie.corr(otra_serie) Calcula la correlación con otra Serie.
de Filtrado y mi_serie[bool_expression] Permite seleccionar elementos basados en una expresión
Selección de booleana.
Datos mi_serie.between(start, end) Devuelve los elementos que están dentro del rango especificado.
mi_serie.nlargest(n) Devuelve los n elementos más grandes.
mi_serie.nsmallest(n) Devuelve los n elementos más pequeños.
de (obviamente la Serie debe contener fechas o tiempos)
Manipulación mi_serie.dt.year Devuelve el año de la fecha.
de Fechas y mi_serie.dt.month Devuelve el mes de la fecha.
Tiempos mi_serie.dt.day Devuelve el día de la fecha.
mi_serie.dt.strftime(format) Convierte fechas en cadenas de texto con formato.
pd.to_datetime(mi_serie) Convierte una Serie en un objeto DateTime.
·
·Código Python
import pandas as pd
lista =[1,2,3,4,5,6,7,8,9] lista_anidada =[[1,2,3],[4,5,6],[7,8,9]]
s = pd.Series(lista) s2 = pd.Series(lista_anidada)
print (f"s=\n{s}") print (f"s2=\n{s2}")
·Salida esperada por consola
#lista =[1,2,3,4,5,6,7,8,9] #lista_anidada =[[1,2,3],
[4,5,6],[7,8,9]]
s=
0 1 s2=
1 2 0 [1, 2, 3]
2 3 1 [4, 5, 6]
3 4 2 [7, 8, 9]
4 5 dtype: object
5 6
6 7
7 8
8 9
dtype: int64
·
·
DataFrames de Pandas:
Métodos mas DatoFames: Ndarray bidimensionales con etiquetas en ejes (incluidas DataFrames de tiempo).
comunes Mas dimensiones se absorben como dataframes anidados
El DataFrame es una estructura de datos tabular que se compone de columnas y filas ordenadas,
de tamaño mutable y potencialmente heterogéneos.
de Creación: pd.DataFrame(objeto_fuente_de_datos)
pd.DataFrames
(data) Crea un nuevo DataFrame a partir de una secuencia de datos (listas, matrices,, diccionarios,
etc.).o como porción de un DataFrane
Parámetros:
data: conjunto de datos crear el DataFrame.
 Un NumPy ndarray (estructurado u homogéneo).
 Un iterable como una lista o tupla que contenga listas, tuplas u otros iterables.
 Un diccionario, donde las claves son los nombres de las columnas y los valores son las
series, matrices, constantes u objetos en forma de lista que constituyen las columnas del
DataFrame.
 Otro DataFrame.
index:
Este parámetro define el índice o etiquetas de fila que se utilizarán para el DataFrame.
Sin datos Pandas utilizará el valor predeterminado un RangeIndex (0, 1, 2, ..., cantidad
de filas ).
columns:
Aquí se especifican las etiquetas de columna que se utilizarán para el DataFrame.
Sin datos Pandas utilizará el valor predeterminado, que es un RangeIndex (0, 1, 2, ...,
cantidad de columnas ). En un diccionario se toman las claves
dtype:
Este parámetro permite forzar el tipo de dato para todas las columnas del DataFrame.
Sin datos establece en None y Pandas intentará inferir automáticamente los tipos de
datos de las columnas basándose en los datos de entrada como cualquier objeto Python
donde el interprete chequea el tipo de dato a asignar.
copy:
Este es un booleano que determina si se deben generar Alias o copiar los datos de
entrada al crear el DataFrame. Esto se debe tener muy en cuenta cuando se utiliza un
ndarray-Numpy u otro DataFrame como entrada. Si copy es True, se crea una copia
independiente de los datos. Si es False, los datos seran un alias, se compartirán entre el
DataFrame y los datos de entrada.
·
DataFrames de Pandas:
Métodos DatoFames
de IO
pd.read_ pd.read_csv(arch) Lee datos desde un archivo CSV (Comma-Separated Values).
pd.read_excel(arch) Lee datos desde un archivo Excel (.xls o .xlsx).
Ingreso desde pd.read_json(arch) Lee datos desde un archivo JSON (JavaScript Object Notation).
pd.read_html(url) Lee tablas HTML de una página web y crea un DataFrame. Requiere
archivos
la librería adicional html5lib.
externos o Lee datos desde una base de datos SQL usando una consulta SQL.
pd.read_sql(sql_query,
mediante Apis database_connection)
(sql) desde pd.read_clipboard() Lee datos desde el portapapeles del sistema, lo que puede ser útil
programas cuando tienes datos copiados desde una fuente externa.
(severs) pd.read_fwf(arch) Lee datos desde un archivo de ancho fijo (Fixed Width Format).
esternos pd.read_hdf(arch) Lee datos desde un archivo HDF5 (Hierarchical Data Format V 5).
pd.read_msgpack(arch) Lee datos desde un archivo binario en formato MessagePack.
pd.read_parquet(arch) Lee datos desde un archivo en formato Parquet (formato de
almacenamiento de columnas).
pd.to_ pd.to_csv(arch) Guardar un DataFrame en un archivo CSV.
pd.to_excel(arch) Guardar un DataFrame en un archivo de Excel (xls o xlsx).
Salida a pd.to_json(arch) Guardar un DataFrame en un objeto JSON.
archivos pd.to_html(url) No hay una función salida para en formato URL.
externos o
mediante Apis pd.to_sql(tabla, Guardar DataFrame en una base de datos, A partir de una conección
(sql) desde con=engine, via Api.
programas schema=None, schema (opcional): Especifica el esquema en la base de datos donde
(severs) if_exists='fail', se guardará la tabla.
esternos index=True, if_exists (opcional): Determina qué hacer si la tabla ya existe en la
index_label=None, base de datos.
chunksize=None, fail (predeterminado): Genera un error si la tabla ya existe.
dtype=None) replace: Reemplaza la tabla existente con los datos del df.
append: Agrega los datos del df a la tabla existente.
index (opcional): Controla si se debe incluir el índice del df
como una columna en la tabla de la base de datos. True
default.
index_label (opcional): especifica un nombre personalizado
para la columna de índice si se incluye en la tabla.
chunksize (opcional): Define el número de filas que se
insertarán en la base de datos a la vez.
dtype (opcional): Permite especificar el tipo de datos que se
utilizará en la base de datos para cada columna. Puede ser un
diccionario que mapee nombres de columna a tipos de datos
SQL.
pd.to_clipboard() No hay una función salida para el portapapeles.

pd.to_fwf(arch) No hay una función salida para en formato URL.

pd.to_hdf(arch) Guardar un df en un objeto HDF. (arch, key, mode='a', kwargs)

pd.to_msgpack(arch) Guardar un df en un archivo MSGPACK.
pd.to_parquet(arch) Guardar un df en un archivo PARQUET.
·
DataFrames de Pandas:
Métodos DatoFames
de datos df.head(n) Devuelve los primeros n elementos del df. Default 5
básicos df.tail(n) Devuelve los últimos n elementos del df. Default 5
pedidos de df.describe() Devuelve información estadística básica de estos datos, da un
información resumen rápido por DataFrames con el conteo, la media, desviación
típica, valor mínimo, valor máximo y percentiles 25%, 50% y 75%.
df.shape Devuelve el numero de líneas y columnas
df.info() Devuelve las características básicas, número de columnas, cuáles son,
cuántos registros no nulos tienen cada una y el tipo
df.values Devuelve la DataFrame como ndarray o ndarray-like según el tipo d.
df.dtypes Devuelve el objeto dtypes de los datos subyacentes.Noten la S final
df.memory_usage() Devuelve el número de bytes de los datos subyacentes.(nbytes)
df.ndim Devuelve el número de dimensiones de los datos subyacentes,
df.size Devuelve el número de elementos de los datos subyacentes.
df.nunique() Devuelve los valores únicos en la DataFrame.Noten la N inicial.
df.value_counts() Devuelve un conteo de ocurrencias de cada valor único.
Saber si hay “nans” permite acelerar de rendimiento
df.isnull() Devuelven una booleana, True si hay valores nulos o NaN.
df.isna() df.isnull() equivale a df.isna() ( hasnans) en existe en df

df.notnull() Devuelve una booleana,,True si no hay nulos o NaN.

df.notna() df.notnull () equivale a df.notna () complementas a .isnull() e.isna()

df.empty Devuelve el de si la DataFrame está vacía.

.any() any()) verifica si en la salida booleana alguno es True
.all() all()) verifica si en la salida booleana todos son True
Puedes usar estos métodos en combinación con isna() o notna() para
df.isna().any().any() verificar si hay algún NaN / Null en todo el DataFrame.
df.notna().all().all() para verificar si todo el df no tiene NaN / Null
de Acceso y df.index Permite acceder a una lista de los índices o etiquetas.
Selección df.columns Permite acceder a una lista de las columnas o etiquetas. df.name
df[nombre_1_col] Permite acceder a la columnas por etiqueta.
df[['col_2','col_1']] Permite acceder a las columnas por etiquetas.
df.loc[:,nombre_1_col] Permite acceder a todas las filas por la etiqueta de la columna.
df.iloc[:,index_1_col] Permite acceder a todas las filas por la índices de la columna.
df.loc[nom_f,nom_c] Permite acceder a un elemento por etiqueta de fila y columna.
df.iloc[index_f,index_c] Permite acceder a un elemento por índices de fila y columna.

El acceso y la selección de datos en Pandas son procesos fundamentales para trabajar con DataFrames y Series,
( las estructuras de datos principales en análisis de datos ademas de las bases de datos)

Pandas ofrece diversas formas de acceder y seleccionar datos, lo que permite realizar tareas como filtrar filas
(registros), seleccionar columnas (campos) específicas y realizar operaciones de indexación avanzadas.
Un DataFrame tiene dos índices dobles, un par para las filas o registros (uno numérico y uno de etiquetas) y otro
para las columnas o campos (uno numérico y uno de etiquetas). Los índices alfanuméricos o etiquetas pueden o
no estar presentes, los numéricos siempre estan.

·
Crear un df de 4 filas y 10 columnas sin etiquetas
·Código Python
import pandas as pd
# creamos un DataFrame
lista_a = [ [10,9,8,7,6,5,4,3,2,1,0],
[100,109,118,207,96,350,240,3,200,250,300],
[210,211,212,213,214,215,216,217,218,219,220],
["Ariel","Betty","Caro","Dany","Ester","Fran","Gaby","Hector","Ines","Julia",
"Kary"] ]

df = pd.DataFrame(lista_a)
print (f"{df}")
·Salida esperada por consola
0 1 2 3 4 5 6 7 8 9 10 < -indice de
campo o columna
0 10 9 8 7 6 5 4 3 2 1 0
1 100 109 118 207 96 350 240 3 200 250 300
2 210 211 212 213 214 215 216 217 218 219 220
3 Ariel Betty Caro Dany Ester Fran Gaby Hector Ines Julia Kary
^
- indice de registro o fila

·
Acceder y seleccionar datos por posición mediante el indice numérico
Acceso directo
Código Python
# Seleccionar la columna index 1
columna = 1
print (f"df[columna]=\n{df[columna]}")
Salida esperada por consola
df[columna]=
0 9
1 109
2 211
3 Betty
^
- indice de registro o fila
Código Python
# Seleccionar las columnas index 1 y 3
print (f"df[[1:3]]=\n{df[[1,3]]}")
Salida esperada por consola
df[[1:3]]=
1 3< -indice de campo o columna
0 9 7
1 109 207
2 211 213
3 Betty Dany
 ^
- indice de registro o fila
Código Python
# Seleccionar las filas de la 1 a la 2 (excluyendo la 3)
print (f"df[1:3]=\n{df[1:3]}")
Salida esperada por consola
df[1:3]=
0 1 2 3 4 5 6 7 8 9 10< -indice de campo/columna
1 100 109 118 207 96 350 240 3 200 250 300
2 210 211 212 213 214 215 216 217 218 219 220
^
- indice de registro o fila
·
·
El acceso y la selección de datos en Pandas son una parte fundamental del análisis de datos.
Los métodos loc e iloc proporcionan una forma sencilla de acceder a los datos de un DataFrame por su índice o
posición.
·
.iloc

Acceder y seleccionar datos por posición mediante el indice numérico, utilizado el método iloc.
sintaxis .iloc[]
dataframe.iloc[filas, columnas],
Donde filas y columnas pueden ser indices individuales, listas de indices o slicing.
·
.iloc[ fila(s) , columnas(s) ]
Código Python
# Selección de una columna por posición
columna_0 = df.iloc[:, 0]
print (f"columna_0=\n{columna_0}")
·Salida esperada por consola
columna_0=
0 10
1 100
2 210
3 Ariel
Name: 0, dtype: object
Código Python
# Selección de una fila por posición
fila_3 = df.iloc[3, :]# fila_3 = df.iloc[3]
print (f"fila_3=\n{fila_3}")
·Salida esperada por consola
fila_1=
0 Ariel
1 Betty
2 Caro
3 Dany
4 Ester
5 Fran
 6 Gaby
7 Hector
8 Ines
9 Julia
10 Kary
Name: 3, dtype: object

·
.iloc[ listas – slicing ]
Código Python
# Selección de una celda por posición
fila_3_columna_1 = df.iloc[3,1]
print (f"fila_3_columna_1 ={fila_3_columna_1}")
·Salida esperada por consola
columna_1_fila_3=Betty
Código Python
# Selección de una celda por posición lista
fila_1_3_columna_1_3_5_7 = df.iloc[[1,3],[1,3,5,7]]
print (f"fila_1_3_columna_1_3_5_7=\n{fila_1_3_columna_1_3_5_7}")
·Salida esperada por consola
fila_1_3_columna_1_3_5_7=
1 3 5 7
1 109 207 350 3
3 Betty Dany Fran Hector
Código Python
# Selección de una celda por posición slicing
fila_2a4_columna_1a8_x2 = df.iloc[2:4,1:8:2]
print (f"fila_2a4_columna_1a8_x2=\n{fila_2a4_columna_1a8_x2}")
·Salida esperada por consola
fila_2a4_columna_1a8_x2=
1 3 5 7
2 211 213 215 217
3 Betty Dany Fran Hector
·
·
Código Python
salida = df[df.columns[-2:]]# slicing anteultimo al final
print(f"salida=\n{salida}")
Opción Código Python
salida = df.iloc[ : ,[2,3]]
print(f"salida=\n{salida}")
Salida esperada por consola
salida= sueldo nombre
0 210 Ariel
1 211 Betty
2 212 Caro
3 213 Dany
 4 214 Ester
5 215 Fran
6 216 Gaby
7 217 Hector
8 218 Ines
9 219 Julia
10 220 Kary
·
·
·
salida = df.iloc[1] # Todos los dato de la filas 1 y todas las columnas
salida = df.iloc[[0,1,2],:] # Todos los dato de todas las filas 0,1 y 2 / columnas 2 y 4
salida = df.iloc[:, [2, 4]] # Todos los dato de todas las filas / columnas 2 y 4
salida = df.iloc[[1,3], [2, 4]] #Todos los dato de las filas 1 al 3 / columnas 2 y 4
salida = df.iloc[0] # Todos los datos de la primera fila
salida = df.iloc[1] # Todos los datos de la segunda fila
salida = df.iloc[-1] # Todos los datos de la ultima fila
salida = df.iloc[:,0] # Todos los datos de la primera columna
salida = df.iloc[:,-1] # Todos los datos de la ultima columna

Crear un df de 4 filas y 10 columnas con etiquetas

·Código Python
import pandas as pd
# creamos un DataFrame
lista_a = [ [10,9,8,7,6,5,4,3,2,1,0],
[100,109,118,207,96,350,240,3,200,250,300],
[210,211,212,213,214,215,216,217,218,219,220],
["Ariel","Betty","Caro","Dany","Ester","Fran","Gaby","Hector","Ines","Julia",
"Kary"] ]
df.index=["ingreso","locker","sueldo","nombre"]
df.columns=["A","B","C","D","E","F","G","H","I","J","K"]
df = pd.DataFrame(lista_a)
print (f"{df}")
·Salida esperada por consola
A B C D E F G H I J K < - indice de
campo o columna
ingreso 10 9 8 7 6 5 4 3 2 1 0
locker 100 109 118 207 96 350 240 3 200 250 300
sueldo 210 211 212 213 214 215 216 217 218 219 220
nombre Ariel Betty Caro Dany Ester Fran Gaby Hector Ines Julia Kary
^
- etiqueta de registro o fila

·
·
Acceso
Acceso directo
Código Python
print (f"df['B']=\n{df['B']}")
Salida esperada por consola
df['B']=
ingreso 9
locker 109
sueldo 211
nombre Betty
^
- etiqueta de registro o fila
Name: B, dtype: object
Código Python
print (f"df['locker':'sueldo']\n{df['locker':'sueldo']}")
Salida esperada por consola
df['locker':'sueldo']
A B C D E F G H I J K< - etiqueta de campo
o columna
locker 100 109 118 207 96 350 240 3 200 250 300
sueldo 210 211 212 213 214 215 216 217 218 219 220
^
- etiqueta de registro o fila
·
·

.loc

Acceder y seleccionar datos por posición mediante el etiqueta alfanumérica, utilizado el método loc.
sintaxis loc[]
dataframe.loc[etiqueta de filas, etiqueta de columnas]
dataframe.loc[ : , etiqueta de columnas]
dataframe.loc[ : , [col1,col2,col3,col4]]
Donde filas y columnas pueden ser etiquetas individuales, listas de etiquetas o slicing.
Es principalmente util para obtener informacion de arrays booleano donde nos devolverá solo aquellas
filas en las que el array tiene el valor True.
·
loc[ fila(s) , columnas(s) ]
Código Python
# Selección de una columna por etiqueta
columna_B = df.loc[:, 'B']
print (f"columna_B=\n{columna_B}")
·Salida esperada por consola
columna_B=
ingreso 9
locker 109
sueldo 211
nombre Betty
Name: B, dtype: object
Código Python
# Selección de una fila por etiqueta
fila_nombre = df.loc['nombre', :]# fila_nombre = df.loc['nombre']
print (f"fila_nombre=\n{fila_nombre}")
·Salida esperada por consola
fila_nombre=
A Ariel
B Betty
C Caro
D Dany
E Ester
F Fran
G Gaby
H Hector
I Ines
J Julia
K Kary
Name: nombre, dtype: object
·
loc[ listas – slicing ]
Código Python
# Selección de una celda por etiqueta
fila_nombre_columna_B = df.loc['nombre','B']
print (f"fila_nombre_columna_B={fila_nombre_columna_B}")
·Salida esperada por consola
fila_nombre_columna_B=Betty
Código Python
# Selección de una celda por etiqueta lista
fila_locker_nombre_columna_B_D_F_H = df.loc[['locker','nombre'],['B','D','F','H']]
print (f"fila_locker_nombre_columna_B_D_F_H=\n
{fila_locker_nombre_columna_B_D_F_H}")
·Salida esperada por consola
fila_locker_nombre_columna_B_D_F_H=
B D F H< -etiqueta de campo o columna
locker 109 207 350 3
nombre Betty Dany Fran Hector
^
- etiqueta de registro o fila
Código Python
# Selección de una celda por etiqueta slicing
fila_2a4_columna_1a8_x2 = df.loc[2:4,1:8:2]
print (f"fila_2a4_columna_1a8_x2=\n{fila_2a4_columna_1a8_x2}")
·Salida esperada por consola
fila_lockerAnombre_columna_BaH_x2=
B D F H< -etiqueta de campo o columna
locker 109 207 350 3
sueldo 211 213 215 217
nombre Betty Dany Fran Hector
^
- etiqueta de registro o fila
 ·
·
columnas
Código Python
# reformulamos el df
#
# df=df.T
#
datos = {
"ingreso":[10,9,8,7,6,5,4,3,2,1,0],
"locker" :[100,109,118,207,96,350,240,301,200,250,300],
"sueldo" :[210,211,212,213,214,215,216,217,218,219,220],
"nombre" :
["Ariel","Betty","Caro","Dany","Ester","Fran","Gaby","Hector","Ines","Julia", "Kary"]
}
df = pd.DataFrame(datos)
Salida esperada por consola
df= ingreso locker sueldo nombre
0 10 100 210 Ariel
1 9 109 211 Betty
2 8 118 212 Caro
3 7 207 213 Dany
4 6 96 214 Ester
5 5 350 215 Fran
6 4 240 216 Gaby
7 3 301 217 Hector
8 2 200 218 Ines
9 1 250 219 Julia
10 0 300 220 Kary
·
·
Código Python
salida = df.loc[ : ,['sueldo','nombre']]
print(f"salida=\n{salida}")
Código Python
salida =df[['sueldo','nombre']]
print(f"salida=\n{salida}")
Salida esperada por consola
salida= sueldo nombre
0 210 Ariel
1 211 Betty
2 212 Caro
3 213 Dany
4 214 Ester
5 215 Fran
6 216 Gaby
7 217 Hector
 8 218 Ines
9 219 Julia
10 220 Kary
·
·

Malditos NA (NaN)
Para deshacerme de los NaN que no me permiten calcular tengo algunas opciones
Borra la fila
Rellenarla con un dato propio
Rellenarla con un dato del DataFrame
df_reparado =df_con_Nan.dropna() # borrolas filas que tienen algun NaN
df_reparado =df_con_Nan.fillna(o) # lleno los NaN con 0
df_reparado =df_con_Nan.fillna({“col1”=0,”col2”=”vacio”) # lleno los NaN de la col1 con 0 y los col2 con
“vacio”
Filtrado
Filtrado booleano
df.loc[df[columna]==valor]
df[df[columna]==valor]#omito loc porque es una sera booleana
df[df.columna==valor]#nombre python de columna
El filtrado booleano permita seleccionar y filtrar datos siendo ampliamente utilizada en análisis y manipulación de
datos
Filtrado de Filas:
Se utiliza para seleccionar filas que cumplan una condición específica.
# Filtrado de filas donde 'A' es mayor que 1
filas_filtradas = df[df['A'] > 1]
·
Selección de Columnas:
Se utiliza para seleccionar columnas específicas por nombre.
# Selección de columnas 'A' y 'B'
columnas_seleccionadas = df[['A', 'B']]
·
inplace:
Booleano que indica si deseas realizar la eliminación en el lugar (modificar el DataFrame original) o si
deseas devolver un nuevo DataFrame con las filas o columnas eliminadas. Por defecto, es False.
·
Métodos DatoFames
de Filtrado y df[bool_expression] Permite seleccionar elementos basados en una expresión booleana.
Selección de df.between(start, end) Devuelve los elementos que están dentro del rango especificado.
Datos df.nlargest(n) Devuelve los n elementos más grandes.
df.nsmallest(n) Devuelve los n elementos más pequeños.
df.loc [ df[nombre_1_col] > Filtra filas basadas en una condición.\n
valor]
·
Código Python
import pandas as pd
dict_ = {
'uno' : [1,2,3,4,1,2,3,4],
'dos' : [4,3,2,1,0,9,8,7],
'tres': [5,6,7,8,9,10,11,12]
}
df = pd.DataFrame(data=dict_, index=['a', 'b', 'c' , 'd' , 'e' , 'f' , 'g' , 'h'])
print("\nindice dict_ indice alfa:\n",df)
Salida esperada por consola

uno dos tres < -indice de campo o columna

a 1 4 5
b 2 3 6
c 3 2 7
 d 4 1 8
e 1 0 9
f 2 9 10
g 3 8 11
h 4 7 12
^ - indice de registro o fila
·
·
Código Python
filas_filtradas = df.loc[:,'uno':'tres'] >2
print("filas_filtradas=\n",filas_filtradas)
Salida esperada por consola
filas_filtradas=
uno dos tres < -indice de campo o columna
a False True True
b False True True
c True False True
d True False True
e False False True
f False True True
g True True True
h True True True
^ - indice de registro o fila
Código Python
salida = df[filas_filtradas]
print("salida = \n",salida)
Salida esperada por consola
salida =
uno dos tres < -indice de campo o columna
a NaN 4.0 5
b NaN 3.0 6
c 3.0 NaN 7
d 4.0 NaN 8
e NaN NaN 9
f NaN 9.0 10
g 3.0 8.0 11
h 4.0 7.0 12
·
·
a 1 4 5 df
>2
a False True True df[]>2
_____________________________
a NaN 4.0 5 df[df[]>2]
·
Código Python
import pandas as pd
 dict_ = {
'uno' : [1,2,3,4,1,2,3,4],
'dos' : [4,3,2,1,0,9,8,7],
'tres': [5,6,7,8,9,10,11,12]
}
df = pd.DataFrame(data=dict_, index=['a', 'b', 'c' , 'd' , 'e' , 'f' , 'g' , 'h'])
print("df:\n",df)
df=df.loc[df['uno'] > 2]
print("df:\n",df)
Salida esperada por consola
df:uno dostres < -indice de campo o columna
a 1 4 5
b 2 3 6
c 3 2 7
d 4 1 8
e 1 0 9
f 2 9 10
g 3 8 11
h 4 7 12
df = df.loc [df ['uno'] > 2]
df = df.loc [df ['uno'] > 2, ['uno', 'dos', 'tres']]
df = df.loc[:,['uno', 'dos','tres']][df > 2]
df: uno dos tres
c 3 2 7
d 4 1 8
g 3 8 11
h 4 7 12
^ - indice de registro o fila

·
·
Código Python
salida = df.loc[df['locker'] %2 ==0, ['locker', 'sueldo']]
print(f"salida=\n{salida}")
Salida esperada por consola
salida= locker sueldo
0 100 210
2 118 212
4 96 214
5 350 215
6 240 216
8 200 218
9 250 219
10 300 220

·
·
filtrado por una columna e inverso
serie_serie_filtro_bool = df['columna'] condición ejemplo 'nombre'== 'Pepe' 'sueldo'=> 1000
salida = df.loc[serie_filtro_bool ]
·
Código Python
datos = {
"ingreso":[10,9,8,7,6,5,4,3,2,1,0],
"locker" :[100,109,118,207,96,350,240,301,200,250,300],
 "sueldo" :[210,211,212,213,214,215,216,217,218,219,220],
"nombre" :
["Ariel","Betty","Caro","Dany","Ester","Fran","Gaby","Hector","Ines","Julia", "Kary"]
}
df = pd.DataFrame(datos)
Código Python
""" filtrado por una columna e inverso"""
########################################################################
print ("*"*50)
print(f"df=\n{df}")
print ("*"*50)
########################################################################
""" nombre"""
serie_serie_filtro_bool = df['nombre'] == 'Ariel'
print(f"serie_filtro_bool =\n{serie_filtro_bool }")
print ("*"*50)
########################################################################
salida = df.loc[serie_filtro_bool ]
print(f"salida=\n{salida}")
print ("*"*50)
Código Python
""" en una sola linea"""
salida = df.loc[df['nombre'] == 'Ariel' ]
print(f"salida=\n{salida}")
print ("*"*50)
Salida esperada por consola
df.loc[df['nombre'] == 'Ariel'] Salida=
df= ingreso locker sueldo nombre serie_filtro_bool = ingreso locker sueldo nombre
0 10 100 210 Ariel 0 True---> 0 10 100 210 Ariel
1 9 109 211 Betty 1 False--//--
2 8 118 212 Caro 2 False--//--
3 7 207 213 Dany 3 False--//--
4 6 96 214 Ester 4 False--//--
5 5 350 215 Fran 5 False--//--
6 4 240 216 Gaby 6 False--//--
7 3 301 217 Hector 7 False--//--
8 2 200 218 Ines 8 False--//--
9 1 250 219 Julia 9 False--//--
10 0 300 220 Kary 10 False--//--
Name: nombre, dtype:
bool

·
·

print("DataFrame Maximo:--------------------------------->:",df_titanic.max(numeric_only=True))
Código Python
""" filtrado por una columna e inverso"""
########################################################################
print ("*"*50)
print(f"df=\n{df}")
print ("*"*50)
########################################################################
""" sueldo"""
serie_serie_filtro_bool = df['sueldo'] >= 215
print(f"serie_filtro_bool =\n{serie_filtro_bool }")
print ("*"*50)
########################################################################
salida = df.loc[serie_filtro_bool ]
print(f"salida=\n{salida}")
print ("*"*50)
Código Python
""" en una sola linea"""
salida = df.loc[df['sueldo'] >= 215 ]
print(f"salida=\n{salida}")
print ("*"*50)
Salida esperada por consola
df.loc[df['sueldo'] >= 215] Salida=
df= ingreso locker sueldo nombre serie_filtro_bool = ingreso locker sueldo nombre
0 10 100 210 Ariel 0 False--//--
1 9 109 211 Betty 1 False--//--
2 8 118 212 Caro 2 False--//--
3 7 207 213 Dany 3 False--//--
4 6 96 214 Ester 4 False--//--
5 5 350 215 Fran 5 True---> 5 5 350 215 Fran
6 4 240 216 Gaby 6 True---> 6 4 240 216 Gaby
7 3 301 217 Hector 7 True---> 7 3 301 217 Hector
8 2 200 218 Ines 8 True---> 8 2 200 218 Ines
9 1 250 219 Julia 9 True---> 9 1 250 219 Julia
10 0 300 220 Kary 10 True---> 10 0 300 220 Kary
Name: sueldo, dtype:
bool

·
·
Código Python
""" inversa"""
salida_inversa = df.loc[df['sueldo'] < 215] # inversa 1
print(f"salida_inversa=\n{salida_inversa}")
·
serie_serie_filtro_bool = df['sueldo'] >= 215 # reuso el filtro anterior
salida_inversa = df.loc[~(serie_filtro_bool )] # inversa 2 niego el filtro
print(f"salida_inversa=\n{salida_inversa}")
·
salida_inversa = df.loc[~(df['sueldo'] >= 215)] # inversa 3 genero un filtro y lo niego
print(f"salida_inversa=\n{salida_inversa}")
·
Salida esperada por consolade los 3 códigos
df.loc[df['sueldo'] < 215]
df.loc[~(df['sueldo'] >= 215)]
df.loc[~(serie_filtro_bool )] Salida=
df= ingreso locker sueldo nombre serie_filtro_bool = ingreso locker sueldo nombre
0 10 100 210 Ariel 0 False-//-True-> 0 10 100 210 Ariel
 1 9 109 211 Betty 1 False-//-True-> 1 9 109 211 Betty
2 8 118 212 Caro 2 False-//-True-> 2 8 118 212 Caro
3 7 207 213 Dany 3 False-//-True-> 3 7 207 213 Dany
4 6 96 214 Ester 4 False-//-True-> 4 6 96 214 Ester
5 5 350 215 Fran 5 True->False-//-
6 4 240 216 Gaby 6 True->False-//-
7 3 301 217 Hector 7 True->False-//-
8 2 200 218 Ines 8 True->False-//-
9 1 250 219 Julia 9 True->False-//-
10 0 300 220 Kary 10True->False-//-
Name: sueldo, dtype:
bool

·
·
Operadores lógicos & (and / y) , | (or / o) , ~ (not / no)
Se pueden utilizar operadores lógicos para combinar condiciones en la selección de datos.
# Filtrado de filas donde 'A' es mayor que 1 y 'B' es menor que 6
filas_filtradas = df[(df['A'] > 1) & (df['B'] < 6)]
Se permite combinar múltiples condiciones booleanas utilizando operadores lógicos como & (and) y | (or) para
realizar filtrados más complejos y selectivos.
filtrado por varias columnas e inversos
and - y
serie_serie_filtro_bool = ( df['columna'] condición ) & ( df['columna'] condición 2 )
salida = df.loc[serie_filtro_bool ]
or - o
serie_serie_filtro_bool = ( df['columna'] condición ) | ( df['columna'] condición 2 )
salida = df.loc[serie_filtro_bool ]
not - no
df.loc[ ~ (serie_filtro_bool ) ]
·
Código Python
datos = {
"ingreso":[10,9,8,7,6,5,4,3,2,1,0],
"locker" :[100,109,118,207,96,350,240,301,200,250,300],
"sueldo" :[210,211,212,213,214,215,216,217,218,219,220],
"nombre" :
["Ariel","Betty","Caro","Dany","Ester","Fran","Gaby","Hector","Ines","Julia", "Kary"]
}
df = pd.DataFrame(datos)
Código Python
serie_serie_filtro_bool = (df['sueldo'] >= 215) | (df['ingreso'] % 2 == 0)
# ^____or
print(f"serie_filtro_bool =\n{serie_filtro_bool }")
print ("*"*50)
salida = df.loc[serie_filtro_bool ]
print(f"salida=\n{salida}")
·
salida_inversa = df.loc[(df['sueldo'] >= 215) | (df['ingreso'] % 2 == 0)]
print(f"salida_inversa=\n{salida_inversa}")
·
Salida esperada por consolade los 3 códigos
 df.loc[(df['sueldo'] >= 215) |
(df['ingreso'] % 2 == 0)]
df= ingreso locker sueldo nombre serie_filtro_bool = Salida=
0 10 100 210 Ariel 0 True---> ingreso locker sueldo nombre
1 9 109 211 Betty 1 False--//-- 0 10 100 210 Ariel
2 8 118 212 Caro 2 True--->
3 7 207 213 Dany 3 False--//-- 2 8 118 212 Caro
4 6 96 214 Ester 4 True--->
5 5 350 215 Fran 5 True---> 4 6 96 214 Ester
6 4 240 216 Gaby 6 True---> 5 5 350 215 Fran
7 3 301 217 Hector 7 True---> 6 4 240 216 Gaby
8 2 200 218 Ines 8 True---> 7 3 301 217 Hector
9 1 250 219 Julia 9 True---> 8 2 200 218 Ines
10 0 300 220 Kary 10 True---> 9 1 250 219 Julia
Name: sueldo, dtype: 10 0 300 220 Kary
bool

·
·
Código Python
serie_serie_filtro_bool = (df['sueldo'] >= 215) & (df['locker'] % 2 == 0)
# ^____and
print(f"serie_filtro_bool =\n{serie_filtro_bool }")
########################################################################
print ("*"*50)
salida = df.loc[serie_filtro_bool ]
print(f"salida=\n{salida}")
Salida esperada por consolade los 3 códigos
df.loc[(df['sueldo'] >= 215) &
(df['locker'] % 2 == 0)] Salida=
df= ingreso locker sueldo nombre serie_filtro_bool = ingreso locker sueldo nombre
0 10 100 210 Ariel 0 False--//--
1 9 109 211 Betty 1 False--//--
2 8 118 212 Caro 2 False--//--
3 7 207 213 Dany 3 False--//--
4 6 96 214 Ester 4 False--//--
5 5 350 215 Fran 5 True---> 5 5 350 215 Fran
6 4 240 216 Gaby 6 True---> 6 4 240 216 Gaby
7 3 301 217 Hector 7 False--//--
8 2 200 218 Ines 8 True---> 8 2 200 218 Ines
9 1 250 219 Julia 9 True---> 9 1 250 219 Julia
10 0 300 220 Kary 10 True---> 10 0 300 220 Kary
Name: sueldo, dtype:
bool

·
·
Opción para la selección de columna de un DataFrame
df[nombre_columna]
Si el nombre de la columna ‘nombre_columna‘ es un nombre de objeto Python válido (para un identificador de
Python) y además no coincide con el nombre de las palabras reservadas index, major_axis, minor_axis, items y
tampoco coincide con el nombre de un método de la clase DataFrame, se puede acceder a dicha columna de la
siguiente manera: df.nombre_columna.
·
Axis
Puedes especificar la dirección en la que deseas aplicar un método o función, ya sea a lo largo de las filas
(axis=0) o a lo largo de las columnas (axis=1).

filter
Utilizar el método isin() para seleccionar datos que se encuentran en una lista.
·
filter
Código Python
datos = {
"ingreso":[10,9,8,7,6,5,4,3,2,1,0],
"locker" :[100,109,118,207,96,350,240,301,200,250,300],
"sueldo" :[210,211,212,213,214,215,216,217,218,219,220],
"nombre" :
["Ariel","Betty","Caro","Dany","Ester","Fran","Gaby","Hector","Ines","Julia", "Kary"]
}
df = pd.DataFrame(datos,index=['a1', 'b2', 'c3' , 'd1' , 'e2' , '3f' , 'g1' , 'h2', 'i3' , 'j1' , 'k3'])
Código Python
salida = df.filter(items=['sueldo', 'locker'])
Salida esperada por consolade los 3 códigos
df= ingreso locker sueldo nombre salida=
a1 10 100 210 Ariel sueldo locker
b2 9 109 211 Betty a1 210 100
c3 8 118 212 Caro b2 211 109
d1 7 207 213 Dany c3 212 118
e2 6 96 214 Ester d1 213 207
f3 5 350 215 Fran e2 214 96
g1 4 240 216 Gaby f3 215 350
h2 3 301 217 Hector g1 216 240
i3 2 200 218 Ines h2 217 301
h1 1 250 219 Julia i3 218 200
k2 0 300 220 Kary j1 219 250
k2 220 300

·
·
like
filter permite el uso de like similar a SQL
df.filter(like='cambio') # los nombres de las columnas deben tener la cadena específica ‘cambio’
(‘tipo de cambio’-’moneda de cambio’-’cambio de habitos’)
·
Dado un df con
columns: 2021,2022….enero_2023,febrero_2023,marzo_2023,abril_2023,…..diciembre_2023,,2024
y filas : compras_2021, ventas_2021 …... compras_2023, ventas_2023, compras_2024, ventas_2024
puedo elegir df.filter(like='2023' axis=0)
puedo elegir df.filter(like='2023' axis=1)
·
Filter like
Código Python
print ("*"*50)
salida = df.filter(like='n', axis=1) # Filtramos filas que contengan el string 'n'

Código Python
print ("*"*50)
salida = df.filter(like='2', axis=0) # Filtramos filas que contengan el string '2'
Salida esperada por consolade los 3 códigos
salida= Salida=
df= ingreso locker sueldo nombre ingreso nombre ingreso locker sueldo nombre
a1 10 100 210 Ariel a1 10 Ariel
b2 9 109 211 Betty b2 9 Betty b2 9 109 211 Betty
c3 8 118 212 Caro c3 8 Caro
d1 7 207 213 Dany d1 7 Dany
 e2 6 96 214 Ester e2 6 Ester e2 6 96 214 Ester
f3 5 350 215 Fran f3 5 Fran
g1 4 240 216 Gaby g1 4 Gaby
h2 3 301 217 Hector h2 3 Hector h2 3 301 217 Hector
i3 2 200 218 Ines i3 2 Ines
h1 1 250 219 Julia j1 1 Julia
k2 0 300 220 Kary k2 0 Kary k2 0 300 220 Kary

·
·

Isin
Utilizar el método isin() para seleccionar datos que se encuentran en una lista.
·
isin
Código Python
serie_serie_filtro_bool = df['sueldo'].isin((212, 218))
print(f"serie_filtro_bool =\n{serie_filtro_bool }")
########################################################################
print ("*"*50)
salida = df.loc[serie_filtro_bool ]
print(f"salida=\n{salida}")
Salida esperada por consolade los 3 códigos
df.loc[(df['sueldo'].isin((212, 218)))] Salida=
df= ingreso locker sueldo nombre serie_filtro_bool = ingreso locker sueldo nombre
0 10 100 210 Ariel 0 False--//--
1 9 109 211 Betty 1 False--//--
2 8 118 212 Caro 2 True---> 2 8 118 212 Caro
3 7 207 213 Dany 3 False--//--
4 6 96 214 Ester 4 False--//--
5 5 350 215 Fran 5 False--//--
6 4 240 216 Gaby 6 False--//--
7 3 301 217 Hector 7 False--//--
8 2 200 218 Ines 8 True---> 8 2 200 218 Ines
9 1 250 219 Julia 9 False--//--
10 0 300 220 Kary 10 False--//--
Name: sueldo, dtype:
bool

·
·
Código Python
serie_serie_filtro_bool = df.columns.isin(['locker', 'nombre'])
print(f"serie_filtro_bool =\n{serie_filtro_bool }")
########################################################################
print ("*"*50)
selec_cols = df.columns[serie_filtro_bool ]
print(f"selec_cols=\n{selec_cols}")
########################################################################
print ("*"*50)
salida=df[selec_cols]
print(f"salida=\n{salida}")
Salida esperada por consolade los 3 códigos
df.columns.isin(['locker', 'nombre']) serie_filtro_bool = Salida=
df= ingreso locker sueldo nombre [False True False True] locker nombre
0 10 100 210 Ariel ^ ^--> 0 100 Ariel
1 9 109 211 Betty |_____________> 1 109 Betty
2 8 118 212 Caro 2 118 Caro
3 7 207 213 Dany 3 207 Dany
4 6 96 214 Ester Index(['locker', 'nombre'], 4 96 Ester
5 5 350 215 Fran dtype='object') 5 350 Fran
6 4 240 216 Gaby 6 240 Gaby
 7 3 301 217 Hector 7 301 Hector
8 2 200 218 Ines 8 200 Ines
9 1 250 219 Julia 9 250 Julia
10 0 300 220 Kary 10 300 Kary

·
·
Query
Utilizar el método query() para seleccionar datos utilizando una expresión booleana.
El método query es otro metodo de DataFrame para seleccionar filas basada en los valores de las columnas.

Aqui los que ya han estudiado bases de datos SQL (Structured Query Language) y recuerdan la cláusula
WHERE corren con ventajas.
A query le proporcionaremos como parámetro un string con las condiciones y operadores.
·
Query
Código Python
salida = df.query('nombre == "Ariel"')
# ^ ^-----^^
# |_________________|string como condición
print(f"salida=\n{salida}")
Salida esperada por consola
salida=
ingreso locker sueldo nombre
0 10 100 210 Ariel
·Código Python
salida = df.query('sueldo >= 215 & ingreso % 2 == 0' )
print(f"salida=\n{salida}")
Salida esperada por consola
salida=
ingreso locker sueldo nombre
6 4 240 216 Gaby
8 2 200 218 Ines
10 0 300 220 Kary
·
·
Código Python
valor_sueldo = 215
valor_ingreso = 0
salida = df.query('sueldo >= @valor_sueldo & ingreso % 2 == @valor_ingreso' )
print(f"salida=\n{salida}")
Salida esperada por consola
salida=
ingreso locker sueldo nombre
6 4 240 216 Gaby
8 2 200 218 Ines
10 0 300 220 Kary
·
·
select_dtypes
Permite especificar el tipo de datos de las columnas que desea seleccionar.
exclude e include
Numéricos:
 'int64': Enteros de 64 bits.
 'float64': Números de coma flotante de 64 bits.
 'complex64': Números complejos de 64 bits.
df.select_dtypes(include=['int64', 'float64'])
Texto y Cadenas de Caracteres:
 'object': Cadenas de caracteres y otros tipos de objetos de Python.
 'string': Cadenas de caracteres (a partir de Pandas 1.0.0).
df.select_dtypes(include=['object'])
Booleanos:
 'bool': Valores booleanos (True o False).
df.select_dtypes(include=['bool'])
Fecha y Hora:
 'datetime64': Fechas y horas.
df.select_dtypes(include=['datetime64'])
Categóricos:
 'category': Datos categóricos.
df.select_dtypes(include=['category'])
Tipos de Datos Específicos (Ejemplos Adicionales):
 'timedelta64': Diferencia entre fechas y horas.
 'complex128': Números complejos de 128 bits.
 'uint16': Enteros sin signo de 16 bits.
 'float32': Números de coma flotante de 32 bits.
df.select_dtypes(exclude=['object', 'bool'])
·····································································································
Métodos DatoFames
de estadísticas df.min() Permite obtener el elemento mas pequeño del df
y Resumen df.max() Permite obtener el elemento mas grande del df
df.mean() Permite obtener la media de los elemento del df
df.idxmin() Permite ubicar el índice del valor mínimo.
df.idxmax() Permite ubicar el índice del valor máximo.
df.median() Permite calcular la mediFran de los valores.
df.std() Permite obtener la desviación estándar de los elemento del df
df.count() Permite obtener la cantidad de elemento del df
df.reindex Permite cambiar el orden de las filas de forma manual
df.describe() Permite calcular estadísticas descriptivas sobre la DataFrame.
df.sum() Permite calcular la suma de los valores del df.
df.corr(other) DataFrame.corr(other): Calcula la correlación con otra DataFrame.
·····································································································
Métodos DatoFames
de (obviamente el DataFrame debe contener fechas o tiempos)
Manipulación df.dt.year df.dt.month Devuelve el año de la fecha.
de Fechas y df.dt.day Devuelve el mes de la fecha.
Tiempos df.dt.strftime(format) Devuelve el día de la fecha.
pd.to_datetime(df) Convierte fechas en cadenas de texto con formato.
Convierte una DataFrame en un objeto DateTime.
 ·····································································································
Métodos DatoFames
de df.apply(func) Aplica una función a cada elemento del df.
Manipulación df.map(dict_or_func) Mapea valores a nuevos valores según un diccionario o función.
de Datos df.fillna(value) Rellena los valores nulos con el valor especificado.
df.dropna() Permite eliminar filas con valores nulos.
df.drop(index) Elimina un elemento por índice o etiqueta.
df.T Crea la transposición del df
·
Apply
El método df.apply(func) permite aplicar una función personalizada (func) a lo largo de las filas o columnas de
un DataFrame (df).

La dirección en la que deseas aplicar el método o El método, ya sea a lo largo de las filas (axis=0) o a lo largo de
las columnas (axis=1).
·
Apply
Código Python
datos = {
"ingreso":[10,9,8,7,6,5,4,3,2,1,0],
"locker" :[100,109,118,207,96,350,240,301,200,250,300],
"sueldo" :[210,211,212,213,214,215,216,217,218,219,220],
"nombre" :
["Ariel","Betty","Caro","Dany","Ester","Fran","Gaby","Hector","Ines","Julia", "Kary"]
}
df = pd.DataFrame(datos)
·Código Python
def suma_serie(serie):
return serie.sum()
#---------------------------------------------------------------------------------------
suma_por_fila = df.apply(suma_serie)
print(f"suma_por_fila=\n{suma_por_fila}")
Salida esperada por consola
suma_por_fila=
ingreso 55
locker 2271
sueldo 2365
nombre ArielBettyCaroDanyEsterFranGabyHectorInesJulia…< - - - - - -No tiene
sentido
dtype: object
Código Python
def suma_serie(serie):
return serie.sum()
#---------------------------------------------------------------------------------------
diferencia_max_min_por_columna = df.select_dtypes(exclude=['object'])
.apply(diferencia_max_min, axis=0)
print(f"suma_por_fila=\n{suma_por_fila}")
Salida esperada por consola
 suma_por_fila=
ingreso 55
locker 2271
sueldo 2365
dtype: int64
·
·
Código Python
datos = {
"ingreso":[10,9,8,7,6,5,4,3,2,1,0],
"locker" :[100,109,118,207,96,350,240,301,200,250,300],
"sueldo" :[210,211,212,213,214,215,216,217,218,219,220],
"nombre" :
["Ariel","Betty","Caro","Dany","Ester","Fran","Gaby","Hector","Ines","Julia", "Kary"]
}
df = pd.DataFrame(datos)
Código Python
def diferencia_max_min(columna):
return columna.max() - columna.min()
#---------------------------------------------------------------------------------------
diferencia_max_min_por_columna =
df.select_dtypes(exclude=['object']) .apply(diferencia_max_min, axis=0)
print(f"diferencia_max_min_por_columna=\n{diferencia_max_min_por_columna}")
Salida esperada por consola
diferencia_max_min_por_columna=
ingreso 10
locker 254
sueldo 10
dtype: int64
dtype: object
Código Python
def suma_serie(serie):
return serie.sum()
#---------------------------------------------------------------------------------------
diferencia_max_min_por_fila =
df.select_dtypes(exclude=['object']).apply(diferencia_max_min, axis=1)
print(f"diferencia_max_min_por_fila=\n{diferencia_max_min_por_fila}")
Salida esperada por consola
diferencia_max_min_por_fila=
0 200
1 202
2 204
3 206
4 208
5 345
6 236
7 298
8 216
9 249
10 300
dtype: int64
·
·
Map
El método df.map(func) permite aplicar una función personalizada (func) o mapeo a una Serie de un DataFrame
(df).

Esta función toma como argumento una función, un diccionario u otra Serie que se utilizará para realizar la
transformación.
·
Map
Código Python
datos = {
"ingreso":[10,9,8,7,6,5,4,3,2,1,0],
"locker" :[100,109,118,207,96,350,240,301,200,250,300],
"sueldo" :[210,211,212,213,214,215,216,217,218,219,220],
"nombre" :
["Ariel","Betty","Caro","Dany","Ester","Fran","Gaby","Hector","Ines","Julia", "Kary"]
}
df = pd.DataFrame(datos)
·Código Python
def es_par(dato):
return dato%2==0
#---------------------------------------------------------------------------------------
salida = df["ingreso"].map(es_par)# < - - - - - - - - - - map(función)
print(f"salida es_par=\n{salida}")
Salida esperada por consola
salida es_par=
0 True
1 False
2 True
3 False
4 True
5 False
6 True
7 False
8 True
9 False
10 True
Name: ingreso, dtype: bool
Código Python
salida = df.locker.map(es_par)# < - - - - - - - - - - map(función)
print(f"salida es_par=\n{salida}")
Salida esperada por consola
salida es_par=
0 True
1 False
2 True
3 False
4 True
5 True
6 True
7 False
8 True
9 True
10 True
Name: locker, dtype: bool
 ·
·
Código Python
datos = {
"ingreso":[10,9,8,7,6,5,4,3,2,1,0],
"locker" :[100,109,118,207,96,350,240,301,200,250,300],
"sueldo" :[210,211,212,213,214,215,216,217,218,219,220],
"nombre" :
["Ariel","Betty","Caro","Dany","Ester","Fran","Gaby","Hector","Ines","Julia", "Kary"]
}
df = pd.DataFrame(datos)
·Código Python
locker_dic ={ 100:"piso 1 izq",
109:"piso 1 izq",
118:"piso 1 der",
207:"piso 2 izq",
96: "piso PB der",
350:"piso 3 der",
240:"piso 2 der",
301:"piso 3 izq",
200:"piso 2 der",
250:"piso 2 der",
300:"piso 3 der"}
salida = df.locker.map(locker_dic)# < - - - - - - - - - - map(diccionario)
print(f"salida locker_dic=\n{salida}")
Salida esperada por consola
salida locker_dic=
0 piso 1 izq
1 piso 1 izq
2 piso 1 der
3 piso 2 izq
4 piso PB der
5 piso 3 der
6 piso 2 der
7 piso 3 izq
8 piso 2 der
9 piso 2 der
10 piso 3 der
Name: locker, dtype: object
·
·
Fillna
El método df.fillna() busca los valores NaN y los reemplazan por valores pre-establecidos.
value: El valor que se utilizará para reemplazar los valores faltantes (NaN).
inplace: booleana que indica si se debe realizar la modificación en el lugar o si se debe devolver un nuevo
DataFrame con los valores llenados.
·
Fillna()
Código Python
datos = {
 "ingreso":[10,9,8,7,6,5,None,3,2,1,0],
"locker" :[100,None,118,207,96,350,240,301,200,250,300],
"sueldo" :[210,211,212,213,214,None,216,217,218,219,220],
"nombre" :
["Ariel","Betty","Caro","Dany","Ester",None,"Gaby","Hector","Ines","Julia", "Kary"]
}
import numpy as np
datos = {
"ingreso":[10,9,8,7,6,5,np.nan,3,2,1,0],
"locker" :[100,np.nan,118,207,96,350,240,301,200,250,300],
"sueldo" :[210,211,212,213,214,np.nan,216,217,218,219,220],
"nombre" :
["Ariel","Betty","Caro","Dany","Ester",np.nan,"Gaby","Hector","Ines","Julia", "Kary"]
}
df = pd.DataFrame(datos)
·Código Python
salida = df.fillna(0) # < - - - - - - - - se reemplaza por cero (0)
print(f"salida sin NaN=\n{salida}")
print ("*"*50)
alida esperada por consola
original con NaN= salida sin NaN=
ingreso locker sueldo nombre ingreso locker sueldo nombre
0 10.0 100.0 210.0 Ariel 0 10.0 100.0 210.0 Ariel
1 9.0 NaN 211.0 Betty 1 9.0 0.0 211.0 Betty
2 8.0 118.0 212.0 Caro 2 8.0 118.0 212.0 Caro
3 7.0 207.0 213.0 Dany 3 7.0 207.0 213.0 Dany
4 6.0 96.0 214.0 Ester 4 6.0 96.0 214.0 Ester
5 5.0 350.0 NaN None 5 5.0 350.0 0.0 0
6 NaN 240.0 216.0 Gaby 6 0.0 240.0 216.0 Gaby
7 3.0 301.0 217.0 Hector 7 3.0 301.0 217.0 Hector
8 2.0 200.0 218.0 Ines 8 2.0 200.0 218.0 Ines
9 1.0 250.0 219.0 Julia 9 1.0 250.0 219.0 Julia
10 0.0 300.0 220.0 Kary 10 0.0 300.0 220.0 Kary
·
·
Dropna
El método df.fillna() busca los valores NaN y eliminar filas o columnas los contienen. de un DataFrame. Este
método es útil cuando deseas eliminar datos faltantes antes de realizar análisis o procesamiento posterior.

Sintaxis:
df.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)
axis: Indica si deseas eliminar filas (axis=0, por defecto) o columnas (axis=1) que contienen valores faltantes.
how: Controla cuándo se eliminará una fila o columna.
'any': (default) Eliminará una fila o columna si contiene al menos un valor faltante.
'all': Solo eliminará una fila o columna si todos sus valores son faltantes.
thresh: Establece un limite o umbral con un número entero que especifica la cantidad mínimo de valores no
faltantes requeridos en una fila o columna antes de que no se elimine.
subset: Una lista de etiquetas de columnas que se utilizarán para buscar valores faltantes. Si se proporciona, solo
se eliminarán filas o columnas que tengan valores faltantes en las columnas especificadas.
inplace: Booleano que indica si deseas realizar la eliminación en el lugar (modificar el DataFrame original) o si
deseas devolver un nuevo DataFrame con las filas o columnas eliminadas. Por defecto, es False.
·
dropna()
Código Python
import numpy as np
datos = {
"ingreso":[10,9,8,7,6,5,np.nan,3,2,1,np.nan],
"locker" :[100,109,118,207,96,350,240,301,200,250,300],
"sueldo" :[210,np.nan,212,213,214,np.nan,216,217,np.nan,219,220],
"nombre" :
["Ariel","Betty","Caro","Dany","Ester","Fran","Gaby","Hector","Ines","Julia", "Kary"]
}
df = pd.DataFrame(datos)
print(f"original con NaN=\n{df}")
Código Python
salida = df.dropna(axis=0)< - - - - - - - - elimina por filas (axis=0)
print(f"salida sin NaN borrado por fila=\n{salida}")
Código Python
salida = df.dropna(axis=1)< - - - - - - - - elimina por columnas (axis=1)
print(f"salida sin NaN borrado por columna=\n{salida}")
Salida esperada por consola
original con NaN= salida sin NaN borrado por fila= salida sin NaN borrado por
ingreso locker sueldo nombre ingreso locker sueldo nombre columna=
0 10.0 100 210.0 Ariel 0 10.0 100 210.0 Ariel locker nombre
1 9.0 109 NaN Betty 0 100 Ariel
2 8.0 118 212.0 Caro 2 8.0 118 212.0 Caro 1 109 Betty
3 7.0 207 213.0 Dany 3 7.0 207 213.0 Dany 2 118 Caro
4 6.0 96 214.0 Ester 4 6.0 96 214.0 Ester 3 207 Dany
5 5.0 350 NaN Fran 4 96 Ester
6 NaN 240 216.0 Gaby 5 350 Fran
7 3.0 301 217.0 Hector 7 3.0 301 217.0 Hector 6 240 Gaby
8 2.0 200 NaN Ines 7 301 Hector
9 1.0 250 219.0 Julia 9 1.0 250 219.0 Julia 8 200 Ines
10 NaN 300 220.0 Kary 9 250 Julia
10 300 Kary

·
·
Drop()
El método df.drop(index) permite eliminar una o varias filas o columnas de un DataFrame según su indice.
Este método es útil cuando deseas eliminar datos y achicar el tamaño del df.
Sintaxis:
df.drop(index, axis=0, inplace=False)
index: La etiqueta o lista de etiquetas de las filas que deseas eliminar.
axis: Indica si deseas eliminar filas (axis=0, por defecto) o columnas (axis=1).
inplace: Un valor booleano que indica si deseas realizar la eliminación en el lugar (modificar el DataFrame
original) o si deseas devolver un nuevo DataFrame sin las filas especificadas. Por defecto, es False.
·
drop()
Código Python
datos = {
"ingreso":[10,9,8,7,6,5,4,3,2,1,0],
"locker" :[100,109,118,207,96,350,240,301,200,250,300],
"sueldo" :[210,211,212,213,214,215,216,217,218,219,220],
 "nombre" :
["Ariel","Betty","Caro","Dany","Ester","Fran","Gaby","Hector","Ines","Julia", "Kary"]
}
df = pd.DataFrame(datos)
print(f"original=\n{df}")
Código Python
df_sin_filas = df.drop(["A","E","J"], axis=0)< - - - - - - - - elimina por filas (axis=0)
print(f"df_sin_filas=\n{df_sin_filas}")
Código Python
df_sin_columna = df.drop(["locker"], axis=1)< - - - - - - - - elimina por columnas (axis=1)
print(f"df_sin_columna=\n{df_sin_columna}")
Salida esperada por consola
original= df_sin_filas= df_sin_columna=
ingreso locker sueldo nombre ingreso locker sueldo nombre ingreso sueldo nombre
A 10 100 210 Ariel A 10 210 Ariel
B 9 109 211 Betty B 9 109 211 Betty B 9 211 Betty
C 8 118 212 Caro C 8 118 212 Caro C 8 212 Caro
D 7 207 213 Dany D 7 207 213 Dany D 7 213 Dany
E 6 96 214 Ester E 6 214 Ester
F 5 350 215 Fran F 5 350 215 Fran F 5 215 Fran
G 4 240 216 Gaby G 4 240 216 Gaby G 4 216 Gaby
H 3 301 217 Hector H 3 301 217 Hector H 3 217 Hector
I 2 200 218 Ines I 2 200 218 Ines I 2 218 Ines
J 1 250 219 Julia J 1 219 Julia
K 0 300 220 Kary K 0 300 220 Kary K 0 220 Kary

·
·
dt.t o dt.transpose()
La transposición, representada por dt.t o dt.transpose(), es una operación que se utiliza para cambiar las filas de
una matriz o un DataFrame a columnas y viceversa.
Cambio de Orientación de Datos:
La transposición es útil cuando deseas cambiar la orientación de tus datos. Por ejemplo, si tienes un
DataFrame donde las filas representan variables y las columnas representan observaciones, la
transposición te permitirá cambiarlo para que las filas sean observaciones y las columnas sean variables,
o viceversa. Esto puede ser útil en casos en los que prefieras trabajar con los datos de una manera u otra.
Cálculos y Operaciones:
En algunos casos, la transposición es necesaria para realizar ciertos cálculos o aplicar operaciones.
Algunos algoritmos o funciones pueden requerir que los datos estén en un formato específico, y la
transposición puede ser parte del proceso de preparación de datos.
Visualización de Datos:
En la visualización de datos, a veces es más efectivo representar los datos en una orientación diferente
para crear gráficos más claros y legibles. La transposición puede ayudar a lograr este objetivo.
Compatibilidad con Algoritmos y Bibliotecas:
Algunas bibliotecas y algoritmos pueden esperar que los datos se proporcionen en un formato
específico. La transposición puede ser necesaria para que tus datos sean compatibles con estas
bibliotecas o algoritmos.
Reducción de Dimensionalidad:
En algunas situaciones, la transposición puede utilizarse como parte de un proceso de reducción de
dimensionalidad o preprocesamiento de datos.
Análisis de Datos Longitudinales:
En el análisis de datos longitudinales o de series temporales, la transposición puede ser útil para cambiar
entre una representación de "ancho" y una representación "larga" de los datos.
·
.T() o .transpose()
Código Python
datos = {
"ingreso":[10,9,8,7,6,5,4,3,2,1,0],
"locker" :[100,109,118,207,96,350,240,301,200,250,300],
"sueldo" :[210,211,212,213,214,215,216,217,218,219,220],
"nombre" :
["Ariel","Betty","Caro","Dany","Ester","Fran","Gaby","Hector","Ines","Julia", "Kary"]
}
df = pd.DataFrame(datos)
print(f"original=\n{df}")
Salida esperada por consola
original=
ingreso locker sueldo nombre
A 10 100 210 Ariel
B 9 109 211 Betty
C 8 118 212 Caro
D 7 207 213 Dany
E 6 96 214 Ester
F 5 350 215 Fran
G 4 240 216 Gaby
H 3 301 217 Hector
I 2 200 218 Ines
J 1 250 219 Julia
K 0 300 220 Kary
Código Python
print(f"df Transpuesta=\n{df.T}")
Salida esperada por consola
df Transpuesta=
A B C D E F G H I J K
ingreso 10 9 8 7 6 5 4 3 2 1 0
locker 100 109 118 207 96 350 240 301 200 250 300
sueldo 210 211 212 213 214 215 216 217 218 219 220
nombre Ariel Betty Caro Dany Ester Fran Gaby Hector Ines Julia Kary

·
df.sort_values(by='columna')
El método df.sort_values(by='columna') en Pandas se utiliza para ordenar un DataFrame en función de los
valores de una columna específica. Esta operación es útil para organizar los datos en un orden específico, lo que
facilita la exploración y el análisis de los datos. Aquí está una descripción detallada de cómo funciona:
Sintaxis:
df.sort_values(by, axis=0, ascending=True, inplace=False, ignore_index=False, key=None)
by: Especifica la columna por la cual deseas ordenar el DataFrame. Debe proporcionarse el nombre de
la columna.
axis: Indica si deseas ordenar las filas (axis=0, por defecto) o las columnas (axis=1) del DataFrame. En
este caso, se usa axis=0 para ordenar las filas.
ascending: Un valor booleano o una lista de valores booleanos que indica si deseas ordenar en orden
ascendente (True) o descendente (False). Por defecto, es True, lo que significa que se ordenarán en orden
ascendente.
inplace: Un valor booleano que determina si deseas realizar la ordenación en el lugar (modificar el
DataFrame original) o si deseas devolver un nuevo DataFrame ordenado. Por defecto, es False.
ignore_index: Un valor booleano que controla si deseas restablecer el índice después de la ordenación.
 Por defecto, es False.
key: Una función que se utiliza para personalizar la ordenación, por ejemplo, para ordenar basándose en
una función de transformación de valores en lugar de los valores reales. Por defecto, es None.

·
df.sort_values(by='columna')
Código Python
datos = {
"ingreso":[10,9,8,7,6,5,4,3,2,1,0],
"locker" :[100,109,118,207,96,350,240,301,200,250,300],
"sueldo" :[210,211,212,213,214,215,216,217,218,219,220],
"nombre" :
["Ariel","Betty","Caro","Dany","Ester","Fran","Gaby","Hector","Ines","Julia", "Kary"]
}
df = pd.DataFrame(datos)
print(f"original=\n{df}")
Código Python
salida = df.sort_values(by="nombre")
print(f"salida=\n{salida}")
Código Python
salida = df.sort_values(by="nombre" , ascending=False)# para ordenar en orden descendente
print(f"salida=\n{salida}")

Salida esperada por consola

original= salida= salida=
ingreso locker sueldo nombre ingreso locker sueldo nombre ingreso locker sueldo nombre
A 10 100 210 Ariel E 6 96 214 Ester K 0 300 220 Kary
B 9 109 211 Betty A 10 100 210 Ariel J 1 250 219 Julia
C 8 118 212 Caro B 9 109 211 Betty I 2 200 218 Ines
D 7 207 213 Dany C 8 118 212 Caro H 3 301 217 Hector
E 6 96 214 Ester I 2 200 218 Ines G 4 240 216 Gaby
F 5 350 215 Fran D 7 207 213 Dany F 5 350 215 Fran
G 4 240 216 Gaby G 4 240 216 Gaby E 6 96 214 Ester
H 3 301 217 Hector J 1 250 219 Julia D 7 207 213 Dany
I 2 200 218 Ines K 0 300 220 Kary C 8 118 212 Caro
J 1 250 219 Julia H 3 301 217 Hector B 9 109 211 Betty
K 0 300 220 Kary F 5 350 215 Fran A 10 100 210 Ariel

·
Concat
Para agregar filas o columnas en un DataFrame existente, primero debes crear un nuevo DataFrame que
contenga lo que deseas agregar y luego utilizar pd.concat para combinar ambos DataFrames.
Los DataFrames deben tener las mismas cantidad de columnas y que los nombres de las columnas tienen que
coincidir.
·
df.concat( [ df_1 , df_2 ] )
Código Python
datos = {
"ingreso":[10,9,8,7,6,5,4,3,2,1,0],
"locker" :[100,109,118,207,96,350,240,301,200,250,300],
"sueldo" :[210,211,212,213,214,215,216,217,218,219,220],
 "nombre" :
["Ariel","Betty","Caro","Dany","Ester","Fran","Gaby","Hector","Ines","Julia", "Kary"]
}
df = pd.DataFrame(datos)
print(f"original=\n{df}")
Código Python
ingreso = {
"ingreso":[11],
"locker" :[275],
"sueldo" :[230],
"nombre" :["Joaquin"]
}
fila_nueva = pd.DataFrame(ingreso)
df_concat = pd.concat([df, fila_nueva], ignore_index=True)
Salida esperada por consola
salida=
ingreso locker sueldo nombre
0 10 100 210 Ariel
1 9 109 211 Betty
2 8 118 212 Caro
3 7 207 213 Dany
4 6 96 214 Ester
5 5 350 215 Fran
6 4 240 216 Gaby
7 3 301 217 Hector
8 2 200 218 Ines
9 1 250 219 Julia
10 0 300 220 Kary
11 11 275 230 Joaquin < - - - - - - - - -fila Agregada
·
Código Python
dic = {
"Argentina": "Buenos Aires",
"Bolivia": "La Paz",
"Brasil": "Brasilia",
"Chile": "Santiago",
"Colombia": "Bogotá",
"Ecuador": "Quito",
"Guyana": "Georgetown",
"Paraguay": "Asunción",
"Perú": "Lima",
"Surinam": "Paramaribo",
"Uruguay": "Montevideo",
"Venezuela": "Caracas"}

df_concat["pais"]=dic.keys()
df_concat["ciudad"]=dic.values()

Salida esperada por consola

salida=
ingreso locker sueldo nombre pais ciudad
0 10 100 210 Ariel Argentina Buenos Aires
1 9 109 211 Betty Bolivia La Paz
2 8 118 212 Caro Brasil Brasilia
 3 7 207 213 Dany Chile Santiago
4 6 96 214 Ester Colombia Bogotá
5 5 350 215 Fran Ecuador Quito
6 4 240 216 Gaby Guyana Georgetown
7 3 301 217 Hector Paraguay Asunción
8 2 200 218 Ines Perú Lima
9 1 250 219 Julia Surinam Paramaribo
10 0 300 220 Kary Uruguay Montevideo
11 11 275 230 Joaquin Venezuela Caracas
^_____________^_______columnas Agregadas
·
·
groupby
Se utiliza para agrupar filas de un DataFrame según los valores de una o más columnas.
Después de agrupar los datos, puedes realizar operaciones de agregación en cada grupo, como sumar, promediar
o contar los valores en cada grupo
Sintaxis
grupo = df.groupby(columna_grupo)
Donde `columna_grupo` es el/los nombre(s) de la columna(s) por la cual deseas agrupar el DataFrame.
·
df.groupby()
Código Python
datos = {
"ingreso":[10,9,8,7,6,5,4,3,2,1,0],
"locker" :[100,109,118,207,96,350,240,301,200,250,300],
"sueldo" :[210,211,212,213,214,215,216,217,218,219,220],
"nombre" :
["Ariel","Betty","Caro","Dany","Ester","Fran","Gaby","Hector","Ines","Julia", "Kary"]
}
df = pd.DataFrame(datos)
print(f"original=\n{df}")
Código Python

Salida esperada por consola

·
Código Python

Salida esperada por consola

·
·
import pandas as pd
data = {'Vendedor': ['Alice', 'Bob', 'Alice', 'Alice', 'Bob'],
'Producto': ['A', 'B', 'A', 'C', 'B'],
'Venta': [100, 200, 150, 300, 250]}
df = pd.DataFrame(data)
```

Si deseamos agrupar las ventas por vendedor y calcular la suma de las ventas para cada vendedor, podemos
hacerlo de la siguiente manera:

```python
grupo = df.groupby('Vendedor')
total_ventas_por_vendedor = grupo['Venta'].sum()
```

El resultado será un nuevo objeto `Series` que muestra la suma de las ventas por vendedor:

```
Vendedor
Alice 550
Bob 450
Name: Venta, dtype: int64
```

Puedes realizar varias operaciones de agregación en grupos, como `sum()`, `mean()`, `count()`, `min()`, `max()`,
etc. Por ejemplo, si deseas calcular el promedio de ventas por producto:

```python
grupo = df.groupby('Producto')
promedio_ventas_por_producto = grupo['Venta'].mean()
```

El resultado será:

```
Producto
A 125.0
B 225.0
C 300.0
Name: Venta, dtype: float64
```

También puedes agrupar por múltiples columnas proporcionando una lista de nombres de columnas al método
`groupby`. Por ejemplo, para agrupar por vendedor y producto:

```python
grupo = df.groupby(['Vendedor', 'Producto'])
total_ventas_por_vendedor_producto = grupo['Venta'].sum()
```
El resultado mostrará la suma de las ventas para cada combinación de vendedor y producto.

df.groupby('columna').agg({'columna2': 'función'}):
Permite agrupar datos por una columna y aplicar una función de agregación a otra columna.
resumen = df.groupby('A').agg({'B': 'sum'})

pd.merge(df1, df2, on='columna_común'):

Permite fusionar DataFrames en función de una columna común (similar a una operación SQL JOIN).

df_fusionado = pd.merge(df1, df2, on='clave')

Cambiar nombres de columnas:

df.rename(columns={'nombre_actual': 'nombre_nuevo'}):
Permite cambiar los nombres de las columnas.
df = df.rename(columns={'A': 'Columna_A', 'B': 'Columna_B'})

El método to_sql en Pandas se utiliza para guardar los datos de un DataFrame en una base de datos
SQL. Permite escribir los contenidos de un DataFrame en una tabla específica de una base de datos
relacional utilizando una conexión a la base de datos.

Aquí tienes una descripción detallada de cómo utilizar to_sql:

python
DataFrame.to_sql(name, con, schema=None, if_exists='fail', index=True, index_label=None,
chunksize=None, dtype=None)

- name: Especifica el nombre de la tabla en la base de datos donde se guardarán los datos del
DataFrame.

- con: Representa la conexión a la base de datos. Puedes proporcionar una conexión SQLAlchemy o
un objeto SQLite. También puedes proporcionar una cadena de conexión que describe la ubicación
de la base de datos. Por ejemplo, para SQLite, puedes especificar un archivo SQLite como
'sqlite:///mydatabase.db'.

- schema (opcional): Especifica el esquema en la base de datos donde se guardará la tabla. Por
defecto, es None, lo que significa que se usará el esquema predeterminado.
- if_exists (opcional): Determina qué hacer si la tabla ya existe en la base de datos. Puede tomar uno
de los siguientes valores:
- 'fail' (predeterminado): Genera un error si la tabla ya existe.
- 'replace': Reemplaza la tabla existente con los datos del DataFrame.
- 'append': Agrega los datos del DataFrame a la tabla existente.

- index (opcional): Controla si se debe incluir el índice del DataFrame como una columna en la
tabla de la base de datos. De forma predeterminada, es True.

- index_label (opcional): Permite especificar un nombre personalizado para la columna de índice si

se incluye en la tabla. Por defecto, el nombre se genera automáticamente.

- chunksize (opcional): Define el número de filas que se insertarán en la base de datos a la vez. Esto
puede ser útil para controlar el uso de memoria al insertar grandes cantidades de datos.

- dtype (opcional): Permite especificar el tipo de datos que se utilizará en la base de datos para cada
columna. Puede ser un diccionario que mapee nombres de columna a tipos de datos SQL.

Ejemplo de uso de to_sql:

python
from sqlalchemy import create_engine

# Crear una conexión a la base de datos SQLite

engine = create_engine('sqlite:///mydatabase.db')

# DataFrame con los datos que se guardarán

df = ...

# Guardar el DataFrame en una tabla llamada 'mi_tabla' en la base de datos

df.to_sql('mi_tabla', con=engine, if_exists='replace', index=False)

En este ejemplo, se crea una conexión a una base de datos SQLite y se utiliza to_sql para guardar el
DataFrame df en una tabla llamada 'mi_tabla'. La opción if_exists se establece en 'replace' para
reemplazar la tabla si ya existe, y el índice del DataFrame se excluye (index=False) al guardar los
datos en la tabla.