Módulos estándar

🧭 Navegación:

• Anterior: Módulos y la Biblioteca Estándar
• Siguiente: Mini Proyecto – Integrando Todo

¡Bienvenido al almacén central de herramientas de Python! Has aprendido a crear tus propias máquinas (funciones), pero Python viene con un almacén gigantesco de herramientas prefabricadas llamadas módulos estándar. Es como tener acceso a una ferretería industrial completa sin tener que fabricar cada herramienta desde cero.

🏪 ¿Qué son los módulos estándar?

Los módulos estándar son como departamentos especializados dentro del almacén central de Python. Cada departamento contiene herramientas específicas para diferentes tipos de trabajo:

• Departamento Matemático: math - Calculadoras avanzadas y fórmulas
• Departamento de Tiempo: datetime - Relojes, calendarios y cronómetros
• Departamento de Azar: random - Generadores de números aleatorios
• Departamento del Sistema: os - Herramientas para el sistema operativo
• Departamento de Archivos: pathlib - Navegadores de carpetas y archivos
• Departamento de Internet: urllib - Herramientas para descargar de internet

# Importar herramientas de diferentes departamentos
import math           # Departamento matemático
import datetime       # Departamento de tiempo
import random         # Departamento de azar
import os            # Departamento del sistema

# Usar las herramientas especializadas
precio_base = 127.89
precio_redondeado = math.ceil(precio_base)  # Redondear hacia arriba
print(f"Precio redondeado: ${precio_redondeado}")

fecha_hoy = datetime.date.today()  # Obtener fecha actual
print(f"Procesando pedido del: {fecha_hoy}")

numero_factura = random.randint(1000, 9999)  # Generar número aleatorio
print(f"Número de factura: {numero_factura}")

📚 Formas de importar módulos

1. Importación completa del departamento

import math

# Necesitas especificar el departamento cada vez
area_circulo = math.pi * (5 ** 2)
raiz_cuadrada = math.sqrt(25)
seno_45 = math.sin(math.radians(45))

print(f"Área del círculo: {area_circulo:.2f}")
print(f"Raíz de 25: {raiz_cuadrada}")
print(f"Seno de 45°: {seno_45:.2f}")

2. Importación con alias (apodo)

import datetime as dt  # Le ponemos un apodo más corto

# Ahora usamos el apodo
ahora = dt.datetime.now()
mañana = ahora + dt.timedelta(days=1)
fecha_entrega = mañana.strftime("%Y-%m-%d")

print(f"Pedido procesado: {ahora.strftime('%H:%M:%S')}")
print(f"Fecha de entrega: {fecha_entrega}")

3. Importación específica de herramientas

from random import randint, choice, shuffle
from os import getcwd, listdir
from math import pi, sqrt, ceil

# Usamos las herramientas directamente (sin especificar departamento)
numero_aleatorio = randint(1, 100)
producto_aleatorio = choice(["Laptop", "Mouse", "Teclado", "Monitor"])
area_circulo = pi * (10 ** 2)
directorio_actual = getcwd()

print(f"Número: {numero_aleatorio}")
print(f"Producto seleccionado: {producto_aleatorio}")
print(f"Área: {area_circulo:.2f}")
print(f"Trabajando en: {directorio_actual}")

4. Importación de todo (usar con cuidado)

# ⚠️ Usar solo con módulos que conoces bien
from math import *

# Ahora todas las herramientas matemáticas están disponibles directamente
resultado = sqrt(sin(pi/2) + cos(0) + tan(pi/4))
print(f"Resultado complejo: {resultado:.2f}")

🧮 Departamento Matemático (math)

El módulo math es como tener una calculadora científica avanzada en tu almacén:

import math

def calcular_metricas_almacen():
    """Usa herramientas matemáticas para métricas del almacén"""
    
    # Área de zonas circulares del almacén
    radio_zona_carga = 15  # metros
    area_zona_carga = math.pi * (radio_zona_carga ** 2)
    
    # Volumen de contenedores cilíndricos
    altura_contenedor = 3  # metros
    volumen_contenedor = area_zona_carga * altura_contenedor
    
    # Distancia entre dos puntos del almacén (usando teorema de Pitágoras)
    def distancia_puntos(x1, y1, x2, y2):
        return math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
    
    # Coordenadas de estaciones en el almacén
    estacion_recepcion = (0, 0)
    estacion_empaque = (50, 30)
    distancia = distancia_puntos(*estacion_recepcion, *estacion_empaque)
    
    # Redondeo inteligente de precios
    precios_originales = [127.89, 45.23, 199.67, 89.12]
    precios_redondeados = {
        "hacia_arriba": [math.ceil(precio) for precio in precios_originales],
        "hacia_abajo": [math.floor(precio) for precio in precios_originales],
        "normal": [round(precio, 2) for precio in precios_originales]
    }
    
    # Estadísticas con logaritmos (para crecimiento exponencial)
    ventas_mensuales = [1000, 1200, 1440, 1728, 2074]  # Crecimiento del 20%
    tasa_crecimiento = math.log(ventas_mensuales[-1] / ventas_mensuales[0]) / len(ventas_mensuales)
    
    return {
        "area_zona_carga": round(area_zona_carga, 2),
        "volumen_contenedor": round(volumen_contenedor, 2),
        "distancia_estaciones": round(distancia, 2),
        "precios_redondeados": precios_redondeados,
        "tasa_crecimiento_mensual": round(tasa_crecimiento * 100, 2)
    }

# Ejemplo de uso
metricas = calcular_metricas_almacen()
print("📊 MÉTRICAS DEL ALMACÉN:")
print(f"Área de zona de carga: {metricas['area_zona_carga']} m²")
print(f"Volumen de contenedor: {metricas['volumen_contenedor']} m³")
print(f"Distancia entre estaciones: {metricas['distancia_estaciones']} m")
print(f"Tasa de crecimiento: {metricas['tasa_crecimiento_mensual']}% mensual")

# Herramientas matemáticas más utilizadas
print("\n🧮 HERRAMIENTAS MATEMÁTICAS DISPONIBLES:")
print(f"π (pi): {math.pi:.4f}")
print(f"e (euler): {math.e:.4f}")
print(f"Raíz cuadrada de 144: {math.sqrt(144)}")
print(f"2 elevado a la 8: {math.pow(2, 8)}")
print(f"Logaritmo natural de 100: {math.log(100):.2f}")
print(f"Logaritmo base 10 de 1000: {math.log10(1000)}")

📅 Departamento de Tiempo (datetime)

El módulo datetime es como tener relojes, calendarios y cronómetros profesionales:

import datetime as dt

def sistema_gestion_tiempo():
    """Sistema completo de gestión de tiempo para el almacén"""
    
    # Obtener información actual
    ahora = dt.datetime.now()
    hoy = dt.date.today()
    
    # Crear fechas específicas
    apertura_almacen = dt.date(2020, 1, 15)
    horario_apertura = dt.time(8, 0, 0)  # 8:00 AM
    horario_cierre = dt.time(18, 0, 0)   # 6:00 PM
    
    # Calcular tiempo en operación
    dias_en_operacion = (hoy - apertura_almacen).days
    años_en_operacion = dias_en_operacion / 365.25
    
    # Programar entregas futuras
    entregas_proximas = []
    for i in range(1, 8):  # Próximos 7 días
        fecha_entrega = hoy + dt.timedelta(days=i)
        # Solo días laborales (lunes a viernes)
        if fecha_entrega.weekday() < 5:
            entregas_proximas.append({
                "fecha": fecha_entrega.strftime("%Y-%m-%d"),
                "dia_semana": fecha_entrega.strftime("%A"),
                "es_laborable": True
            })
    
    # Verificar si estamos abiertos ahora
    hora_actual = ahora.time()
    esta_abierto = horario_apertura <= hora_actual <= horario_cierre
    
    # Calcular tiempo hasta cierre/apertura
    if esta_abierto:
        tiempo_hasta_cierre = dt.datetime.combine(hoy, horario_cierre) - ahora
        mensaje_estado = f"Abierto - Cierra en {tiempo_hasta_cierre}"
    else:
        mañana = hoy + dt.timedelta(days=1)
        tiempo_hasta_apertura = dt.datetime.combine(mañana, horario_apertura) - ahora
        mensaje_estado = f"Cerrado - Abre en {tiempo_hasta_apertura}"
    
    # Análisis por trimestres
    trimestre_actual = (ahora.month - 1) // 3 + 1
    inicio_trimestre = dt.date(ahora.year, (trimestre_actual - 1) * 3 + 1, 1)
    dias_transcurridos_trimestre = (hoy - inicio_trimestre).days
    
    return {
        "fecha_hora_actual": ahora.strftime("%Y-%m-%d %H:%M:%S"),
        "dias_en_operacion": dias_en_operacion,
        "años_en_operacion": round(años_en_operacion, 1),
        "estado_almacen": mensaje_estado,
        "entregas_proximas": entregas_proximas,
        "trimestre": {
            "numero": trimestre_actual,
            "dias_transcurridos": dias_transcurridos_trimestre
        }
    }

# Sistema de registro de actividades
def registrar_actividad(actividad, timestamp=None):
    """Registra actividades con timestamp automático"""
    if timestamp is None:
        timestamp = dt.datetime.now()
    
    registro = {
        "actividad": actividad,
        "timestamp": timestamp.isoformat(),
        "fecha_legible": timestamp.strftime("%d/%m/%Y %H:%M:%S"),
        "dia_semana": timestamp.strftime("%A"),
        "es_fin_semana": timestamp.weekday() >= 5
    }
    
    return registro

# Ejemplos de uso
info_tiempo = sistema_gestion_tiempo()
print("⏰ SISTEMA DE GESTIÓN DE TIEMPO:")
print(f"Fecha y hora: {info_tiempo['fecha_hora_actual']}")
print(f"Días en operación: {info_tiempo['dias_en_operacion']}")
print(f"Estado: {info_tiempo['estado_almacen']}")
print(f"Trimestre {info_tiempo['trimestre']['numero']}: día {info_tiempo['trimestre']['dias_transcurridos']}")

print("\n📦 ENTREGAS PROGRAMADAS:")
for entrega in info_tiempo['entregas_proximas'][:3]:
    print(f"  {entrega['fecha']} ({entrega['dia_semana']})")

# Registrar algunas actividades
actividades = [
    "Recepción de mercancía",
    "Inventario de productos",
    "Procesamiento de pedidos"
]

print("\n📝 REGISTRO DE ACTIVIDADES:")
for actividad in actividades:
    registro = registrar_actividad(actividad)
    print(f"  {registro['fecha_legible']}: {registro['actividad']}")

🎲 Departamento de Azar (random)

El módulo random es como tener dados, ruletas y máquinas de sorteo profesionales:

import random

def sistema_aleatorio_almacen():
    """Sistema de decisiones y selecciones aleatorias para el almacén"""
    
    # Base de datos simulada
    productos = [
        {"codigo": "LAP001", "nombre": "Laptop Gaming", "stock": 15},
        {"codigo": "MOU001", "nombre": "Mouse Inalámbrico", "stock": 50},
        {"codigo": "TEC001", "nombre": "Teclado Mecánico", "stock": 25},
        {"codigo": "MON001", "nombre": "Monitor 4K", "stock": 8},
        {"codigo": "AUD001", "nombre": "Audífonos", "stock": 30}
    ]
    
    empleados = ["Ana García", "Carlos López", "María Rodríguez", "José Martínez", "Elena Fernández"]
    colores_etiqueta = ["rojo", "azul", "verde", "amarillo", "naranja", "morado"]
    
    # 1. Selección aleatoria simple
    producto_destacado = random.choice(productos)
    empleado_del_mes = random.choice(empleados)
    color_promocional = random.choice(colores_etiqueta)
    
    # 2. Números aleatorios para códigos y referencias
    numero_factura = random.randint(10000, 99999)
    descuento_sorpresa = round(random.uniform(5.0, 25.0), 1)  # Entre 5% y 25%
    
    # 3. Muestreo de productos para inventario sorpresa
    productos_a_revisar = random.sample(productos, 3)  # Seleccionar 3 sin repetición
    
    # 4. Distribución normal para simulación de demanda
    # La mayoría de pedidos están cerca del promedio, pocos muy altos o bajos
    demanda_simulada = [round(random.normalvariate(100, 20)) for _ in range(7)]  # 7 días
    demanda_simulada = [max(0, d) for d in demanda_simulada]  # No negativos
    
    # 5. Barajado de prioridades de envío
    ordenes_envio = [f"Orden-{i:03d}" for i in range(1, 11)]
    random.shuffle(ordenes_envio)  # Barajar las órdenes
    
    # 6. Simulación de fallos/éxitos
    def simular_entrega():
        return random.random() < 0.95  # 95% de éxito
    
    resultados_entregas = [simular_entrega() for _ in range(10)]
    tasa_exito = sum(resultados_entregas) / len(resultados_entregas) * 100
    
    # 7. Selección ponderada (algunos productos tienen más probabilidad)
    pesos_productos = [p["stock"] for p in productos]  # Más stock = más probable
    producto_tendencia = random.choices(productos, weights=pesos_productos, k=1)[0]
    
    return {
        "selecciones": {
            "producto_destacado": producto_destacado["nombre"],
            "empleado_del_mes": empleado_del_mes,
            "color_promocional": color_promocional
        },
        "numeros_aleatorios": {
            "numero_factura": numero_factura,
            "descuento_sorpresa": f"{descuento_sorpresa}%"
        },
        "inventario_sorpresa": [p["nombre"] for p in productos_a_revisar],
        "demanda_semanal": demanda_simulada,
        "ordenes_priorizadas": ordenes_envio[:5],  # Primeras 5
        "simulacion_entregas": {
            "total_entregas": len(resultados_entregas),
            "entregas_exitosas": sum(resultados_entregas),
            "tasa_exito": round(tasa_exito, 1)
        },
        "producto_tendencia": producto_tendencia["nombre"]
    }

# Generador de datos de prueba
def generar_datos_prueba(cantidad=100):
    """Genera datos aleatorios para pruebas del sistema"""
    
    nombres = ["Ana", "Carlos", "María", "José", "Elena", "Luis", "Carmen", "Antonio"]
    apellidos = ["García", "López", "Rodríguez", "Martínez", "Fernández", "González"]
    ciudades = ["Madrid", "Barcelona", "Valencia", "Sevilla", "Bilbao", "Málaga"]
    
    clientes_prueba = []
    for i in range(cantidad):
        cliente = {
            "id": f"CLI{i+1:03d}",
            "nombre": random.choice(nombres),
            "apellido": random.choice(apellidos),
            "ciudad": random.choice(ciudades),
            "edad": random.randint(18, 70),
            "gasto_promedio": round(random.expovariate(1/200), 2),  # Distribución exponencial
            "es_vip": random.random() < 0.1  # 10% son VIP
        }
        clientes_prueba.append(cliente)
    
    return clientes_prueba

# Establecer semilla para resultados reproducibles
random.seed(42)  # Mismos resultados en cada ejecución

# Ejemplos de uso
print("🎲 SISTEMA ALEATORIO DEL ALMACÉN:")
datos_aleatorios = sistema_aleatorio_almacen()

print(f"🌟 Producto destacado: {datos_aleatorios['selecciones']['producto_destacado']}")
print(f"👤 Empleado del mes: {datos_aleatorios['selecciones']['empleado_del_mes']}")
print(f"🏷️ Color promocional: {datos_aleatorios['selecciones']['color_promocional']}")
print(f"📄 Número de factura: {datos_aleatorios['numeros_aleatorios']['numero_factura']}")
print(f"💰 Descuento sorpresa: {datos_aleatorios['numeros_aleatorios']['descuento_sorpresa']}")

print(f"\n📊 Demanda simulada (7 días): {datos_aleatorios['demanda_semanal']}")
print(f"📈 Tasa de éxito en entregas: {datos_aleatorios['simulacion_entregas']['tasa_exito']}%")

# Generar algunos clientes de prueba
print("\n👥 CLIENTES DE PRUEBA GENERADOS:")
clientes_muestra = generar_datos_prueba(5)
for cliente in clientes_muestra:
    vip = " (VIP)" if cliente["es_vip"] else ""
    print(f"  {cliente['nombre']} {cliente['apellido']} - {cliente['ciudad']} - ${cliente['gasto_promedio']:.2f}{vip}")

💻 Departamento del Sistema (os)

El módulo os es como tener herramientas para interactuar con el sistema operativo:

import os
from pathlib import Path

def sistema_gestion_archivos():
    """Sistema de gestión de archivos y directorios del almacén"""
    
    # Información del sistema actual
    info_sistema = {
        "directorio_actual": os.getcwd(),
        "usuario": os.getenv("USER", os.getenv("USERNAME", "usuario_desconocido")),
        "sistema_operativo": os.name,
        "separador_rutas": os.sep,
        "variables_entorno": len(os.environ)
    }
    
    # Crear estructura de directorios para el almacén
    estructura_almacen = [
        "datos_almacen",
        "datos_almacen/inventario",
        "datos_almacen/ventas",
        "datos_almacen/reportes",
        "datos_almacen/backups",
        "datos_almacen/logs"
    ]
    
    # Crear directorios si no existen
    directorios_creados = []
    for directorio in estructura_almacen:
        try:
            os.makedirs(directorio, exist_ok=True)
            directorios_creados.append(directorio)
        except PermissionError:
            print(f"⚠️ Sin permisos para crear: {directorio}")
    
    # Listar contenido del directorio actual
    contenido_actual = []
    try:
        for item in os.listdir("."):
            ruta_completa = os.path.join(".", item)
            es_directorio = os.path.isdir(ruta_completa)
            tamaño = os.path.getsize(ruta_completa) if not es_directorio else 0
            
            contenido_actual.append({
                "nombre": item,
                "tipo": "Directorio" if es_directorio else "Archivo",
                "tamaño": tamaño,
                "ruta_completa": os.path.abspath(ruta_completa)
            })
    except PermissionError:
        contenido_actual = [{"error": "Sin permisos para listar directorio"}]
    
    # Trabajar con rutas usando pathlib (más moderno)
    directorio_datos = Path("datos_almacen")
    
    archivos_ejemplo = {
        "inventario": directorio_datos / "inventario" / "productos.json",
        "ventas": directorio_datos / "ventas" / "ventas_2024.csv",
        "log": directorio_datos / "logs" / "sistema.log"
    }
    
    # Crear archivos de ejemplo
    archivos_creados = []
    for tipo, archivo in archivos_ejemplo.items():
        try:
            archivo.parent.mkdir(parents=True, exist_ok=True)
            if not archivo.exists():
                archivo.write_text(f"# Archivo de {tipo} del almacén\n# Creado automáticamente\n")
                archivos_creados.append(str(archivo))
        except Exception as e:
            print(f"⚠️ Error creando {archivo}: {e}")
    
    return {
        "info_sistema": info_sistema,
        "directorios_creados": directorios_creados,
        "archivos_creados": archivos_creados,
        "contenido_directorio": contenido_actual[:5]  # Primeros 5 elementos
    }

# Utilidades para el sistema de archivos
def crear_respaldo_configuracion():
    """Crea respaldo de archivos de configuración"""
    import datetime as dt
    
    timestamp = dt.datetime.now().strftime("%Y%m%d_%H%M%S")
    directorio_backup = Path(f"backup_{timestamp}")
    
    try:
        directorio_backup.mkdir(exist_ok=True)
        
        # Archivos importantes del sistema a respaldar
        archivos_importantes = [
            "datos_almacen/inventario/productos.json",
            "datos_almacen/ventas/ventas_2024.csv"
        ]
        
        archivos_respaldados = []
        for archivo in archivos_importantes:
            ruta_origen = Path(archivo)
            if ruta_origen.exists():
                nombre_backup = f"{ruta_origen.stem}_backup_{timestamp}{ruta_origen.suffix}"
                ruta_destino = directorio_backup / nombre_backup
                
                # Copiar contenido
                contenido = ruta_origen.read_text()
                ruta_destino.write_text(contenido)
                archivos_respaldados.append(str(ruta_destino))
        
        return {
            "directorio_backup": str(directorio_backup),
            "archivos_respaldados": archivos_respaldados,
            "timestamp": timestamp
        }
    
    except Exception as e:
        return {"error": f"Error creando respaldo: {e}"}

# Ejemplos de uso
print("💻 SISTEMA DE GESTIÓN DE ARCHIVOS:")
gestion = sistema_gestion_archivos()

print(f"📁 Directorio actual: {gestion['info_sistema']['directorio_actual']}")
print(f"👤 Usuario: {gestion['info_sistema']['usuario']}")
print(f"🖥️ Sistema: {gestion['info_sistema']['sistema_operativo']}")

print(f"\n📂 Directorios creados: {len(gestion['directorios_creados'])}")
for directorio in gestion['directorios_creados']:
    print(f"  ✅ {directorio}")

print(f"\n📄 Archivos creados: {len(gestion['archivos_creados'])}")
for archivo in gestion['archivos_creados']:
    print(f"  ✅ {archivo}")

# Crear respaldo
print("\n💾 CREANDO RESPALDO:")
respaldo = crear_respaldo_configuracion()
if "error" not in respaldo:
    print(f"✅ Respaldo creado en: {respaldo['directorio_backup']}")
    print(f"📦 Archivos respaldados: {len(respaldo['archivos_respaldados'])}")
else:
    print(f"❌ {respaldo['error']}")

🌐 Departamento de Internet (urllib)

Para conectar tu almacén con el mundo exterior:

from urllib.parse import urlparse, parse_qs
from urllib.request import urlopen
import json

def sistema_consulta_precios():
    """Sistema para consultar precios externos y APIs"""
    
    # Simulación de URLs de APIs (en un caso real serían APIs reales)
    urls_ejemplo = {
        "api_precios": "https://api.ejemplo.com/precios?producto=laptop",
        "api_inventario": "https://proveedor.com/api/stock?codigo=LAP001",
        "api_cambio": "https://api.cambio.com/rates?from=USD&to=EUR"
    }
    
    # Análisis de URLs
    analisis_urls = {}
    for nombre, url in urls_ejemplo.items():
        parsed = urlparse(url)
        parametros = parse_qs(parsed.query)
        
        analisis_urls[nombre] = {
            "dominio": parsed.netloc,
            "ruta": parsed.path,
            "parametros": parametros,
            "esquema": parsed.scheme,
            "url_completa": url
        }
    
    return analisis_urls

# Ejemplo de construcción de URLs para APIs
def construir_url_api(base_url, endpoint, **parametros):
    """Construye URLs para APIs con parámetros"""
    from urllib.parse import urlencode
    
    url_completa = f"{base_url.rstrip('/')}/{endpoint.lstrip('/')}"
    
    if parametros:
        query_string = urlencode(parametros)
        url_completa += f"?{query_string}"
    
    return url_completa

# Ejemplos de uso
print("🌐 SISTEMA DE CONSULTA EXTERNA:")
analisis = sistema_consulta_precios()

for nombre, info in analisis.items():
    print(f"\n📡 {nombre.upper()}:")
    print(f"  Dominio: {info['dominio']}")
    print(f"  Ruta: {info['ruta']}")
    print(f"  Parámetros: {info['parametros']}")

# Construcción de URLs
print("\n🔗 CONSTRUCCIÓN DE URLs:")
base_api = "https://api.almacen.com"

urls_construidas = [
    construir_url_api(base_api, "productos", categoria="electronicos", limite=10),
    construir_url_api(base_api, "ventas", desde="2024-01-01", hasta="2024-12-31"),
    construir_url_api(base_api, "inventario", codigo="LAP001", incluir_stock=True)
]

for url in urls_construidas:
    print(f"  ✅ {url}")

🎯 Comprueba tu comprensión

Ejercicio 1: Calculadora de almacén

Usa el módulo math para crear una calculadora de espacios del almacén:

import math

def calcular_espacios_almacen(largo, ancho, alto, forma="rectangular"):
    """
    Calcula diferentes métricas de espacio del almacén.
    
    Args:
        largo, ancho, alto: Dimensiones en metros
        forma: "rectangular" o "circular"
    
    Returns:
        dict: Métricas calculadas
    """
    # Tu código aquí
    pass

# Prueba
metricas = calcular_espacios_almacen(50, 30, 8)
print(metricas)

Ejercicio 2: Sistema de fechas de vencimiento

Usa datetime para gestionar fechas de vencimiento:

import datetime as dt

def gestionar_vencimientos(productos):
    """
    Analiza productos próximos a vencer.
    
    Args:
        productos: Lista de productos con fecha de vencimiento
    
    Returns:
        dict: Análisis de vencimientos
    """
    # Tu código aquí
    pass

# Prueba
productos_test = [
    {"nombre": "Producto A", "vencimiento": "2024-12-31"},
    {"nombre": "Producto B", "vencimiento": "2024-11-15"},
    {"nombre": "Producto C", "vencimiento": "2025-06-01"}
]

analisis = gestionar_vencimientos(productos_test)
print(analisis)

Ejercicio 3: Generador de códigos aleatorios

Usa random para generar códigos únicos:

import random
import string

def generar_sistema_codigos(cantidad, tipo="producto"):
    """
    Genera códigos únicos para productos, empleados, etc.
    
    Args:
        cantidad: Número de códigos a generar
        tipo: "producto", "empleado", "factura"
    
    Returns:
        list: Lista de códigos únicos
    """
    # Tu código aquí
    pass

# Prueba
codigos_productos = generar_sistema_codigos(10, "producto")
print(codigos_productos)

💡 Mejores prácticas

1. Importa solo lo que necesitas: No importes módulos completos si solo usas una función
2. Usa alias descriptivos: import datetime as dt es más claro que import datetime as d
3. Documenta las dependencias: Siempre especifica qué módulos necesita tu código
4. Maneja errores de importación: No todos los módulos están disponibles en todos los sistemas
5. Explora la documentación: Cada módulo tiene muchas funciones útiles

🎉 ¡Felicitaciones!

Has aprendido a usar el almacén central de herramientas de Python. Ahora puedes:

• ✅ Importar y usar módulos estándar eficientemente
• ✅ Realizar cálculos matemáticos avanzados con math
• ✅ Gestionar fechas y tiempo con datetime
• ✅ Generar datos aleatorios con random
• ✅ Interactuar con el sistema operativo usando os
• ✅ Trabajar con URLs e internet usando urllib

Estos módulos son la base para crear aplicaciones más potentes y profesionales. En la siguiente sección veremos diagramas que te ayudarán a visualizar cómo funcionan las funciones y módulos.

🧭 Navegación:

• Anterior: Módulos y la Biblioteca Estándar
• Siguiente: Mini Proyecto – Integrando Todo