No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Uso de iloc y loc en Pandas

15/32
Recursos

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:

  1. 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)
    
    
  2. Seleccionar múltiples filas:

    
    # Seleccionar las primeras cinco filas
    primeras_cinco_filas = retail_data.iloc[:5]
    print("Primeras cinco filas:\n", primeras_cinco_filas)
    
    
  3. 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)
    
    
  4. 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:

  1. 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)
    
    
  2. 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.

  3. Seleccionar una columna específica por su nombre:

    
    # Seleccionar la columna 'Quantity'
    columna_quantity = retail_data.loc[:, 'Quantity']
    print("Columna 'Quantity':\n", columna_quantity.head())
    
    
  4. Seleccionar múltiples columnas por sus nombres:

    
    # Seleccionar las columnas 'Quantity' y 'UnitPrice'
    columnas_quantity_unitprice = retail_data.loc[:, ['Quantity', 'UnitPrice']]
    print("Columnas 'Quantity' y 'UnitPrice':\n", columnas_quantity_unitprice.head())
    
    
  5. 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

  1. 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.
  2. Inclusión del Último Índice:
    • iloc: excluye el último índice en un rango.
    • loc: incluye el último índice en un rango.

Ejercicio Práctico

  1. 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’.
  2. 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())

Aportes 13

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

### **Diferencias Principales Entre** `iloc` **y** `loc`: ### 1. **Índices vs. Etiquetas**: * `iloc`: Se basa en la posición (número de índice). * `loc`: Se basa en las etiquetas de los índices. 2. **Inclusividad en Slicing**: * `iloc`: Excluye el índice final en el slicing (similar a las listas en Python). * `loc`: Incluye tanto el inicio como el final en el slicing. 3. **Compatibilidad con Booleanos**: * `loc` permite la selección de filas o columnas utilizando condiciones booleanas, lo cual no es posible con `iloc`.
📝 Mis apuntes de la clase La funcionalidad **iloc** esta basada en el acceso a datos mediante la posición numérica de las filas o columnas de un DataFrame. **iloc** sigue las reglas de indexación, esto quiere decir que el primer índice es el 0. 📌 **Nota**: En el caso de una serie solo podemos acceder a las filas. Sintaxis: `data_df.iloc[filas, columnas]`. Donde: * **filas**: Una sola posición, un array con las posiciones numéricas o un slicing con la sintaxis * **columnas**: Una sola posición, un array con las posiciones numéricas de las columnas o bien un slicing. Sintaxis de slicing en **iloc** aplica tanto para las filas como para las columnas `[posicion_inicial : posicion_final : saltos]` Ejemplos: ```python print("Fila 5:") row_5 = retail_df.iloc[5] print(row_5) print(type(row_5)) print("Fila 5, columnas 2 y 3:") row_5_cols_2_3 = retail_df.iloc[5, [2,3]] print(row_5_cols_2_3) print(type(row_5_cols_2_3)) print("Filas 8,5,6,2:") rows_8562 = retail_df.iloc[[8,5,6,2]] print(type(rows_8562)) display(rows_8562) print("Filas 8,5,6,2 y columnas 1, 4, 6:") rows_8562_cols_146 = retail_df.iloc[[8,5,6,2], [1, 4, 6]] print(type(rows_8562_cols_146)) display(rows_8562_cols_146) ``` ***loc*** 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]` ```python 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💚
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 8\) Acceso a Múltiples Columnas con loc: quantity\_unitprices\_column = retail\_data.loc\[:, \['Quantity', 'UnitPrice']] print(quantity\_unitprices\_column) Descripción: Obtiene y muestra las columnas Quantity y UnitPrice para todas las filas.
Encontré este video, la verdad está increíblemente explicado muy claro todo: <https://youtu.be/0MEoGE1Cd04?si=MK3fHQ9CXEiHF5SM> 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.
**<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.
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](https://monica.im/s/DPYJZkyOJZ) * **📊 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](https://builtin.com/software-engineering-perspectives/pandas-iloc) * **📈 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.
***Poner condiciones a cierta cantidad de Filas con iloc y loc.*** ![](https://static.platzi.com/media/user_upload/code_loc-aead5d92-e663-4f8b-82a3-017eb32d7c8b.jpg)
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`: ```python 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`: ```python 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`: ```python 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`: ```python \# Seleccionar la fila con índice 0 (la primera fila) print(df.loc\[0]) \# Seleccionar la fila donde el índice es 1 print(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: ```python \# 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: ```python \# Seleccionar la primera fila (índice 0) y la columna 'Nombre' df.loc\[0, 'Nombre'] # Resultado: 'Ana' ``` \#### Seleccionar un subconjunto con `iloc` y `loc`: ```python \# 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 ```js poland_unit_prices = retail_data.loc[retail_data['Country'] == 'Poland', ['Country', 'UnitPrice']] poland_unit_prices ``````js Country UnitPrice 6608 Poland 2.55 6609 Poland 1.25 6610 Poland 1.45 6611 Poland 1.49 6612 Poland 0.85 6613 Poland 8.50 6614 Poland 1.45 6615 Poland 1.45 ```
Reto o sugerencia de la lección: dividir en bloques más pequeños para poder hacer el preprocesamiento: ```js import numpy as np print(retail_data.shape) # Dividir en bloques más pequeños block_size = 100000 for i in range(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 for print(block) # Muestra las primeras 5 y las últimas 5 filas (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.
![](https://static.platzi.com/media/user_upload/image-ff3e8072-a5a4-4def-9314-8aaae5b0bcfa.jpg)
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!