Cómo iterar sobre cada fila de un archivo CSV utilizando un bucle for en Python

Aprender a manejar archivos CSV de manera eficiente en Python es importante para tareas como el análisis de datos y la creación de informes, entre otras aplicaciones. En particular, el uso de bucles for para iterar sobre cada fila permite manipular los datos CSV de manera intuitiva. En este artículo, se explicará detalladamente cómo utilizar la biblioteca estándar de Python csv, desde lo básico hasta métodos más eficientes de procesamiento. Esto permitirá comprender un enfoque adecuado para manejar grandes cantidades de datos.

Índice

Cómo abrir un archivo CSV en Python

El primer paso básico para trabajar con archivos CSV es abrir el archivo y cargar correctamente los datos. En Python, se usa la función estándar open para abrir archivos CSV.

Forma básica de abrir un archivo

Usando la función open de Python, puedes abrir un archivo CSV en modo solo lectura. El siguiente ejemplo muestra cómo abrir un archivo llamado example.csv.

with open('example.csv', mode='r', encoding='utf-8') as file:
    print(file.read())

Razón para usar la declaración with

El uso de la declaración with permite abrir y cerrar el archivo de manera segura, sin necesidad de llamar explícitamente a file.close(). Esto garantiza que el archivo se cierre correctamente incluso si ocurre un error, evitando así pérdidas de recursos.

Preparación para usar el módulo CSV

Una vez abierto el archivo, se puede utilizar el módulo csv para procesar su contenido. Este módulo proporciona funcionalidades para leer datos separados por comas de una manera más manejable. En los siguientes apartados, veremos ejemplos detallados de cómo utilizarlo.

Iteración básica con csv.reader

Usando el objeto reader del módulo csv, se puede iterar sobre un archivo CSV fila por fila. Este método es sencillo y permite obtener cada fila en forma de lista, lo que facilita el procesamiento de los datos.

Uso básico de csv.reader

El siguiente es un ejemplo básico de cómo leer un archivo CSV utilizando csv.reader.

import csv

# Abrir el archivo CSV
with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)  # Crear el lector csv
    for row in reader:  # Iterar sobre cada fila
        print(row)  # Mostrar cada fila como lista

Formato de los datos obtenidos

El row devuelto por csv.reader es una lista que contiene los datos de cada celda como cadenas de texto. Supongamos que tenemos el siguiente archivo CSV:

Name,Age,City
Alice,30,New York
Bob,25,Los Angeles

El resultado de la ejecución del código anterior sería:

['Name', 'Age', 'City']
['Alice', '30', 'New York']
['Bob', '25', 'Los Angeles']

Cómo omitir la primera fila (cabecera)

Si deseas omitir la primera fila (que suele ser la cabecera), puedes usar la función next():

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    next(reader)  # Omitir la fila de la cabecera
    for row in reader:
        print(row)

Puntos a tener en cuenta

Por defecto, csv.reader reconoce la coma (,) como delimitador. Si usas otro delimitador, debes especificarlo utilizando el argumento delimiter.
Cuando se manejen grandes volúmenes de datos, es importante ser consciente del uso de memoria y optimizar el procesamiento.

A continuación, veremos cómo obtener los valores de las columnas para realizar un procesamiento específico.

Cómo obtener y procesar los valores de las columnas

Usando csv.reader, puedes obtener cada fila como una lista y extraer fácilmente los valores de columnas específicas para su procesamiento. Este enfoque permite realizar un procesamiento más eficiente y enfocado en los datos que necesitas.

Ejemplo básico de extracción de una columna específica

El siguiente código muestra cómo extraer y procesar una columna específica (por ejemplo, la segunda columna):

import csv

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    next(reader)  # Omitir la cabecera
    for row in reader:
        # Obtener el valor de la segunda columna (índice 1)
        age = row[1]
        print(f"Age: {age}")

Por ejemplo, si tenemos el siguiente archivo CSV:

Name,Age,City
Alice,30,New York
Bob,25,Los Angeles

La ejecución de este código produciría la siguiente salida:

Age: 30  
Age: 25

Procesar varias columnas a la vez

Si deseas trabajar con varias columnas simultáneamente, puedes especificarlas utilizando los índices de las listas.

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    next(reader)  # Omitir la cabecera
    for row in reader:
        name = row[0]  # Primer columna
        city = row[2]  # Tercer columna
        print(f"{name} lives in {city}.")

Resultado:

Alice lives in New York.  
Bob lives in Los Angeles.

Añadir manejo de errores

Para hacer el código más robusto, es recomendable agregar manejo de errores en caso de que el archivo contenga datos incompletos o vacíos.

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    next(reader)  # Omitir la cabecera
    for row in reader:
        try:
            name = row[0]
            age = int(row[1])  # Obtener edad como número
            print(f"{name} is {age} years old.")
        except (IndexError, ValueError) as e:
            print(f"Error processing row: {row}, Error: {e}")

Ejemplos avanzados

Este método puede ser útil en escenarios prácticos como los siguientes:

Filtrar datos que cumplan con ciertos criterios (por ejemplo, mayores de 30 años).
Realizar cálculos sobre valores de columnas para generar nueva información.
Realizar estadísticas por columna (como sumas o promedios).

A continuación, explicaremos cómo usar csv.DictReader para trabajar con los datos de las columnas de manera más intuitiva.

Procesar datos de filas en formato diccionario con csv.DictReader

Usando csv.DictReader, puedes manejar cada fila de un archivo CSV como un diccionario. Esto te permite acceder a los datos usando los nombres de las columnas como claves, lo que elimina la necesidad de recordar los índices de las columnas y mejora la legibilidad del código.

Uso básico de csv.DictReader

El siguiente código muestra cómo procesar los datos de un archivo CSV usando csv.DictReader:

import csv

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.DictReader(file)
    for row in reader:
        # Acceder a los datos usando los nombres de las columnas
        name = row['Name']
        age = row['Age']
        city = row['City']
        print(f"{name} is {age} years old and lives in {city}.")

Por ejemplo, con el siguiente archivo CSV:

Name,Age,City
Alice,30,New York
Bob,25,Los Angeles

Al ejecutar este código, obtendrás la siguiente salida:

Alice is 30 years old and lives in New York.  
Bob is 25 years old and lives in Los Angeles.

Ventajas de usar los nombres de las columnas

Mejora de la legibilidad del código: Al usar los nombres de las columnas directamente, el código es más intuitivo y fácil de leer.
Flexibilidad: No es necesario modificar el código si cambia el orden de las columnas, siempre que los nombres de las columnas sigan siendo los mismos.

Detección automática de nombres de columnas

csv.DictReader usa automáticamente la primera fila como encabezado. También es posible personalizar los nombres de las columnas, como se muestra a continuación:

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.DictReader(file, fieldnames=['Name', 'Age', 'City'])  # Especificar nombres de columnas personalizados
    next(reader)  # Omitir la primera fila si es necesario
    for row in reader:
        print(row)

Manejo de datos faltantes

Cuando hay datos faltantes en un archivo CSV, el valor para la clave correspondiente será None. Es importante realizar las verificaciones necesarias para evitar errores.

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.DictReader(file)
    for row in reader:
        name = row.get('Name', 'Unknown')  # Establecer valor predeterminado
        age = row.get('Age', 'N/A')
        print(f"Name: {name}, Age: {age}")

Ejemplos avanzados

Filtrado de datos: Seleccionar filas que cumplan con ciertos criterios.
Conversión a JSON: Convertir datos en formato diccionario directamente a JSON.
Procesamiento estadístico: Realizar operaciones de agregación basadas en los nombres de las columnas.

A continuación, veremos algunos detalles sobre la codificación de archivos CSV y cómo manejarla correctamente.

Consideraciones sobre la codificación de archivos CSV

Cuando trabajas con archivos CSV en Python, es crucial especificar correctamente la codificación para evitar problemas con caracteres corruptos o fallos al leer el archivo. En esta sección, se abordan las principales consideraciones sobre la codificación y cómo evitar problemas comunes.

Formatos de codificación comunes

Los siguientes son formatos de codificación que se utilizan comúnmente para archivos CSV:

UTF-8: Usado internacionalmente y compatible con varios idiomas. Es la codificación estándar en Python.
Shift_JIS: Comúnmente usado en Japón, pero puede causar problemas con algunos caracteres especiales.
ISO-8859-1: Usado en idiomas de Europa occidental.

Especificación de codificación

Al usar la función open de Python, puedes especificar la codificación con el argumento encoding.

with open('example.csv', mode='r', encoding='utf-8') as file:
    print(file.read())

Si el archivo está codificado en Shift_JIS, puedes especificarlo así:

with open('example.csv', mode='r', encoding='shift_jis') as file:
    print(file.read())

Manejo de errores de codificación

Cuando ocurre un error debido a una codificación incorrecta, puedes usar los siguientes métodos para manejarlo adecuadamente.

Uso del argumento `errors` para ignorar o reemplazar

El argumento errors controla el comportamiento en caso de errores de codificación.

with open('example.csv', mode='r', encoding='utf-8', errors='ignore') as file:
    print(file.read())  # Ignorar errores

with open('example.csv', mode='r', encoding='utf-8', errors='replace') as file:
    print(file.read())  # Reemplazar caracteres no válidos

Detectar automáticamente la codificación

Si no conoces la codificación del archivo, puedes utilizar bibliotecas como chardet o charset-normalizer para detectarla.

import chardet

# Detectar la codificación
with open('example.csv', mode='rb') as file:
    result = chardet.detect(file.read())
    print(result['encoding'])

Puntos clave para un manejo eficiente de la codificación

Verificación previa: Verifica la codificación del archivo CSV y especifica el formato adecuado.
Estandarización: Si es posible, utiliza UTF-8 para mantener la coherencia.
Manejo de errores: Utiliza el argumento errors y bibliotecas para manejar errores inesperados.

A continuación, explicaremos cómo manejar grandes archivos CSV de manera eficiente.

Cómo manejar grandes archivos CSV de manera eficiente

Cuando se trabaja con archivos CSV de gran tamaño, es importante adoptar técnicas eficientes para evitar problemas de memoria o tiempo de procesamiento. Python ofrece diversas técnicas para manejar archivos CSV grandes.

Leer por filas para ahorrar memoria

Usando csv.reader o csv.DictReader, puedes leer un archivo CSV fila por fila. Esto te permite procesar el archivo sin cargarlo completo en memoria, lo cual es útil para grandes volúmenes de datos.

import csv

with open('large_file.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    for row in reader:
        # Procesar cada fila
        print(row)

Este método permite procesar archivos de cualquier tamaño sin que el tamaño del archivo afecte el rendimiento.

Uso de procesamiento por lotes

Otra estrategia eficiente es dividir el archivo CSV en lotes y procesar un número fijo de filas a la vez. Aquí tienes un ejemplo usando itertools.islice:

import csv
from itertools import islice

with open('large_file.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    while True:
        batch = list(islice(reader, 100))  # Leer 100 filas a la vez
        if not batch:
            break
        # Procesar el lote
        for row in batch:
            print(row)

Uso de pandas para procesamiento por lotes

La biblioteca pandas de Python es excelente para procesar grandes conjuntos de datos. Puedes usar el argumento chunksize para dividir el procesamiento en bloques.

import pandas as pd

for chunk in pd.read_csv('large_file.csv', chunksize=1000, encoding='utf-8'):
    # Procesar cada bloque
    print(chunk)

Este enfoque es útil cuando necesitas realizar análisis eficientes de grandes conjuntos de datos.

Uso de procesamiento paralelo

Dividiendo el archivo en partes y procesándolas en paralelo, puedes mejorar la velocidad de procesamiento. Aquí tienes un ejemplo usando el módulo multiprocessing:

import csv
from multiprocessing import Pool

def process_chunk(chunk):
    for row in chunk:
        print(row)

def split_file(filename, chunk_size=1000):
    with open(filename, mode='r', encoding='utf-8') as file:
        reader = csv.reader(file)
        batch = []
        for i, row in enumerate(reader):
            batch.append(row)
            if (i + 1) % chunk_size == 0:
                yield batch
                batch = []
        if batch:
            yield batch

if __name__ == "__main__":
    filename = 'large_file.csv'
    with Pool(4) as pool:  # Procesamiento paralelo con 4 procesos
        pool.map(process_chunk, split_file(filename))

Elección de formatos de datos eficientes

Si bien CSV es un formato sencillo y útil, para grandes volúmenes de datos, considera otros formatos como Parquet o Feather, que ofrecen mejores tasas de compresión y velocidad de lectura.

Ejemplo práctico: Filtrar y guardar datos

Este ejemplo muestra cómo filtrar datos que cumplen ciertos criterios y guardarlos en un nuevo archivo:

import csv

with open('large_file.csv', mode='r', encoding='utf-8') as infile, \
     open('filtered_file.csv', mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)
    for row in reader:
        if int(row[1]) > 50:  # Condición: el valor en la segunda columna es mayor a 50
            writer.writerow(row)

A continuación, exploraremos cómo usar la declaración with para realizar operaciones de archivos de manera segura.

Operaciones seguras con archivos utilizando la declaración with

Al trabajar con archivos en Python, el uso de la declaración with garantiza que los archivos se abran y cierren de manera segura, lo que facilita la gestión de recursos. Esto es particularmente útil cuando se manejan archivos CSV, ya que garantiza que los archivos se cierren correctamente incluso si ocurre un error.

Ejemplo básico con la declaración with

El siguiente ejemplo muestra cómo leer un archivo CSV utilizando la declaración with:

import csv

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)

Cuando el bloque with termine, el objeto file se cerrará automáticamente, lo que evita que olvides cerrarlo explícitamente y simplifica el código.

Uso al escribir archivos

También puedes usar with para escribir datos en un archivo CSV de manera segura:

import csv

data = [
    ['Name', 'Age', 'City'],
    ['Alice', '30', 'New York'],
    ['Bob', '25', 'Los Angeles']
]

with open('output.csv', mode='w', encoding='utf-8', newline='') as file:
    writer = csv.writer(file)
    writer.writerows(data)

Ventajas de usar with

Gestión simplificada de recursos
Incluso si ocurre un error durante la operación, los archivos se cierran automáticamente al salir del bloque with.
Mejora de la legibilidad
No es necesario abrir y cerrar los archivos explícitamente, lo que hace que el código sea más limpio y fácil de entender.
Prevención de errores
Evita fugas de recursos (como el uso excesivo de memoria) al asegurarse de que los archivos se cierren correctamente.

Operar múltiples archivos simultáneamente

Con with, también puedes trabajar de manera segura con varios archivos a la vez:

import csv

with open('input.csv', mode='r', encoding='utf-8') as infile, \
     open('output.csv', mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)
    for row in reader:
        writer.writerow(row)

Riesgos de no usar with

Si no utilizas with, puedes olvidar cerrar el archivo, lo que puede causar fugas de recursos.

file = open('example.csv', mode='r', encoding='utf-8')
reader = csv.reader(file)
for row in reader:
    print(row)
file.close()

Este enfoque puede causar problemas, especialmente en aplicaciones grandes o servidores, donde los archivos no se cierran correctamente.

Ejemplo práctico: Filtrar datos y guardarlos

Este ejemplo muestra cómo usar with para filtrar datos de un archivo CSV y guardarlos en un nuevo archivo:

import csv

with open('input.csv', mode='r', encoding='utf-8') as infile, \
     open('filtered_output.csv', mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)
    for row in reader:
        if row[1] == '30':  # Condición: Filtrar filas con valor '30' en la segunda columna
            writer.writerow(row)

En el siguiente artículo, veremos cómo extraer columnas específicas y guardarlas en un nuevo archivo CSV.

Ejemplo práctico: Extraer columnas específicas y guardarlas

En este artículo, veremos cómo extraer columnas específicas de un archivo CSV y guardarlas en un nuevo archivo. Esta es una tarea común en el procesamiento de datos.

Ejemplo básico de extracción de columnas

El siguiente código muestra cómo extraer columnas específicas (por ejemplo, nombre y edad) y guardarlas en un nuevo archivo CSV:

import csv

# Ruta de archivos de entrada y salida
input_file = 'input.csv'
output_file = 'output.csv'

with open(input_file, mode='r', encoding='utf-8') as infile, \
     open(output_file, mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)

    # Procesar encabezados (extraer columnas específicas)
    header = next(reader)
    selected_columns = [0, 1]  # Columnas a extraer (por ejemplo: primera y segunda columna)
    writer.writerow([header[i] for i in selected_columns])

    # Extraer y escribir las columnas seleccionadas
    for row in reader:
        writer.writerow([row[i] for i in selected_columns])

Ejemplo: Contenido del archivo de entrada

Contenido del archivo de entrada input.csv:

Name,Age,City,Country
Alice,30,New York,USA
Bob,25,Los Angeles,USA
Charlie,35,London,UK

Al ejecutar el código, el archivo de salida output.csv contendrá lo siguiente:

Name,Age
Alice,30
Bob,25
Charlie,35

Extracción dinámica de columnas

También es útil extraer columnas dinámicamente usando los nombres de las columnas. Este enfoque facilita la adaptación al cambio de estructura del archivo.

with open(input_file, mode='r', encoding='utf-8') as infile, \
     open(output_file, mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.DictReader(infile)
    writer = csv.writer(outfile)

    # Columnas a extraer
    columns_to_extract = ['Name', 'City']
    writer.writerow(columns_to_extract)

    # Extraer y escribir las columnas especificadas
    for row in reader:
        writer.writerow([row[col] for col in columns_to_extract])

Extracción condicional de columnas

También puedes extraer solo los datos que cumplen con condiciones específicas.

with open(input_file, mode='r', encoding='utf-8') as infile, \
     open(output_file, mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.DictReader(infile)
    writer = csv.DictWriter(outfile, fieldnames=['Name', 'City'])
    writer.writeheader()

    for row in reader:
        if int(row['Age']) > 30:  # Extraer solo los datos con edad mayor a 30
            writer.writerow({'Name': row['Name'], 'City': row['City']})

El archivo de salida tendrá el siguiente contenido:

Name,City
Charlie,London

Ejemplos avanzados

Análisis de datos: Filtrar y preparar datos para análisis y agregaciones.
Conversión de datos: Extraer datos y convertirlos a otros formatos.
Creación de informes eficientes: Extraer información clave de grandes conjuntos de datos y generar informes.

En el siguiente apartado, resumiremos los puntos clave tratados en este artículo.

Resumen

En este artículo, se explicaron varias formas de procesar archivos CSV en Python, desde la iteración básica de filas usando csv.reader hasta el procesamiento más avanzado usando csv.DictReader. También cubrimos la extracción de columnas específicas, cómo manejar grandes archivos CSV y el uso de técnicas eficientes como el procesamiento paralelo. Además, discutimos la importancia de la codificación y cómo usar la declaración with para manejar archivos de manera segura y eficiente.

Con estos conocimientos, podrás realizar tareas de análisis de datos y procesamiento de datos ETL de manera más eficiente, aprovechando la flexibilidad de Python para manejar datos CSV de forma ágil y sin problemas.