Python
Dominando .loc en Python: Guía para principiantes

Dominando .loc en Python: Guía para principiantes

MoeNagy Dev

Entendiendo el accesor .loc

¿Qué es el accesor .loc?

El accesor .loc en pandas es una herramienta poderosa para seleccionar y acceder a datos en un DataFrame o Serie basado en las etiquetas de fila y columna. Te permite seleccionar datos especificando explícitamente las etiquetas de fila y columna, en lugar de utilizar índices numéricos como con el accesor .iloc.

Acceso a datos utilizando etiquetas de fila y columna

Para acceder a datos utilizando el accesor .loc, debes proporcionar las etiquetas de fila y columna como argumentos. Aquí tienes un ejemplo básico:

import pandas as pd
 
# Crear un DataFrame de ejemplo
df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
                   'B': [10, 20, 30, 40, 50]},
                  index=['fila1', 'fila2', 'fila3', 'fila4', 'fila5'])
 
# Acceder a un único elemento
print(df.loc['fila2', 'B'])  # Salida: 20
 
# Acceder a una fila
print(df.loc['fila3'])
# Salida:
# A    3
# B   30
# Name: fila3, dtype: int64
 
# Acceder a una columna
print(df.loc[:, 'A'])
# Salida:
# fila1    1
# fila2    2
# fila3    3
# fila4    4
# fila5    5
# Name: A, dtype: int64

En el ejemplo anterior, creamos un DataFrame de ejemplo con etiquetas de fila 'fila1' a 'fila5' y etiquetas de columna 'A' y 'B'. Luego demostramos cómo usar el accesor .loc para seleccionar un único elemento, una fila completa y una columna completa.

Selección de elementos individuales, filas y columnas

El accesor .loc te permite seleccionar elementos individuales, filas y columnas proporcionando las etiquetas apropiadas. Aquí tienes algunos ejemplos:

# Seleccionar un único elemento
print(df.loc['fila2', 'B'])  # Salida: 20
 
# Seleccionar una fila
print(df.loc['fila3'])
# Salida:
# A    3
# B   30
# Name: fila3, dtype: int64
 
# Seleccionar una columna
print(df.loc[:, 'A'])
# Salida:
# fila1    1
# fila2    2
# fila3    3
# fila4    4
# fila5    5
# Name: A, dtype: int64

Selección de múltiples filas y columnas

También puedes usar el accesor .loc para seleccionar múltiples filas y columnas proporcionando una lista o un rango de etiquetas:

# Seleccionar múltiples filas
print(df.loc[['fila2', 'fila4']])
#    A   B
# fila2  2  20
# fila4  4  40
 
# Seleccionar múltiples columnas
print(df.loc[:, ['A', 'B']])
#        A   B
# fila1  1  10
# fila2  2  20
# fila3  3  30
# fila4  4  40
# fila5  5  50
 
# Seleccionar un rango de filas
print(df.loc['fila2':'fila4'])
#        A   B
# fila2  2  20
# fila3  3  30
# fila4  4  40

En los ejemplos anteriores, demostramos cómo seleccionar múltiples filas y columnas utilizando listas o rangos de etiquetas.

Selecciones condicionales con .loc

Filtrado de filas y columnas basado en condiciones

El accesor .loc también se puede utilizar para filtrar filas y columnas en función de condiciones específicas. Esto es particularmente útil cuando necesitas seleccionar datos que cumplan ciertos criterios.

# Filtrar filas basado en una condición
print(df.loc[df['A'] > 3])
#        A   B
# fila4  4  40
# fila5  5  50
 
# Filtrar columnas basado en una condición
print(df.loc[:, df.columns.str.startswith('A')])
#        A
# fila1  1
# fila2  2
# fila3  3
# fila4  4
# fila5  5

En el primer ejemplo, filtramos el DataFrame para incluir solo las filas donde el valor en la columna 'A' es mayor que 3. En el segundo ejemplo, filtramos el DataFrame para incluir solo las columnas cuyos nombres comienzan con 'A'.

Combinación de múltiples condiciones utilizando operadores booleanos

También puedes combinar múltiples condiciones utilizando operadores booleanos como & (y) y | (o) para crear filtros más complejos.

# Combinar múltiples condiciones utilizando operadores booleanos
print(df.loc[(df['A'] > 2) & (df['B'] < 40)])
#        A   B
# fila3  3  30

En este ejemplo, seleccionamos las filas donde el valor en la columna 'A' es mayor que 2 y el valor en la columna 'B' es menor que 40.

Selección de filas y columnas basada en condiciones complejas

El accesor .loc te permite crear condiciones complejas combinando múltiples filtros y utilizando operadores booleanos. Esto puede ser particularmente útil cuando necesitas realizar una selección y extracción de datos más avanzada.

# Seleccionar filas y columnas basadas en condiciones complejas
print(df.loc[(df['A'] > 2) & (df['B'] < 40), ['A', 'B']])
#        A   B
# fila3  3  30

En este ejemplo, seleccionamos las filas donde el valor en la columna 'A' es mayor que 2 y el valor en la columna 'B' es menor que 40, y solo devolvemos las columnas 'A' y 'B'.

Modificación de datos con .loc

Asignación de valores a elementos específicos

El accesor .loc también se puede utilizar para asignar valores a elementos específicos en un DataFrame o Serie.

# Asignar un valor a un elemento específico
df.loc['fila2', 'B'] = 25
print(df)
#        A   B
# fila1   1  10
# fila2   2  25
# fila3   3  30
# fila4   4  40
# fila5   5  50

En este ejemplo, usamos el accesor .loc para asignar el valor 25 al elemento en la fila 'fila2' y columna 'B'.

Actualización de múltiples filas y columnas

También puedes usar el accesor .loc para actualizar múltiples filas y columnas a la vez.

# Actualizar múltiples filas y columnas
df.loc[['fila2', 'fila4'], ['A', 'B']] = [[12, 125], [42, 420]]
print(df)
#         A    B
# fila1    1   10
# fila2   12  125
# fila3    3   30
# fila4   42  420
# fila5    5   50

En este ejemplo, usamos el accesor .loc para actualizar los valores en las columnas 'A' y 'B' para las filas 'fila2' y 'fila4'.

Manejo de datos faltantes con .loc

El accesor .loc también se puede utilizar para manejar datos faltantes en un DataFrame o Serie.

# Crear un DataFrame con datos faltantes
df = pd.DataFrame({'A': [1, 2, None, 4, 5],
                   'B': [10, 20, 30, None, 50]},
                  index=['fila1', 'fila2', 'fila3', 'fila4', 'fila5'])
 
# Rellenar valores faltantes usando .loc
df.loc[:, 'A'] = df['A'].fillna(0)

title: Manipulación de Datos con .loc en pandas language: es

El método .loc se utiliza para acceder y manipular datos en un DataFrame de pandas.

En este ejemplo, creamos un DataFrame con valores faltantes en las columnas 'A' y 'B'. Luego, utilizamos el accesor .loc para rellenar los valores faltantes con 0 en ambas columnas.

Técnicas Avanzadas con .loc

Encadenamiento de .loc con otras operaciones de pandas

El accesor .loc se puede encadenar con otras operaciones de pandas para crear flujos de trabajo más complejos de selección y manipulación de datos.

# Encadenar .loc con otras operaciones de pandas
filtered_df = df.loc[(df['A'] > 2) & (df['B'] < 40), ['A', 'B']]
filtered_df['C'] = filtered_df['A'] + filtered_df['B']
print(filtered_df)
#        A   B   C
# row3   3  30  33

En este ejemplo, primero usamos el accesor .loc para filtrar el DataFrame en base a una condición, y luego creamos una nueva columna 'C' que es la suma de las columnas 'A' y 'B' para las filas filtradas.

Manejo de índices jerárquicos (de varios niveles)

El accesor .loc también se puede usar para trabajar con DataFrames o Series que tienen índices jerárquicos (de varios niveles).

# Crear un DataFrame con un índice de varios niveles
df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
                   'B': [10, 20, 30, 40, 50]},
                  index=pd.MultiIndex.from_tuples([('group1', 'row1'), ('group1', 'row2'),
                                                  ('group2', 'row1'), ('group2', 'row2'),
                                                  ('group2', 'row3')],
                                                 names=['group', 'row']))
 
# Acceder a los datos usando .loc con índices de varios niveles
print(df.loc[('group2', 'row1'), 'A'])  # Salida: 3
print(df.loc[('group1', slice(None)), 'B'])
# Salida:
# ('group1', 'row1')    10
# ('group1', 'row2')    20
# Name: B, dtype: int64

En este ejemplo, creamos un DataFrame con un índice de varios niveles, y luego demostramos cómo usar el accesor .loc para seleccionar datos basados en el índice jerárquico.

Combinación de .loc con otros accesorios de pandas (por ejemplo, .at, .iat)

El accesor .loc se puede combinar con otros accesorios de pandas, como .at y .iat, para proporcionar un acceso de datos más preciso y eficiente.

# Combinar .loc con .at y .iat
print(df.at[('group2', 'row1'), 'A'])  # Salida: 3
print(df.iat[2, 0])  # Salida: 3

En este ejemplo, usamos el accesor .at para seleccionar un único elemento basado en las etiquetas de fila y columna, y el accesor .iat para seleccionar un único elemento basado en las posiciones enteras de fila y columna.

Consideraciones de rendimiento con .loc

Comprender la eficiencia de .loc

El accesor .loc es generalmente más eficiente que el uso de la indexación booleana o la indexación basada en enteros (.iloc) para conjuntos de datos grandes, ya que evita cálculos innecesarios y copias de datos.

# Comparación de .loc, .iloc e indexación booleana
import pandas as pd
import numpy as np
 
# Crear un DataFrame grande
df = pd.DataFrame(np.random.rand(1000000, 5), columns=['A', 'B', 'C', 'D', 'E'])
 
# Comparación de tiempo
%timeit df.loc[df['A'] > 0.5, ['B', 'C']]
%timeit df.iloc[df['A'] > 0.5, [1, 2]]
%timeit df[(df['A'] > 0.5) & (df['B'] < 0.7)]

En este ejemplo, creamos un DataFrame grande y comparamos el rendimiento de usar .loc, .iloc e indexación booleana para seleccionar un subconjunto de filas y columnas. El accesor .loc es generalmente el más eficiente de los tres métodos.

Comparación de .loc con otros métodos de selección (por ejemplo, .iloc, indexación booleana)

Si bien el accesor .loc es generalmente eficiente, puede haber casos en los que otros métodos de selección, como .iloc o indexación booleana, puedan ser más apropiados dependiendo de su caso de uso específico y estructura de datos.

# Comparación de .loc, .iloc e indexación booleana
# Cuándo usar cada método
# .loc: Cuando tiene datos etiquetados y desea seleccionar en base a las etiquetas
# .iloc: Cuando tiene índices numéricos y desea seleccionar en base a la posición
# Indexación booleana: Cuando desea filtrar datos en base a condiciones complejas

Es importante comprender los compromisos y elegir el método de selección adecuado para sus necesidades específicas.

Listas y Tuplas

Las listas y las tuplas son tipos de secuencias en Python, pero tienen algunas diferencias clave. Las listas son mutables, lo que significa que se pueden cambiar sus elementos, mientras que las tuplas son inmutables, lo que significa que sus elementos no se pueden cambiar.

Listas

Las listas se definen usando corchetes []. Aquí tienes un ejemplo:

fruits = ['manzana', 'banana', 'cereza']

Puedes acceder a elementos individuales de una lista usando su índice, que comienza desde 0:

print(fruits[0])  # Salida: 'manzana'
print(fruits[1])  # Salida: 'banana'

También puedes modificar elementos en una lista:

fruits[1] = 'naranja'
print(fruits)  # Salida: ['manzana', 'naranja', 'cereza']

Las listas tienen muchos métodos útiles, como append(), insert(), remove() y pop(). Aquí tienes un ejemplo:

fruits.append('uva')
fruits.insert(1, 'pera')
fruits.remove('naranja')
last_fruit = fruits.pop()
print(fruits)  # Salida: ['manzana', 'pera', 'cereza']
print(last_fruit)  # Salida: 'uva'

Tuplas

Las tuplas se definen usando paréntesis (). Aquí tienes un ejemplo:

point = (3, 4)

Puedes acceder a elementos individuales de una tupla usando su índice, al igual que con las listas:

print(point[0])  # Salida: 3
print(point[1])  # Salida: 4

Sin embargo, no puedes modificar los elementos de una tupla:

point[0] = 5  # TypeError: 'tuple' object does not support item assignment

Las tuplas se utilizan often para representar datos inmutables, como coordenadas o pares clave-valor.

Diccionarios

Los diccionarios son otra estructura de datos importante en Python. Se utilizan para almacenar pares clave-valor, donde las claves son únicas y los valores pueden ser de cualquier tipo de datos.

Los diccionarios se definen usando llaves {} y los pares clave-valor se separan con dos puntos :.

person = {
    'nombre': 'Juan Pérez',
    'edad': 35,
---
language: es
---
 
# Diccionarios, declaraciones condicionales, bucles, funciones, módulos y paquetes en Python
 
En este tutorial, aprenderás sobre los siguientes conceptos clave en Python:
 
## Diccionarios
Los diccionarios son estructuras de datos que almacenan pares clave-valor. Puedes acceder a los valores en un diccionario utilizando sus claves.
 
Puedes agregar, modificar y eliminar pares clave-valor en un diccionario. Los diccionarios tienen muchos métodos útiles, como "keys()", "values()" y "items()", que te permiten trabajar con las claves y valores en el diccionario.
 
Los diccionarios son muy versátiles y se pueden utilizar para almacenar estructuras de datos complejas, como diccionarios anidados o listas de diccionarios.
 
## Declaraciones condicionales
Las declaraciones condicionales en Python te permiten ejecutar diferentes bloques de código en función de ciertas condiciones. La declaración condicional más común es la declaración "if-elif-else".
 
También puedes utilizar los operadores "and", "or" y "not" para combinar múltiples condiciones. Otra declaración condicional útil es el operador ternario, que te permite escribir una declaración if-else en una sola línea.
 
Las declaraciones condicionales son esenciales para construir lógica compleja en tus programas de Python.
 
## Bucles
Los bucles en Python te permiten ejecutar un bloque de código repetidamente hasta que se cumpla una cierta condición. El bucle más común es el bucle "for", que se utiliza para iterar sobre una secuencia.
 
También puedes utilizar la función "range()" para crear una secuencia de números para iterar. El bucle "while" se utiliza cuando no conoces el número de iteraciones de antemano.
 
Puedes utilizar las declaraciones "break" y "continue" para controlar el flujo de un bucle.
 
Los bucles son esenciales para automatizar tareas repetitivas y procesar grandes cantidades de datos en tus programas de Python.
 
## Funciones
Las funciones en Python son bloques de código reutilizables que realizan una tarea específica. Te permiten organizar tu código y hacerlo más modular y mantenible.
 
Las funciones pueden tener argumentos y devolver valores. También puedes definir valores predeterminados para los argumentos de función.
 
Las funciones también pueden definirse con un número variable de argumentos utilizando la sintaxis "*args" y "**kwargs".
 
Las funciones son fundamentales para la programación en Python y son esenciales para crear código modular, reutilizable y mantenible.
 
## Módulos y Paquetes
En Python, los módulos y paquetes se utilizan para organizar y distribuir código.
 
Un módulo es un solo archivo de Python que contiene definiciones y declaraciones. Puedes importar un módulo utilizando la palabra clave "import". También puedes importar funciones o variables específicas de un módulo.
 
Los paquetes son colecciones de módulos relacionados. Se organizan en una estructura de directorios jerárquica, donde cada directorio contiene un archivo "__init__.py".
 
Los módulos y paquetes son esenciales para organizar y distribuir código de Python, ya que te permiten crear un código reutilizable y mantenible que se puede compartir con otros.
 
## Conclusión
En este tutorial, has aprendido sobre los siguientes conceptos clave en Python:
 
- Listas y Tuplas: Tipos de secuencia para almacenar colecciones de datos.
- Diccionarios: Estructuras de datos para almacenar pares clave-valor.
- Declaraciones condicionales: Ejecución de código en función de condiciones.
- Bucles: Repetición de bloques de código.
- Funciones: Bloques de código reutilizables que realizan tareas específicas.
- Módulos y Paquetes: Organización y distribución de código de Python.
Estos conceptos son fundamentales para la programación en Python y servirán como una base sólida para construir aplicaciones más complejas. Recuerda practicar y experimentar con estos conceptos para profundizar tu comprensión y convertirte en un programador de Python más competente.
 
[![MoeNagy Dev](https://raw.githubusercontent.com/lynn-mikami/Images/main/moenagy-dev.png)](/)