Seleccionar datos es una operación fundamental en cualquier análisis de datos. En Pandas, las dos formas más comunes de seleccionar datos son iloc y loc.
iloc[] - Indexación por Enteros
iloc se utiliza para la indexación basada en enteros, permitiendo seleccionar filas y columnas por su posición.
Ejemplos de uso de iloc:
Seleccionar una fila específica:
import pandas as pd
file_path = "online_retail.csv"
retail_data = pd.read_csv(file_path)
# Seleccionar la primera fila
primera_fila = retail_data.iloc[0]
print("Primera fila:\n", primera_fila)
Seleccionar múltiples filas:
# Seleccionar las primeras cinco filas
primeras_cinco_filas = retail_data.iloc[:5]
print("Primeras cinco filas:\n", primeras_cinco_filas)
Seleccionar una fila y una columna específica:
# Seleccionar el valor en la primera fila y tercera columna
valor = retail_data.iloc[0, 2]
print("Valor en la primera fila y tercera columna:", valor)
Seleccionar múltiples filas y columnas:
# Seleccionar las primeras cinco filas y las primeras tres columnas
subset = retail_data.iloc[:5, :3]
print("Subset de las primeras cinco filas y tres columnas:\n", subset)
loc[] - Indexación por Etiquetas
loc se utiliza para la indexación basada en etiquetas, permitiendo seleccionar filas y columnas por sus nombres.
Ejemplos de uso de loc:
Seleccionar una fila específica por su índice:
# Seleccionar la fila con índice 3
fila_indice_3 = retail_data.loc[3]
print("Fila con índice 3:\n", fila_indice_3)
Seleccionar múltiples filas por sus índices:
# Seleccionar filas con índices de 0 a 4
filas_indices_0_a_4 = retail_data.loc[0:4]
print("Filas con índices de 0 a 4:\n", filas_indices_0_a_4)
Nota: Con loc, el índice final es inclusivo. retail_data.loc[0:4] selecciona 5 filas, incluyendo la fila con índice 4.
# Seleccionar las columnas 'Quantity' y 'UnitPrice'
columnas_quantity_unitprice = retail_data.loc[:, ['Quantity', 'UnitPrice']]
print("Columnas 'Quantity' y 'UnitPrice':\n", columnas_quantity_unitprice.head())
Seleccionar columnas por rango de nombres:
# Seleccionar columnas por rango de nombres
subset_columns = retail_data.loc[:, 'Column1':'Column5']
print("Columnas desde 'Column1' hasta 'Column5':\n", subset_columns.head())
Diferencias Clave entre iloc y loc
Basado en Enteros vs. Etiquetas:
iloc: selecciona datos por posición usando índices enteros.
loc: selecciona datos por etiquetas usando nombres de índices y columnas.
Inclusión del Último Índice:
iloc: excluye el último índice en un rango.
loc: incluye el último índice en un rango.
Ejercicio Práctico
Seleccionar Subconjuntos de Datos:
Utiliza iloc para seleccionar las primeras 10 filas y las primeras 2 columnas del dataset de retail.
Utiliza loc para seleccionar todas las filas y las columnas ‘Quantity’ y ‘UnitPrice’.
Acceso Específico:
Utiliza iloc para seleccionar el valor en la quinta fila y la segunda columna.
Utiliza loc para seleccionar todas las filas donde el país es ‘United Kingdom’ y mostrar las columnas ‘Quantity’ y ‘UnitPrice’.
Código de Ejemplo
import pandas as pd
# Leer el dataset de retail desde un archivo CSV
file_path = "online_retail.csv"
retail_data = pd.read_csv(file_path)
# Seleccionar las primeras 10 filas y las primeras 2 columnas utilizando iloc
subset_iloc = retail_data.iloc[:10, :2]
print("Primeras 10 filas y 2 columnas utilizando iloc:\n", subset_iloc)
# Seleccionar todas las filas y las columnas 'Quantity' y 'UnitPrice' utilizando loc
subset_loc = retail_data.loc[:, ['Quantity', 'UnitPrice']]
print("Columnas 'Quantity' y 'UnitPrice' utilizando loc:\n", subset_loc.head())
# Seleccionar el valor en la quinta fila y la segunda columna utilizando iloc
valor_iloc = retail_data.iloc[4, 1]
print("Valor en la quinta fila y segunda columna utilizando iloc:", valor_iloc)
# Seleccionar todas las filas donde el país es 'United Kingdom' y mostrar las columnas 'Quantity' y 'UnitPrice' utilizando loc
subset_uk = retail_data.loc[retail_data['Country'] == 'United Kingdom', ['Quantity', 'UnitPrice']]
print("Filas de 'United Kingdom' con columnas 'Quantity' y 'UnitPrice' utilizando loc:\n", subset_uk.head())
Con loc podemos acceder a los datos por medio de los valores de los indices y no de la posición numérica de las filas y columnas, éste método es "basado en etiquetas".
Características de loc:
Si el index de un DataFrame o Serie es categoríco, podemos acceder a el por medio de su valor.
También recibe valores numéricos para las posición, pero su indexación empieza desde el $1$.
Permite filtrado booleano de las filas.
Permite la selección de columnas mediante el nombre de éstas.
Sintaxis: data_df.loc[filas, columnas].
Donde:
filas: Una sola posición, un array con las posiciones numéricas, un slicing o una selección booleana.
columnas: Nombre de una columna o un array con los nombres de las columnas.
Sintaxis de slicing en loc aplica tanto para las filas como para las columnas [posicion_inicial : posicion_final : saltos]
print("Filas de la 2 a la 8:")rows_from_2_to_8 = retail_df.loc[2:8]print(type(rows_from_2_to_8))display(rows_from_2_to_8)print("Ventas de 6 unidades en Arabia Saudita")advance_selection =( retail_df.loc[(retail_df["Country"]=="Saudi Arabia")&(retail_df["Quantity"]==6),["Description","Quantity","UnitPrice","InvoiceDate"]])display(advance_selection)
Espero este aporte les sea de utilidad💚
muy bien
Consulta...
osea que con iloc, si pongo .iloc[0]
voy a obtener la primera fila, osea la que tiene index 0
pero si uso .loc[1], voy a obtener la segunda fila, osea la que tiene el indice 1?
gracias por la paciencia
Encontré este video, la verdad está increíblemente explicado muy claro todo:
Mi resumen:
Método de Referencia:* iloc utiliza la posición numérica para acceder a filas y columnas. Es útil cuando no se conocen los nombres de los índices.
loc trabaja con las etiquetas o nombres de los índices, lo que permite acceder de manera más intuitiva si los nombres están bien definidos.
Slicing: Inclusión del Límite Final:* iloc sigue la convención de exclusión del límite superior, por lo que el valor final en un rango de posiciones no se incluye.
loc, por el contrario, incluye tanto el punto de partida como el de llegada en una operación de rango.
Selección Condicional:* loc permite realizar filtros basados en condiciones booleanas, facilitando la selección de filas o columnas que cumplan ciertos criterios.
iloc, al trabajar solo con números, no admite este tipo de filtrado condicional de manera directa.
La diferencia principal entre loc y groupby en Pandas radica en su propósito y uso:
loc se utiliza para acceder a un grupo específico de filas y columnas en un DataFrame utilizando etiquetas. Permite seleccionar datos mediante índices explícitos, facilitando la extracción de subconjuntos de datos.
groupby, por otro lado, se utiliza para agrupar datos en función de una o más columnas y permite realizar operaciones de agregación sobre esos grupos. Es ideal para resumir y analizar datos basados en características comunes.
En resumen, loc se centra en la selección de datos y groupby en la agregación y análisis.
📍 Diferencia entre loc e iloc La principal diferencia es que loc se utiliza para filtrar datos por etiquetas (nombres de filas/columnas), mientras que iloc lo hace basándose en posiciones enteras (índices). source
📊 Método loc loc es un método en Pandas que permite seleccionar filas y columnas mediante etiquetas, lo que facilita trabajar con datos específicos. source
📈 Método iloc iloc se utiliza para acceder a filas y columnas por sus posiciones, siendo útil cuando no se conocen las etiquetas de los datos.
1) Acceso a la Primera Fila con iloc:
first_row = retail_data.iloc[0]
print(first_row)
Descripción: Obtiene y muestra la primera fila del DataFrame usando índices enteros.
2) Acceso a las Primeras Cinco Filas con iloc:
first_five_row = retail_data.iloc[:5]
print(first_five_row)
Descripción: Obtiene y muestra las primeras cinco filas del DataFrame.
3) Subconjunto de Filas y Columnas con iloc:
subset = retail_data.iloc[:3, :2]
print(subset)
Descripción: Obtiene las tres primeras filas y las dos primeras columnas del DataFrame.
4) Acceso a un Valor Específico con iloc:
retail_value = retail_data.iloc[1, 2]
print(retail_value)
Descripción: Obtiene el valor en la segunda fila y tercera columna (Description de la fila 1).
5) Acceso a una Fila con loc:
row_index_3 = retail_data.loc[3]
print(row_index_3)
Descripción: Obtiene y muestra la fila en el índice 3 usando índices basados en etiquetas.
6) Acceso a Varias Filas con loc:
row_index_0_to_4 = retail_data.loc[0:4]
print(row_index_0_to_4)
Descripción: Obtiene y muestra las filas de índice 0 a 4 (inclusive) usando etiquetas.
7) Acceso a una Columna con loc:
quantity_column = retail_data.loc[:, 'Quantity']
print(quantity_column)
Descripción: Obtiene y muestra la columna Quantity
Descripción: Obtiene y muestra las columnas Quantity y UnitPrice para todas las filas.
<u>Uso de iloc y loc en Pandas</u><u>; </u>
Son las formas más comunes de seleccionar datos.
Iloc nos ayuda a extraer la información de nuestro dataframe especificando el índice.
Loc accede a la información pero especificando la etiqueta.
iloc y loc son dos métodos en Pandas utilizados para seleccionar datos de un DataFrame, pero tienen diferencias clave:
iloc: Se utiliza para seleccionar filas y columnas por índice entero (posición). Por ejemplo, df.iloc[0] selecciona la primera fila.
loc: Se usa para seleccionar filas y columnas por etiquetas. Por ejemplo, df.loc['nombre_columna'] selecciona toda la columna con esa etiqueta.
Ambos son útiles, dependiendo de si prefieres trabajar con posiciones o con nombres de etiquetas.
Poner condiciones a cierta cantidad de Filas con iloc y loc.
En **Pandas**, los métodos **iloc** y **loc** se utilizan para acceder a datos en un **DataFrame** o **Series** basándose en diferentes criterios de indexación. Estos dos métodos son esenciales para seleccionar, filtrar o modificar subconjuntos de datos en un DataFrame.
---
### **1. iloc: Indexación basada en la posición**
- **iloc** se utiliza para seleccionar datos basándose en la **posición** numérica (es decir, los índices) de las filas y columnas.
- Funciona de manera similar a la indexación de listas en Python, es decir, por **números de posición**.
#### Sintaxis de iloc:
df.iloc\[fila, columna]
- fila: Especifica la(s) fila(s) por posición (puede ser un número o un rango).
- columna: Especifica la(s) columna(s) por posición (puede ser un número o un rango).
#### Ejemplos de iloc:
import pandas as pd
\# Crear un DataFrame de ejemplo
data ={'Nombre': \['Ana','Luis','Carlos'],  'Edad': \[23, 45, 36],  'Ciudad': \['Madrid', 'Barcelona', 'Valencia']}df = pd.DataFrame(data)\# Seleccionar la primera fila (posición 0)print(df.iloc\[0])
\# Seleccionar las primeras dos filas y todas las columnas
print(df.iloc\[0:2,:])\# Seleccionar la segunda fila y la tercera columna (índice 1 y 2)print(df.iloc\[1,2])\# Seleccionar las dos primeras filas y la primera columna (índice 0)print(df.iloc\[0:2,0])
---
### **2. loc: Indexación basada en etiquetas**
- **loc** se utiliza para seleccionar datos basándose en las **etiquetas** (índices) de filas y columnas.
- Funciona con **etiquetas de índice**, que pueden ser enteros, cadenas o cualquier tipo de etiqueta asignada a las filas o columnas.
#### Sintaxis de loc:
df.loc\[etiqueta\_fila, etiqueta\_columna]
- etiqueta\_fila: Especifica la(s) fila(s) por su índice (puede ser una etiqueta específica o un rango).
- etiqueta\_columna: Especifica la(s) columna(s) por su nombre.
#### Ejemplos de loc:
\# Seleccionar la fila con índice 0(la primera fila)print(df.loc\[0])\# Seleccionar la fila donde el índice es 1print(df.loc\[1])\# Seleccionar las filas con índice 0 y 1, y todas las columnas
print(df.loc\[0:1,:])\# Seleccionar todas las filas y la columna 'Edad'print(df.loc\[:,'Edad'])\# Seleccionar la fila con índice 0 y las columnas 'Nombre' y 'Edad'print(df.loc\[0, \['Nombre','Edad']])
---
### **Diferencias clave entre iloc y loc:**
1. **Criterio de indexación**:
- **iloc** usa la **posición numérica** para seleccionar filas y columnas.
- **loc** usa las **etiquetas o nombres de índice** para seleccionar filas y columnas.
2. **Inclusión de los límites**:
- Con **iloc**, el último valor en un rango es **excluido** (similar a la indexación de listas en Python).
- Con **loc**, los límites en los rangos de filas **son incluidos**.
3. **Tipo de selección**:
- **iloc** es más útil cuando trabajas con posiciones numéricas.
- **loc** es más intuitivo cuando trabajas con etiquetas o nombres de columnas.
---
### Ejemplos adicionales para mostrar las diferencias:
#### Usando iloc para seleccionar por posiciones:
\# Seleccionar la primera fila (posición 0) y la primera columna (posición 0)df.iloc\[0,0]# Resultado: 'Ana'
#### Usando loc para seleccionar por etiquetas:
\# Seleccionar la primera fila (índice 0) y la columna 'Nombre'df.loc\[0,'Nombre']# Resultado: 'Ana'
#### Seleccionar un subconjunto con iloc y loc:
\# Con iloc: Seleccionar las dos primeras filas y todas las columnas
df.iloc\[0:2,:]\# Con loc: Seleccionar las filas con índices 0 y 1, y todas las columnas
df.loc\[0:1,:]
---
### Resumen
- **iloc** es para seleccionar datos **por posiciones numéricas**.
- **loc** es para seleccionar datos **por etiquetas de filas y nombres de columnas**.
Ambos son muy útiles para acceder y manipular datos en **DataFrames** y **Series** de Pandas, y la elección entre ellos depende del tipo de indexación que estés utilizando.
Filtrar un país específico 'Poland' de la columna Country, con el precio unitario del producto:CountryUnitPrice6608Poland2.556609Poland1.256610Poland1.456611Poland1.496612Poland0.856613Poland8.506614Poland1.456615Poland1.45
Reto o sugerencia de la lección: dividir en bloques más pequeños para poder hacer el preprocesamiento:
import numpy as np
print(retail_data.shape)# Dividir en bloques más pequeños
block_size =100000for i inrange(0,len(retail_data), block_size): block = retail_data[i:i+block_size] # Realizar operaciones en el bloque
print(f"Procesando bloque {i//block_size + 1}") # Muestra el número de bloque actual a medida que se ejecuta el ciclo forprint(block) # Muestra las primeras 5 y las últimas 5filas(observaciones) de cada uno de los bloques
```Si quisiéramos procesar cada uno de los bloques, los tendríamos que guardar como listas o diccionarios.
Comparto mis apuntes y propuesta de solución para los ejercicios
NOTA: Uno de los ejercicios requiere del us de una condición booleana para extraer las filas que cumplen la condición "United Kingdom"
Me puse a jugar un poquito y este es el resultado de mi pequeño proyecto
Hola, intenté renderizar un DataFrame en Dijango (un framework de desarrollo WEB en Python),lo pude hacer pero no salió como esperaba,,,,,jajajaj.....se renderiza pero no sale ordenado como en la terminal.Mi idea es poder organizarlo por filas y columnas en la WEB,pensé que podia cambiar bases de datos por CSV's. Alguien ya lo hizo!