Seleccionar datos en Pandas es una de las habilidades base para cualquier análisis con Python, y dominar iloc y loc te permite filtrar filas, columnas o subconjuntos exactos dentro de un data frame. Aquí aprenderás cuándo usar cada método, cómo combinarlos con índices y etiquetas, y por qué fragmentar grandes volúmenes de datos es clave para proyectos reales.
¿Qué diferencia hay entre iloc y loc en Pandas?
La diferencia está en cómo accedes a la información. iloc trabaja por posición numérica (esa i viene de index), mientras que loc trabaja por etiqueta, es decir, el nombre de la fila o columna [01:00].
En ambos casos la notación es la misma: primero indicas filas y después columnas, separadas por una coma dentro de los corchetes.
¿Qué es iloc en Pandas? Es un selector que extrae filas y columnas usando su posición numérica dentro del data frame, empezando desde cero.
¿Qué es loc en Pandas? Es un selector que accede a los datos usando el nombre de la etiqueta de la fila o columna, no su posición.
¿Cómo usar iloc para extraer filas y columnas por índice?
Cuando quieres trabajar con posiciones, iloc es tu mejor aliado. Tanto filas como columnas inician en cero y terminan en el número total de datos menos uno.
Para extraer la primera fila del data frameretail_data, basta con indicar la posición:
El resultado muestra cada columna con la información correspondiente a esa fila [01:40].
¿Cómo seleccionar varias filas con iloc?
Para traer una porción del data frame, usa el operador de slicing. Recuerda que el límite final no se incluye:
retail_data.iloc[0:5] devuelve las primeras cinco filas.
retail_data.iloc[6:8] devuelve las filas en posición 6 y 7.
retail_data.iloc[:5] también funciona dejando vacío el inicio.
¿Cómo extraer un subset combinando filas y columnas?
Puedes pedir un bloque específico indicando ambos rangos:
python
subset = retail_data.iloc[0:3, 0:2]
Esto retorna las filas 0 a 2 y las columnas 0 y 1 [03:20]. Y si necesitas un único valor en una posición exacta, simplemente pasa los dos índices:
python
retail_value = retail_data.iloc[1, 2]
El resultado es el dato puntual ubicado en la fila 1, columna 2.
¿Cómo usar loc para seleccionar datos por etiqueta?
loc cambia la lógica: en lugar de posiciones, le pasas el nombre del índice o de la columna. Para extraer la fila con índice 3:
python
index_three = retail_data.loc[3]
A diferencia de iloc, cuando usas rangos con loc el valor final sí se incluye. Por ejemplo, retail_data.loc[0:4] devuelve cinco filas, de la 0 a la 4 [05:30].
¿Cómo seleccionar una columna completa con loc?
Para traer toda una columna por su nombre, indica todas las filas con : y la etiqueta exacta. Hay que respetar mayúsculas y minúsculas:
python
quantity = retail_data.loc[:, 'Quantity']
El resultado es la columna completa más metadata como el nombre y el total de registros.
¿Cómo seleccionar varias columnas con loc?
Cuando necesitas más de una columna, debes pasarlas como lista:
Esta sintaxis es importante porque Pandas espera una colección cuando consultas múltiples etiquetas [07:45].
¿Por qué fragmentar la información en proyectos reales?
El set de datos del ejemplo contiene más de 500.000 filas, y en proyectos empresariales este volumen suele crecer mucho más. Trabajar con todo el data frame a la vez vuelve lento cualquier análisis y dificulta encontrar lo que buscas.
Una buena práctica al iniciar un análisis es dividir la información en porciones pequeñas para:
Hacer limpieza de datos sobre subconjuntos manejables.
Responder preguntas específicas del proyecto sin sobrecargar memoria.
Validar hipótesis antes de aplicar transformaciones masivas.
Construir un portafolio con ejemplos claros y reproducibles.
Un ejercicio útil es practicar con tu propio dataset: extrae las primeras filas con iloc, filtra columnas clave con loc y combina ambos métodos hasta sentirte cómodo navegando cualquier data frame. ¿Qué dataset vas a explorar primero? Cuéntame en los comentarios.
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.
Si en una base de datos de clientes, yo quiero buscar un cliente por su identificacion, el ID es 10032342 en la columna ID, e imprimir sus datos de todas las columnas:
Para obtener un dato exacto (como el valor de una celda individual), debes proporcionar las coordenadas precisas de intersección entre la fila y la columna.
Si conoces la posición numérica exacta, puedes usar iloc pasando el índice de la fila seguido del índice de la columna. Por ejemplo: dataframe.iloc[0, 2] te devolverá el valor de la primera fila en la tercera columna. Si prefieres usar nombres, loc es tu mejor opción: dataframe.loc[5, 'Total_Ventas'] extraerá el valor exacto de esa columna para la fila con la etiqueta 5. Extraer valores únicos es extremadamente útil cuando necesitas capturar un dato específico para usarlo como variable dinámica en otra parte de tu código, como un umbral de precio máximo o el nombre del producto más vendido.
¿Cuándo debería usar iloc sobre loc?
Debes elegir iloc cuando tu lógica de negocio dependa estrictamente de la posición de los datos, sin importar cómo se llamen las columnas o cuál sea el identificador de la fila. Piensa en iloc como las coordenadas de una hoja de cálculo tradicional (fila 1, columna 2).
Por ejemplo, si necesitas extraer siempre las primeras 10 transacciones del día o la última columna de un reporte generado automáticamente (cuyo nombre cambia cada mes), iloc es la herramienta ideal porque ignora las etiquetas y se enfoca en el índice numérico (comenzando desde cero). En cambio, loc brilla cuando el nombre de la columna (como Precio o Cantidad) es el dato más importante para tu análisis, dándote un código mucho más legible y mantenible para otros analistas en tu equipo.
Comparativa rápida: loc vs iloc vs at/iat
loc → por etiqueta (filas/columnas). Slicing inclusivo. Ideal para filtros de negocio y asignación segura.
iloc → por posición (enteros). Slicing exclusivo. Ideal para lógica matricial.
at → etiqueta escalar (un valor). Más rápido que loc para un elemento.
iat → posición escalar (un valor). Más rápido que iloc para un elemento.
Son consultas (queries) sobre el DataFrame que permiten extraer información específica del dataset de ventas de Amazon.
iloc → consulta por posición numérica (filas y columnas como matriz).
loc → consulta por etiquetas o condiciones lógicas (filtros como precio, categoría, rating).
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
