Tipos de Archivos

Python soporta el trabajo con diversos tipos de archivos, cada uno con sus características y usos específicos. A continuación te explico los principales:

Archivos de Texto

Qué son: Archivos que contienen datos legibles por humanos, codificados como caracteres (ASCII, UTF-8, etc.).

Cómo funcionan: Se abren con el modo r (lectura) o w (escritura).

Cada línea termina con un carácter de nueva línea \n. Pueden leerse línea por línea o todo el contenido a la vez

Ejemplo:

# Escritura
with open('ejemplo.txt', 'w', encoding='utf-8') as f:
    f.write("Línea 1\nLínea 2\n")

# Lectura
with open('ejemplo.txt', 'r', encoding='utf-8') as f:
    contenido = f.read()
print(contenido)

Archivos Binarios

Qué son: Archivos que contienen datos en formato binario (no legibles directamente por humanos).

Cómo funcionan: Se abren con el modo rb (lectura binaria) o wb (escritura binaria).

Se leen y escriben bytes en lugar de strings que son usados para imágenes, ejecutables, datos serializados, etc.

Ejemplo:

# Copiar un archivo binario
with open('imagen.jpg', 'rb') as origen:
    with open('copia.jpg', 'wb') as destino:
        destino.write(origen.read())

Archivos CSV (Comma-Separated Values)

Qué son: Archivos de texto que almacenan datos tabulares con valores separados por comas (u otros delimitadores).

Cómo funcionan: Cada línea representa una fila, los valores de cada columna se separan por comas (o puntos y comas, tabs, etc.). La primera línea puede contener los nombres de las columnas (cabecera).

Ejemplo (usando el módulo csv):

import csv

# Escritura
with open('datos.csv', 'w', newline='') as f:
    writer = csv.writer(f)
    writer.writerow(['Nombre', 'Edad', 'Ciudad'])
    writer.writerow(['Ana', 28, 'Madrid'])
    writer.writerow(['Juan', 32, 'Barcelona'])

# Lectura
with open('datos.csv', 'r') as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

Archivos JSON (JavaScript Object Notation)

Qué son: Formato de texto ligero para intercambio de datos, basado en la sintaxis de objetos de JavaScript.

Cómo funcionan: Almacena datos como pares clave-valor que soporta tipos de datos: strings, números, booleanos, arrays, objetos y null y son muy usado en APIs web y configuración

Ejemplo (usando el módulo json):

import json

# Datos a guardar
datos = {
    "nombre": "Carlos",
    "edad": 35,
    "hobbies": ["fútbol", "lectura", "viajar"],
    "activo": True
}

# Escritura
with open('datos.json', 'w') as f:
    json.dump(datos, f, indent=4)

# Lectura
with open('datos.json', 'r') as f:
    datos_leidos = json.load(f)
print(datos_leidos)
Otros formatos comunes en Python

XML (eXtensible Markup Language)

Que son:Formato de texto para almacenar datos estructurados y usa etiquetas similares a HTML, Se puede procesar con xml.etree.ElementTree.

YAML (YAML Ain't Markup Language)

Que son:Formato legible por humanos para serialización de datos que usa indentación para estructuración y se procesa con la librería PyYAML

Pickle

Que son: Formato binario específico de Python para serializar objetos que permite guardar cualquier objeto Python.

No seguro (no cargar archivos pickle de fuentes no confiables)

Ejemplo:

import pickle

datos = {'a': [1, 2, 3], 'b': ('hola', 'mundo')}

# Guardar
with open('datos.pkl', 'wb') as f:
    pickle.dump(datos, f)

# Cargar
with open('datos.pkl', 'rb') as f:
    datos_cargados = pickle.load(f)

Apertura y cierre de archivos

En Python, trabajar con archivos es una operación fundamental que sigue un flujo específico: apertura, manipulación y cierre.

Método Básico: open() y close()

Apertura:

archivo = open('ejemplo.txt', 'r')  # 'r' es el modo de lectura

Cierre:

archivo.close()  # Siempre debes cerrar el archivo

Problema con este enfoque: Si ocurre un error entre la apertura y el cierre, el archivo podría quedar abierto. Por eso se recomienda usar el enfoque con with.

Método Recomendado: Context Manager (with)

Python ofrece una forma más segura usando el contexto with:

with open('ejemplo.txt', 'r') as archivo:
    contenido = archivo.read()
    # El archivo se cierra automáticamente al salir del bloque

Ventajas:

• Cierre automático aunque ocurran excepciones

• Código más limpio y legible

• Previene fugas de recursos

Modos de Apertura

Modo	Descripción	Ejemplo de Uso
'r'	Lectura (default)	open('archivo.txt', 'r')
'w'	Escritura (sobrescribe si existe)	open('salida.txt', 'w')
'a'	Append (añade al final)	open('log.txt', 'a')
'x'	Creación exclusiva (falla si existe)	open('nuevo.txt', 'x')
'b'	Modo binario	open('imagen.jpg', 'rb')
't'	Modo texto (default)	open('texto.txt', 'rt')
'+'	Lectura y escritura	open('datos.db', 'r+')
'w+'	Escritura + lectura (sobrescribe)	open('datos.tmp', 'w+')
'a+'	Append + lectura	open('registro.log', 'a+')

Operaciones Comunes

Lectura:

with open('archivo.txt', 'r') as f:
    contenido = f.read()  # Lee todo el contenido
    linea = f.readline()  # Lee una línea
    lineas = f.readlines()  # Lee todas las líneas como lista

Escritura:

with open('archivo.txt', 'w') as f:
    f.write("Hola mundo\n")
    f.writelines(["línea 1\n", "línea 2\n"])

Métodos para Leer Archivos

Python ofrece varias formas de leer archivos:

read(): Leer todo el contenido.

with open("archivo.txt", "r", encoding="utf-8") as file:
    contenido = file.read()  # Lee todo el archivo como una cadena
print(contenido)

Ventaja: Simple y rápido para archivos pequeños.

Desventaja: No eficiente para archivos grandes (consume mucha memoria).

readline(): Leer línea por línea

with open("archivo.txt", "r") as file:
    linea = file.readline()  # Lee solo la primera línea
    while linea:
        print(linea.strip())  # Elimina saltos de línea (\n)
        linea = file.readline()  # Lee la siguiente línea
        #Útil cuando necesitas procesar líneas individualmente.

readlines(): Leer todas las líneas (lista).

with open("archivo.txt", "r") as file:
    lineas = file.readlines()  # Devuelve una lista de líneas
for linea in lineas:
    print(linea.strip())

Ventaja: Fácil de iterar.

Desventaja: Al igual que read(), carga todo en memoria.

Iterar directamente sobre el archivo (recomendado para archivos grandes)

with open("archivo.txt", "r") as file:
    for linea in file:  # Lee línea por línea sin cargar todo en memoria
        print(linea.strip())

• Eficiente para archivos grandes (no almacena todo en RAM).

Escritura de Archivos

En Python, la función open() acepta distintos parametros, entre los más importantes: file, mode y encoding. Estos determinan qué archivo se va a abrir, en qué modo se manipulará el archivo y en que codificación se trabajará. A continuación se muestran los modos más usados.

Modo de escritura w (Write)

• Descripción: Abre el archivo solo para escritura. Si el archivo existe, su contenido se trunca (se borra) y se crea uno nuevo si no existe.
• Uso típico:

with open('archivo.txt', 'w') as f:
	f.write('Hola, mundo!')

Esto creará (o sobrescribirá) archivo.txt con el texto especificado.

Modo de adición a (Append)

• Descripción: Abre el archivo para añadir datos al final. Si no existe, lo crea. No trunca el contenido existente.
• Uso típico:

with open('archivo.txt', 'a') as f:
	f.write('\nNueva línea.')

El texto se agrega después del contenido previo, conservando todo lo anterior.

Modo de lectura y escritura r+ (Read/Write)

• Descripción: Abre el archivo tanto para lectura como para escritura sin truncarlo. El puntero inicia al comienzo; si el archivo no existe, lanza FileNotFoundError.
• Uso típico:

with open('archivo.txt', 'r+') as f:
	contenido = f.read()
	f.seek(0)	# Volver al inicio
	f.write('Encabezado\n')

Esto permite modificar o añadir datos sin borrar lo previo.

Manejo de Excepciones

Para que el código sea robusto, es esencial capturar y manejar errores que pueden surgir al trabajar con archivos (permisos, existencia, disco lleno, etc.).

try:
	with open('datos.csv', 'r') as f:
		datos = f.read()
except FileNotFoundError:
	print('Error: el archivo no existe.')
except PermissionError:
	print('Error: sin permiso para acceder al archivo.')
except IOError as e:
	print(f'Error de E/S: {e}')
else:
	print('Archivo leído correctamente.')
finally:
	print('Operación de apertura finalizada.')

• try: bloque donde se ejecuta el código que puede fallar.
• except <ErrorType>: gestiona errores específicos, evitando que el programa termine abruptamente citeturn1search3.
• else: se ejecuta si no hubo excepción.
• finally: siempre se ejecuta (útil para liberar recursos).

Comprobación de Existencia de Archivos

Antes de abrir o manipular un archivo, es buena práctica verificar si existe para evitar excepciones innecesarias. Dos enfoques comunes:

Módulo os.path

import os

ruta = 'archivo.txt'
if os.path.exists(ruta):
	print('El archivo o directorio existe.')
if os.path.isfile(ruta):
	print('Es un archivo regular.')

• exists() devuelve True si existe el archivo o directorio.
• isfile() devuelve True solo si existe y es un archivo.

Módulo pathlib

from pathlib import Path

ruta = Path('archivo.txt')
if ruta.exists():
	print('Existe ruta.')
if ruta.is_file():
	print('Es archivo.')

• Enfoque orientado a objetos.
• Métodos exists() y is_file() facilitan comprobaciones limpias.

Manejo de Archivos CSV y JSON en Python

1. Trabajo con Archivos CSV

La biblioteca csv de Python proporciona herramientas para leer y escribir datos en formato CSV (Valores Separados por Comuna).

Escritura de Archivos CSV

Ejemplo: Crear nuevo archivo CSV

import csv

datos = [
    ['Nombre', 'Edad', 'Ciudad'],
    ['Ana', 28, 'Madrid'],
    ['Carlos', 35, 'Barcelona']
]

with open('personas.csv', 'w', newline='', encoding='utf-8') as archivo:
    escritor = csv.writer(archivo)
    escritor.writerows(datos)

Ejemplo: Usar DictWriter para escritura con encabezados

datos_dict = [
    {'Nombre': 'Laura', 'Edad': 22, 'Ciudad': 'Valencia'},
    {'Nombre': 'Pedro', 'Edad': 41, 'Ciudad': 'Sevilla'}
]

with open('personas_dict.csv', 'w', newline='', encoding='utf-8') as archivo:
    campos = ['Nombre', 'Edad', 'Ciudad']
    escritor = csv.DictWriter(archivo, fieldnames=campos)
    escritor.writeheader()
    escritor.writerows(datos_dict)

Lectura de Archivos CSV

Ejemplo: Leer archivo CSV básico

with open('personas.csv', 'r', encoding='utf-8') as archivo:
    lector = csv.reader(archivo)
    for fila in lector:
        print(f'Nombre: {fila[0]}, Edad: {fila[1]}')

Ejemplo: Usar DictReader para acceso por nombres de campo

with open('personas_dict.csv', 'r', encoding='utf-8') as archivo:
    lector = csv.DictReader(archivo)
    for fila in lector:
        print(f"{fila['Nombre']} vive en {fila['Ciudad']}")

Manejo de Excepciones en CSV

try:
    with open('datos.csv', 'r') as archivo:
        lector = csv.reader(archivo)
        for fila in lector:
            print(fila)
except FileNotFoundError:
    print("Error: Archivo no encontrado")
except csv.Error as e:
    print(f"Error en CSV: {e}")

2. Trabajo con JSON

El módulo json permite serializar (convertir objetos Python a cadena JSON) y deserializar (convertir JSON a objetos Python).

Serialización (Python → JSON)

Ejemplo: Convertir objeto Python a JSON string

import json

datos = {
    "nombre": "Ejemplo",
    "versiones": [1.2, 1.3, 2.0],
    "activo": True
}

json_str = json.dumps(datos, indent=2)
print(json_str)

Ejemplo: Guardar JSON en archivo

with open('config.json', 'w', encoding='utf-8') as archivo:
    json.dump(datos, archivo, ensure_ascii=False, indent=4)

Deserialización (JSON → Python)

Ejemplo: Leer JSON desde string

json_data = '{"nombre": "Ejemplo", "valor": 42}'
objeto_python = json.loads(json_data)
print(objeto_python['nombre'])

Ejemplo: Leer JSON desde archivo

with open('config.json', 'r', encoding='utf-8') as archivo:
    config = json.load(archivo)
    print(config['versiones'])

Manejo de Excepciones en JSON

try:
    with open('datos.json', 'r') as archivo:
        datos = json.load(archivo)
except json.JSONDecodeError as e:
    print(f"Error en formato JSON: {e}")
except FileNotFoundError:
    print("Archivo no encontrado")

Cierre automático con with

El uso de with garantiza que los archivos se cierren correctamente, incluso si ocurren errores durante las operaciones. ejemplo:

with open('registro.log', 'a') as archivo:
    archivo.write('nuevo evento\n')
    # no es necesario llamar a close(), with lo maneja automáticamente

Organización de proyectos

Una estructura típica para proyectos python:

mi_proyecto/
├── src/                  # código fuente
│   └── main.py
├── data/                 # archivos de datos (json, csv, etc.)
│   └── config.json
├── docs/                 # documentación
├── tests/                # pruebas
└── requirements.txt      # dependencias

Buenas prácticas:

1. Separar código, datos y documentación en directorios distintos.
2. Usar nombres descriptivos para archivos y carpetas.
3. Incluir un readme.md con instrucciones del proyecto.