Hasta ahora guardaste un único valor por variable. Con los datos compuestos podés agrupar varios valores y acceder a ellos después. Lista, tupla, conjunto y diccionario sirven para necesidades distintas.

El primer elemento de una lista se encuentra en el índice 0, no en el 1. Un diccionario relaciona claves con valores: por ejemplo, el nombre de un producto con su precio.

productos = ["Mesa", "Silla", "Estante"]
medidas = (120, 60)
materiales = {"pino", "roble", "pino"}
producto = {"nombre": "Mesa", "precio": 45000}

print(productos[0])
print(medidas[1])
print(len(materiales))
print(producto["precio"])

Mesa
60
2
45000

En una lista podés cambiar un elemento utilizando su índice. En un diccionario podés cambiar el valor asociado a una clave.

Si pedís un índice que no existe, aparece IndexError. Si intentás leer una clave inexistente con ["clave"], aparece KeyError. Más adelante aprenderás a manejarlos.

precios = [10000, 15000, 22000]
precios[1] = 18000
print(precios)

cliente = {"nombre": "Ana", "ciudad": "Cosquín"}
cliente["ciudad"] = "Córdoba"
cliente["telefono"] = "123456"
print(cliente["ciudad"])

[10000, 18000, 22000]
Córdoba

Los operadores trabajan sobre números. Practicá su significado antes de construir cálculos grandes.

Python respeta la prioridad habitual de operaciones. Usá paréntesis cuando necesites aclarar qué se resuelve primero.

precio_unitario = 15000
cantidad = 3
subtotal = precio_unitario * cantidad
descuento = subtotal * 0.10
final = subtotal - descuento
print(subtotal)
print(final)

45000
40500.0

Una comparación produce un booleano, True o False. Estos resultados son la base de las decisiones.

• == comprueba igualdad; != comprueba diferencia.
• > y < comparan cuál valor es mayor o menor.
• >= y <= incluyen el límite.

El signo = significa asignar, mientras que == significa comparar. Esta confusión es muy común al empezar.

stock = 8
pedido = 5
print(stock >= pedido)
print(stock == pedido)
print(stock != 0)

True
False
True

Un if ejecuta un bloque de código solamente si su condición es verdadera. elif permite evaluar otra condición y else cubre el resto de los casos.

Los dos puntos : indican que comienza un bloque, y la indentación (normalmente cuatro espacios) identifica qué instrucciones pertenecen a él. Python depende de esa indentación.

stock = 6
pedido = 8

if pedido <= stock:
    print("Hay stock suficiente")
elif stock > 0:
    print("Hay stock parcial")
else:
    print("No hay stock")

Hay stock parcial

Los operadores and, or y not combinan o niegan expresiones booleanas.

• and: el resultado es verdadero si ambas condiciones lo son.
• or: alcanza con que una sea verdadera.
• not: invierte el resultado lógico.

Cuando combinás varias condiciones, utilizá paréntesis para que el código sea claro.

stock = 4
pedido = 3
local_abierto = True

puedo_vender = (stock >= pedido) and local_abierto
print(puedo_vender)
print(not local_abierto)

if puedo_vender:
    print("Confirmar pedido")

True
False
Confirmar pedido

Un método es una operación disponible en un objeto. Se invoca escribiendo un punto y el nombre del método: texto.upper().

Las cadenas de texto (str) son inmutables. Métodos como upper() y replace() devuelven un nuevo texto; no modifican el original.

titulo = "  Mesa de Pino  "
limpio = titulo.strip()
mayusculas = limpio.upper()
print(titulo)
print(limpio)
print(mayusculas)

Mesa de Pino  
Mesa de Pino
MESA DE PINO

Estos métodos permiten normalizar nombres de productos, etiquetas y descripciones.

Podés encadenar métodos, por ejemplo nombre.strip().lower(). split() produce una lista: más adelante podrás modificarla con los métodos de listas.

nombre = "  MESA DE PINO  "
print(nombre.strip().lower())
print("pino,roble,mdf".split(","))
print("madera de pino".replace("pino", "roble"))
print("cosquin".find("z"))

mesa de pino
['pino', 'roble', 'mdf']
madera de roble
-1

Las listas sí son mutables. Muchos métodos modifican directamente la lista que ya existe.

• append(valor) agrega un elemento al final.
• extend(iterable) agrega varios elementos.
• insert(indice, valor) inserta en una posición.
• remove(valor) elimina la primera coincidencia; falla si no existe.
• pop(indice) quita y devuelve un elemento; sin índice usa el último.
• sort() ordena la lista original; sorted(lista) crea una lista nueva ordenada.
• reverse() invierte el orden actual.

precios = [24000, 12000, 18000]
precios.append(30000)
precios.remove(12000)
precios.sort()
print(precios)

ultimo = precios.pop()
print(ultimo)
print(precios)

[18000, 24000, 30000]
30000
[18000, 24000]

Los diccionarios representan datos nombrados, como nombre, precio o stock.

• get(clave, valor_por_defecto) consulta sin fallar cuando la clave no existe.
• keys() obtiene una vista de claves.
• values() obtiene una vista de valores.
• items() obtiene pares clave-valor.
• update({...}) añade o reemplaza claves.
• pop(clave) quita una clave y devuelve su valor.

Los resultados de keys() y items() son vistas, no listas; más adelante aprenderás cómo recorrerlas con bucles.

mueble = {"nombre": "Escritorio", "precio": 85000}
print(mueble.get("stock", 0))

mueble.update({"precio": 90000, "stock": 2})
print(mueble["precio"])
print("stock" in mueble)
print(list(mueble.keys()))

0
90000
True
['nombre', 'precio', 'stock']

Este ejemplo une cadenas, listas y diccionarios sin necesitar bucles ni entrada por teclado. Sirve como puente hacia la próxima clase, donde aprenderás input().

Paso 1: limpiamos un nombre que llega con espacios. Paso 2: lo almacenamos en un diccionario. Paso 3: lo agregamos a una lista de productos. Paso 4: consultamos la información.

nombre_crudo = "  Estantería de Pino "
nombre_limpio = nombre_crudo.strip().title()

producto = {"nombre": nombre_limpio, "precio": 65000}
catalogo = []
catalogo.append(producto)

print(catalogo[0]["nombre"])
print(catalogo[0].get("stock", "Sin dato"))
print(len(catalogo))

Estantería De Pino
Sin dato
1

Hasta ahora nuestros programas trabajaban con datos que escribíamos directamente en el código. La función input() muestra un mensaje (si se lo pasás) y espera a que la persona escriba y presione Enter.

El resultado de input() siempre es una cadena (str), incluso si escribís 12. No confundas el texto "12" con el número entero 12.

Cuando ves el cursor esperando, no significa que el programa se colgó: está esperando una respuesta.

nombre = input("¿Cómo se llama el producto? ")
print("Producto elegido:", nombre)
print("Tipo de dato:", type(nombre).__name__)

Si escribís Mesa:
Producto elegido: Mesa
Tipo de dato: str

Para calcular un total, convertí el texto recibido en un número con int() (enteros) o float() (decimales). Si intentás sumar un texto y un número, Python puede lanzar TypeError. Si intentás convertir letras a número, por ejemplo int("cinco"), se produce ValueError.

En Python los decimales se escriben con punto, no con coma: 12.5. Para esta práctica, cuando un programa pida un número decimal, escribí 12.5.

cantidad_texto = input("Cantidad de unidades: ")
cantidad = int(cantidad_texto)
precio = 15000
total = cantidad * precio
print("Total:", total)

Si ingresás 3:
Total: 45000

Las personas pueden ingresar espacios de más o escribir con mayúsculas y minúsculas diferentes. Podés usar .strip() para quitar espacios de los extremos y .lower() para normalizar texto antes de compararlo.

Los mensajes deben dejar claro qué tipo de respuesta se espera. Por ejemplo, pedir “Unidades (número entero)” ayuda a evitar errores.

respuesta = input("¿Querés retirar en el local? (sí/no): ")
respuesta = respuesta.strip().lower()

if respuesta in ("sí", "si"):
    print("Retiro por el local")
elif respuesta == "no":
    print("Consultar envío")
else:
    print("Respuesta no reconocida")

Si ingresás "  SÍ  ":
Retiro por el local

En este tramo Soy Dalto plantea ejercicios propios. Lo vamos a aprovechar de una manera distinta a mirar pasivamente: pausá apenas aparezca cada consigna, resolvela en un archivo nuevo y recién entonces mirá el razonamiento y la solución del video.

1. Copiá la consigna en un comentario o documento, no el código de la solución.
2. Anotá el resultado esperado y dividí el problema en pasos.
3. Escribí tu versión y ejecutala al menos dos veces con entradas distintas.
4. Compará el resultado y anotá una mejora que puedas aplicar.

Si no conseguís resolverlo, registrá dónde te trabaste. Eso vale más que memorizar una solución.

# Plantilla de trabajo propia: reemplazá los comentarios
# 1. Entradas esperadas:
# 2. Cálculos o decisiones:
# 3. Resultado que debe mostrarse:
# 4. Pruebas con datos diferentes:

Con desempaquetado podés asignar elementos de una lista o tupla a distintas variables en una sola línea. Debe haber una cantidad compatible de valores, salvo que uses * para reunir los restantes.

Por ejemplo, ancho, largo = medidas recibe dos valores. También podés intercambiar dos variables sin una variable auxiliar mediante a, b = b, a.

medidas = (120, 60)
largo, ancho = medidas
print("Largo:", largo)
print("Ancho:", ancho)

primer_producto, *otros = ["Mesa", "Silla", "Estante"]
print("Principal:", primer_producto)
print("Otros:", otros)

Largo: 120
Ancho: 60
Principal: Mesa
Otros: ['Silla', 'Estante']

Una estructura muy práctica para representar una compra es el diccionario: asociás nombres de campos a valores. Conviene usar claves claras y consultar las opcionales con get(). Podés modificar una clave mediante producto["precio"] = ....

El método items() permite recorrer pares de clave y valor cuando aprendamos los bucles en la próxima clase.

producto = {
    "nombre": "Escritorio",
    "precio": 120000,
    "stock": 3
}

producto["stock"] = 2
print(producto["nombre"])
print(producto.get("descuento", 0))
print(producto["stock"])

Escritorio
0
2

Vamos a unir input(), conversión de tipos, condiciones y diccionarios en un programa pequeño. Es un ejemplo de consola: todavía no es un sistema para clientes ni guarda compras en un archivo.

Probar un programa significa cambiar entradas y revisar si la salida tiene sentido. Ejecutalo con pedido igual al stock y después con un pedido superior al stock.

producto = {"nombre": "Silla", "precio": 20000, "stock": 4}
cantidad = int(input("¿Cuántas sillas necesitás?: "))

if cantidad <= 0:
    print("La cantidad debe ser positiva")
elif cantidad > producto["stock"]:
    print("No hay stock suficiente")
else:
    total = producto["precio"] * cantidad
    print("Subtotal:", total)

Si ingresás 2:
Subtotal: 40000
Si ingresás 6:
No hay stock suficiente

Antes de continuar, intentá explicar de memoria: ¿qué devuelve input()?, ¿por qué convertimos ciertos valores?, ¿qué significa desempaquetar? y ¿cuándo conviene usar un diccionario?

edad_texto = "21"
edad = int(edad_texto)
print(type(edad_texto).__name__)
print(type(edad).__name__)
print(edad >= 18)

str
int
True

Un for repite un bloque de instrucciones para cada elemento de un iterable, como una lista, tupla, cadena o diccionario. La variable del bucle toma un valor diferente en cada vuelta.

La indentación define qué instrucciones pertenecen al bucle. Todo lo que esté fuera del bloque se ejecutará después de terminar las repeticiones.

productos = ["Mesa", "Silla", "Estante"]
for producto in productos:
    print("Producto:", producto)

print("Fin del listado")

Producto: Mesa
Producto: Silla
Producto: Estante
Fin del listado

Si necesitás repetir una instrucción cierto número de veces, usá range(). El límite superior no se incluye: range(1, 4) genera 1, 2 y 3. También podés indicar un tercer argumento como paso.

Al recorrer una lista, a menudo es más claro iterar por sus elementos en lugar de usar índices. Pero range() es ideal para cantidades definidas.

for numero in range(1, 4):
    print("Vuelta:", numero)

for numero in range(0, 6, 2):
    print("Par:", numero)

Vuelta: 1
Vuelta: 2
Vuelta: 3
Par: 0
Par: 2
Par: 4

Dos patrones aparecen constantemente en programación: un contador registra cuántas veces pasa algo y un acumulador combina resultados (por ejemplo, un total).

Inicializá estas variables antes del bucle. Si las reiniciás dentro, perderás el avance en cada repetición.

precios = [15000, 23000, 12000]
total = 0
caros = 0

for precio in precios:
    total += precio
    if precio >= 20000:
        caros += 1

print("Total:", total)
print("Precios desde $20.000:", caros)

Total: 50000
Precios desde $20.000: 1

Si iterás directamente sobre un diccionario, obtenés sus claves. Con .items() obtenés cada clave junto con su valor; el desempaquetado de la clase anterior resulta útil.

enumerate() incorpora un índice mientras recorrés una colección y zip() permite recorrer varias secuencias en paralelo. Son herramientas complementarias para practicar; no necesitás dominarlas todas inmediatamente.

stock = {"Mesa": 2, "Silla": 5}
for nombre, cantidad in stock.items():
    print(nombre, cantidad)

productos = ["Mesa", "Silla"]
for posicion, nombre in enumerate(productos, start=1):
    print(posicion, nombre)

precios = [60000, 20000]
for nombre, precio in zip(productos, precios):
    print(nombre, precio)

Mesa 2
Silla 5
1 Mesa
2 Silla
Mesa 60000
Silla 20000

A diferencia del for, un while repite su bloque mientras su condición siga siendo verdadera. Sirve para reintentos, menús y procesos que no sabés de antemano cuántas vueltas necesitan.

El riesgo clásico es el bucle infinito. Debe existir una forma de que la condición deje de cumplirse o de salir mediante break.

contador = 1
while contador <= 3:
    print("Intento:", contador)
    contador += 1

print("Terminó")

Intento: 1
Intento: 2
Intento: 3
Terminó

break finaliza por completo el bucle actual. continue omite lo que resta de la vuelta y pasa a la próxima iteración.

Usalos con moderación y explicá por qué existen. Los bucles suelen ser más fáciles de entender cuando la condición de salida es clara.

pedidos = [2, 0, 5, -1, 3]

for cantidad in pedidos:
    if cantidad == -1:
        print("Fin de los pedidos")
        break
    if cantidad == 0:
        continue
    print("Procesar:", cantidad)

Procesar: 2
Procesar: 5
Fin de los pedidos

Python incluye funciones que ya vienen listas para usar, llamadas built-ins o funciones integradas. Te ayudan a contar, sumar, ordenar y comparar sin escribir un bucle propio para todo.

sorted() no es lo mismo que lista.sort(): la primera devuelve una lista nueva, mientras que la segunda ordena la lista original.

precios = [15000, 22000, 12000]
print(len(precios))
print(sum(precios))
print(min(precios))
print(max(precios))
print(sorted(precios))
print(precios)

3
49000
12000
22000
[12000, 15000, 22000]
[15000, 22000, 12000]

Este ejemplo conecta listas, diccionarios, bucles, decisiones y funciones integradas. Leé cada línea y anotá en qué orden se ejecuta el programa.

Podemos representar cada producto con un diccionario y guardarlos en una lista. El for recorre cada producto, calcula el valor de su stock y acumula el resultado.

inventario = [
    {"nombre": "Mesa", "precio": 50000, "stock": 2},
    {"nombre": "Silla", "precio": 18000, "stock": 3}
]

valor_inventario = 0
for producto in inventario:
    subtotal = producto["precio"] * producto["stock"]
    valor_inventario += subtotal
    print(producto["nombre"], subtotal)

print("Productos diferentes:", len(inventario))
print("Valor total:", valor_inventario)

Mesa 100000
Silla 54000
Productos diferentes: 2
Valor total: 154000

Una función es un bloque de código al que le damos un nombre y que podemos ejecutar cuando lo necesitamos. Primero se define con def y después se llama usando sus paréntesis.

Un buen nombre describe una acción, por ejemplo saludar o calcular_total.

def saludar():
    print("¡Bienvenido!")

saludar()
saludar()

Resultado esperado: Se imprime dos veces «¡Bienvenido!».

Un parámetro es el nombre que aparece al definir una función; un argumento es el valor que le pasás al llamarla. Podés pasar más de uno, usar argumentos nombrados y definir valores por defecto.

En una llamada con argumentos posicionales, el orden importa.

def presentar(nombre, ciudad="Cosquín"):
    return f"{nombre} trabaja en {ciudad}"

print(presentar("Ana"))
print(presentar(ciudad="Córdoba", nombre="Luis"))

Resultado esperado: Ana trabaja en Cosquín / Luis trabaja en Córdoba

print() muestra algo en pantalla. return devuelve un resultado para que otra parte del programa lo utilice. Cuando Python llega a return, la función termina.

Si una función no devuelve nada explícitamente, su resultado es None.

def doble(numero):
    return numero * 2

resultado = doble(7)
print(resultado + 1)

Resultado esperado: 15

Una variable creada dentro de una función es normalmente local: existe solo durante la ejecución de esa función. Los parámetros también son variables locales.

Preferí pasar datos por parámetros y devolver resultados, en lugar de modificar variables globales.

iva = 0.21

def agregar_iva(precio):
    subtotal = precio * (1 + iva)
    return subtotal

print(agregar_iva(1000))
# print(subtotal) daría NameError

Resultado esperado: 1210.0

*args reúne argumentos posicionales en una tupla. **kwargs reúne argumentos nombrados en un diccionario. Son herramientas útiles cuando una función necesita aceptar cantidades variables de datos.

En proyectos pequeños no hace falta utilizarlos para todo: los parámetros comunes suelen ser más claros.

def sumar_precios(*precios):
    return sum(precios)

print(sumar_precios(100, 250, 50))

Resultado esperado: 400

Podés crear funciones que reciban listas y devuelvan valores calculados. En lugar de volver a escribir el mismo recorrido en varios lugares, lo concentrás en una función.

Para poder entenderlas y probarlas, procurá que cada función haga una tarea concreta.

def precio_total(productos):
    total = 0
    for producto in productos:
        total += producto["precio"]
    return total

lista = [{"precio": 2500}, {"precio": 3500}]
print(precio_total(lista))

Resultado esperado: 6000

lambda permite escribir una función anónima de una única expresión. Resulta práctica como función breve para ordenar o transformar datos, pero para lógica compleja es mejor def.

No significa que todas las funciones deban convertirse en lambda.

productos = [
    {"nombre": "Mesa", "precio": 45000},
    {"nombre": "Silla", "precio": 18000}
]
ordenados = sorted(productos, key=lambda p: p["precio"])
print([p["nombre"] for p in ordenados])

Resultado esperado: ['Silla', 'Mesa']

Antes de resolver un ejercicio, escribí qué datos entran, qué operación necesitás y qué valor debe salir. Después dividí el problema en funciones simples.

Probá varios casos, incluido uno con valores pequeños que puedas verificar a mano. Escribir pruebas con assert es una práctica adicional que incorporamos al curso.

def descuento(precio, porcentaje):
    return precio * (1 - porcentaje / 100)

assert descuento(100, 10) == 90
assert descuento(200, 50) == 100
print("Pruebas correctas")

Resultado esperado: Pruebas correctas

Un módulo es un archivo .py con código reutilizable. En lugar de escribir todo en un único archivo, podés separar funciones relacionadas.

Para probar este ejemplo, guardá el primer bloque como calculadora.py y el segundo como principal.py, ambos en la misma carpeta.

# calculadora.py
def sumar(a, b):
    return a + b

# principal.py (otro archivo)
import calculadora
print(calculadora.sumar(2, 3))

Resultado esperado: Al ejecutar principal.py, muestra 5.

import modulo conserva el nombre del módulo delante de cada función. from modulo import funcion importa solamente un nombre. as permite asignar un alias.

Evitá from modulo import * en proyectos normales: dificulta saber de dónde proviene cada nombre.

import math
from math import sqrt
import random as azar

print(math.ceil(2.1))
print(sqrt(81))
print(azar.randint(1, 3))  # valor aleatorio

Resultado esperado: 3 / 9.0 / un número entre 1 y 3

Cuando se importa un módulo, se ejecuta su código a nivel superior la primera vez que se carga. Por eso conviene dejar ejemplos o pruebas detrás de if __name__ == "__main__":.

Esto ayuda a que una función importada no dispare procesos inesperados.

# utilidades.py
def duplicar(valor):
    return valor * 2

if __name__ == "__main__":
    print(duplicar(4))  # solo en ejecución directa

Resultado esperado: Al importar utilidades no imprime 8.

Python busca módulos usando rutas de importación que incluyen la biblioteca estándar y ubicaciones del proyecto. Si Python no encuentra un archivo, puede aparecer ModuleNotFoundError.

Para iniciar, guardá los archivos relacionados en la misma carpeta y ejecutá el archivo principal desde allí. No modifiques rutas del sistema sin necesidad.

import sys
print(sys.path[0])  # primera entrada de búsqueda

Resultado esperado: Muestra una ruta o una cadena vacía, según cómo ejecutes Python.

Un paquete permite agrupar módulos en una carpeta. Es habitual utilizar un archivo __init__.py para identificar y configurar el paquete; en Python moderno también existen paquetes de espacio de nombres sin ese archivo.

Separar responsabilidades facilita el mantenimiento cuando un proyecto crece.

# Estructura del proyecto:
# proyecto/
#   principal.py
#   herramientas/
#       __init__.py
#       precios.py
#
# En principal.py:
# from herramientas.precios import calcular_total

Con open() y with podés leer archivos. El modo "r" es lectura; encoding="utf-8" ayuda a trabajar correctamente con acentos. with cierra el archivo automáticamente incluso si ocurre un error.

El archivo debe existir para poder leerlo en modo r.

with open("notas.txt", "r", encoding="utf-8") as archivo:
    texto = archivo.read()

print(texto)

Resultado esperado: Imprime el contenido de notas.txt.

El modo "w" crea o sobrescribe un archivo; "a" añade contenido al final. "r" lee. Agregá "\n" si querés una nueva línea.

Guardá los archivos de práctica en una carpeta separada para evitar sobrescribir datos importantes.

with open("registro.txt", "w", encoding="utf-8") as f:
    f.write("Mesa,2\n")

with open("registro.txt", "a", encoding="utf-8") as f:
    f.write("Silla,4\n")

with open("registro.txt", "r", encoding="utf-8") as f:
    for linea in f:
        print(linea.strip())

Resultado esperado: Mesa,2 / Silla,4

Al leer un archivo, asegurate de que exista. Una ruta relativa como "registro.txt" depende del directorio de trabajo actual, que puede cambiar según cómo ejecutes el programa.

Este ejemplo añade una comprobación con FileNotFoundError; el manejo de excepciones se profundizará en la clase 09.

try:
    with open("registro.txt", encoding="utf-8") as f:
        contenido = f.read()
    print(contenido)
except FileNotFoundError:
    print("Primero creá registro.txt")

Resultado esperado: Muestra el contenido o informa que falta el archivo.

CSV significa valores separados por comas. Es un archivo de texto organizado en filas y columnas; suele utilizarse para exportar productos, alumnos o ventas. No es una base de datos: es una forma sencilla de intercambiar información.

El separador puede ser una coma o un punto y coma. Por eso es importante conocer el formato antes de interpretarlo.

# Una fila podría representar: nombre,precio,cantidad
linea = "Mesa,45000,2"
campos = linea.split(",")
print(campos)

Resultado esperado: ['Mesa', '45000', '2']

Python incluye el módulo csv, que interpreta correctamente el texto delimitado, incluso cuando aparecen comillas o separadores dentro de los datos. Es preferible a usar split(',') para un CSV real.

El ejemplo crea el archivo antes de leerlo, así funciona en cualquier carpeta donde tengas permisos de escritura.

import csv
with open("precios.csv", "w", newline="", encoding="utf-8") as archivo:
    escritor = csv.writer(archivo)
    escritor.writerow(["producto", "precio"])
    escritor.writerow(["Mesa", 45000])

with open("precios.csv", "r", newline="", encoding="utf-8") as archivo:
    for fila in csv.reader(archivo):
        print(fila)

Resultado esperado: ['producto', 'precio'] / ['Mesa', '45000']

Con csv.DictReader, cada fila se convierte en un diccionario. Así accedés a los campos por el encabezado de la columna, sin recordar el orden de los índices.

Recordá que los números provenientes de un CSV son texto; convertílos a int o float antes de calcular.

import csv
with open("precios.csv", newline="", encoding="utf-8") as archivo:
    for fila in csv.DictReader(archivo):
        print(fila["producto"], int(fila["precio"]) * 2)

Resultado esperado: Mesa 90000 (si creaste precios.csv en el apunte anterior)

Para generar archivos con nombres de columnas usá csv.DictWriter. Indicá la lista de campos, escribí los encabezados con writeheader() y luego cada registro.

newline="" evita líneas en blanco adicionales en algunos sistemas, especialmente Windows.

import csv
productos = [{"producto": "Silla", "precio": 18000},
             {"producto": "Mesa", "precio": 45000}]
with open("catalogo.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["producto", "precio"])
    writer.writeheader()
    writer.writerows(productos)
print("Catálogo guardado")

Resultado esperado: Catálogo guardado

En muchos archivos exportados desde planillas argentinas las columnas aparecen separadas por ;. Si el archivo contiene acentos, utilizá una codificación adecuada como utf-8 o utf-8-sig.

Si detectás espacios sobrantes, strip() ayuda a limpiarlos antes de convertir valores.

import csv
texto = "producto;precio\nSillón; 30000 \n"
with open("ejemplo.csv", "w", encoding="utf-8") as f:
    f.write(texto)
with open("ejemplo.csv", encoding="utf-8") as f:
    filas = csv.DictReader(f, delimiter=";")
    for fila in filas:
        print(fila["producto"], int(fila["precio"].strip()))

Resultado esperado: Sillón 30000

En un programa real, leer suele ser el primer paso. Después necesitás filtrar, transformar y resumir los datos. Por ejemplo, calcular el valor de un pequeño inventario a partir de listas de diccionarios.

Separá el procesamiento de los mensajes de pantalla para que sea más fácil revisarlo.

registros = [{"precio": 3000, "cantidad": 2},
             {"precio": 1500, "cantidad": 4}]
total = sum(r["precio"] * r["cantidad"] for r in registros)
print(f"Valor del inventario: ${total}")

Resultado esperado: Valor del inventario: $12000

Matplotlib es una biblioteca externa para visualizar datos. Si todavía no está instalada, en la terminal ejecutá python -m pip install matplotlib (en Windows también puede funcionar py -m pip install matplotlib).

El ejemplo crea un gráfico de barras. Esta biblioteca no forma parte de Python estándar, por lo que requiere instalación.

import matplotlib.pyplot as plt
nombres = ["Mesa", "Silla", "Banco"]
ventas = [5, 8, 3]
plt.bar(nombres, ventas)
plt.title("Ventas por producto")
plt.ylabel("Unidades")
plt.show()

Resultado esperado: Se abre una ventana con el gráfico de barras

Los gráficos son una herramienta de comunicación. Elegí títulos y unidades descriptivas; no hace falta decorar excesivamente la visualización.

En lugar de plt.show() podés utilizar plt.savefig() para guardar una imagen. Esta práctica es una ampliación nuestra del bloque de gráficos.

import matplotlib.pyplot as plt
meses = ["Ene", "Feb", "Mar"]
pedidos = [4, 7, 6]
plt.plot(meses, pedidos, marker="o")
plt.title("Pedidos por mes")
plt.ylabel("Pedidos")
plt.tight_layout()
plt.savefig("pedidos.png", dpi=130)
print("Se guardó pedidos.png")

Resultado esperado: Se guardó pedidos.png

Una excepción es una señal de que algo no pudo ejecutarse normalmente. Por ejemplo, convertir letras en un número genera ValueError. El mensaje te ayuda a detectar la causa.

No se trata de ocultar todos los errores: conviene reconocer cuáles son esperables y cuáles necesitan corregirse.

try:
    numero = int("abc")
    print(numero)
except ValueError:
    print("Ingresá un número válido")

Resultado esperado: Ingresá un número válido

try contiene la operación que puede fallar. except trata el error específico. else se ejecuta si no hubo excepción. finally se ejecuta al terminar, haya ocurrido o no el error.

Es preferible atrapar errores específicos en lugar de utilizar un except: genérico.

try:
    precio = float("1250")
except ValueError:
    print("Precio incorrecto")
else:
    print(f"Precio válido: {precio}")
finally:
    print("Comprobación terminada")

Resultado esperado: Precio válido: 1250.0 / Comprobación terminada

El tipo de excepción que controlás debe corresponder al problema. ZeroDivisionError aparece cuando dividís por cero; FileNotFoundError, cuando un archivo pedido no existe.

En el ejercicio siguiente, el programa distingue una entrada no numérica de un divisor cero.

def dividir(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return "No podés dividir por cero"

print(dividir(10, 2))
print(dividir(5, 0))

Resultado esperado: 5.0 / No podés dividir por cero

Cuando una función recibe un valor inválido, a veces conviene detener el cálculo de manera explícita con raise. Así otras partes del programa pueden reconocer qué ocurrió.

Este contenido es un refuerzo adicional que complementa el manejo de excepciones del video.

def precio_con_iva(precio):
    if precio < 0:
        raise ValueError("El precio no puede ser negativo")
    return precio * 1.21

try:
    print(precio_con_iva(-50))
except ValueError as error:
    print(error)

Resultado esperado: El precio no puede ser negativo

Las expresiones regulares (regex) son patrones para buscar o reemplazar texto. Python incorpora el módulo re. re.search() localiza la primera coincidencia, mientras re.findall() devuelve todas las coincidencias.

Usá r"..." para escribir patrones sin que las barras invertidas sean tratadas como escapes de Python.

import re
frase = "Pedido 107 y pedido 204"
encontrados = re.findall(r"\d+", frase)
print(encontrados)

Resultado esperado: ['107', '204']

\d representa un dígito, \w un carácter de palabra y \s un espacio en blanco. Los cuantificadores indican cuántas repeticiones se admiten: + una o más, * cero o más y {n} exactamente n.

No confundas re.search() (busca una parte) con re.fullmatch() (comprueba todo el texto).

import re
codigos = ["ABC-123", "AB-12", "ZZZ-987"]
for codigo in codigos:
    valido = re.fullmatch(r"[A-Z]{3}-\d{3}", codigo)
    print(codigo, bool(valido))

Resultado esperado: ABC-123 True / AB-12 False / ZZZ-987 True

Los paréntesis permiten capturar una parte del patrón; las coincidencias ofrecen group() o groups() para recuperarlas. Por otro lado, re.sub() reemplaza texto que coincide con un patrón.

Para empezar, usá expresiones cortas y probalas con varios ejemplos antes de diseñar una muy larga.

import re
mensaje = "Facturas: F-012 y F-086"
print(re.findall(r"F-(\d{3})", mensaje))
print(re.sub(r"\d", "X", mensaje))

Resultado esperado: ['012', '086'] / Facturas: F-XXX y F-XXX

Las regex son útiles para extraer códigos, localizar fechas simples o comprobar formatos. Pero un formato correcto no garantiza datos verdaderos: un código puede cumplir un patrón y no existir en tu sistema.

Como ejercicio integrador, combinamos una entrada, una excepción específica y la validación mediante fullmatch().

import re
def validar_codigo(codigo):
    if not re.fullmatch(r"[A-Z]{2}-\d{4}", codigo):
        raise ValueError("Formato esperado: AB-1234")
    return codigo

for ejemplo in ["AB-1234", "A-123"]:
    try:
        print(validar_codigo(ejemplo))
    except ValueError as error:
        print(error)

Resultado esperado: AB-1234 / Formato esperado: AB-1234