Explorando las Librerías Esenciales de Python 📚

Descubre herramientas incorporadas y externas que potenciarán tus proyectos de matemáticas, ciencias y más.

1. ¿Qué son las Librerías Básicas? 🧰

En Python, una librería (o módulo) es una colección de funciones, clases y variables preescritas que extienden la funcionalidad básica del lenguaje. Piensa en ellas como cajas de herramientas especializadas: si necesitas hacer cálculos matemáticos complejos, hay una "caja de herramientas matemáticas"; si necesitas trabajar con fechas, hay una para eso.

Ventajas de Usar Librerías:

Importación de Librerías:

Para usar una librería, primero debes "importarla" a tu script. Hay varias formas:

# 1. Importar la librería completa
import math
print(math.pi) # Necesitas usar el nombre de la librería para acceder a sus funciones/variables

# 2. Importar funciones específicas de una librería
from math import sqrt, sin
print(sqrt(16))
print(sin(0))

# 3. Importar con un alias (un nombre más corto)
import calendar as cal
print(cal.month(2025, 6))

Librerías Estándar vs. Externas:

Python viene con una Librería Estándar robusta (como `math`, `calendar`, `datetime`) que está disponible automáticamente. Las librerías externas (como `tabulate`, `rich`, `prettytable`) son desarrolladas por terceros y necesitas instalarlas (usualmente con `pip`) antes de poder importarlas.

2. Librería math: Matemáticas Avanzadas 🔢

La librería math proporciona acceso a funciones matemáticas definidas por el estándar C. Es tu aliada para cálculos numéricos, trigonométricos, logarítmicos y más.

Constantes Matemáticas Importantes:

import math
print(f"Valor de Pi (π): {math.pi}")      # Aprox. 3.141592653589793
print(f"Valor de Euler (e): {math.e}")   # Aprox. 2.718281828459045

📋 Tabla Completa de Funciones Matemáticas

Aquí tienes una referencia completa de las funciones más útiles de la librería math:

Categoría Función Descripción Ejemplo Resultado
🔢 Constantes math.pi Valor de π (pi) math.pi 3.14159...
math.e Número de Euler math.e 2.71828...
📐 Redondeo round(x, n) Redondea a n decimales round(3.14159, 2) 3.14
math.ceil(x) Redondea hacia arriba math.ceil(3.2) 4
math.floor(x) Redondea hacia abajo math.floor(3.8) 3
math.trunc(x) Trunca decimales math.trunc(3.9) 3
⚡ Potencias math.sqrt(x) Raíz cuadrada math.sqrt(16) 4.0
math.pow(x, y) x elevado a y math.pow(2, 3) 8.0
x ** y Alternativa a pow() 2 ** 3 8

Nota: Esta tabla continuará con más categorías (Trigonometría, Logaritmos, Geometría, Combinatoria, Verificación) en la siguiente parte.

Categoría Función Descripción Ejemplo Resultado
🌊 Trigonometría math.sin(x) Seno (x en radianes) math.sin(math.pi/2) 1.0
math.cos(x) Coseno (x en radianes) math.cos(0) 1.0
math.tan(x) Tangente (x en radianes) math.tan(math.pi/4) 1.0
math.asin(x) Arcoseno math.asin(1) 1.5708 (π/2)
math.degrees(x) Radianes a grados math.degrees(math.pi) 180.0
math.radians(x) Grados a radianes math.radians(180) 3.14159 (π)
📈 Logaritmos math.log(x) Logaritmo natural (base e) math.log(math.e) 1.0
math.log10(x) Logaritmo base 10 math.log10(100) 2.0
math.log(x, base) Logaritmo en base específica math.log(32, 2) 5.0
📏 Geometría math.dist(p1, p2) Distancia euclidiana math.dist([0,0], [3,4]) 5.0
math.hypot(x, y) Hipotenusa math.hypot(3, 4) 5.0
🎲 Combinatoria math.factorial(n) Factorial de n math.factorial(5) 120
math.comb(n, k) Combinaciones math.comb(5, 2) 10
math.perm(n, k) Permutaciones math.perm(5, 2) 20
✅ Verificación math.isclose(a, b) Compara flotantes math.isclose(0.1+0.2, 0.3) True
math.isfinite(x) Es número finito math.isfinite(100) True
math.isnan(x) Es "Not a Number" math.isnan(float('nan')) True
math.gcd(a, b) Máximo común divisor math.gcd(48, 18) 6

Funciones Organizadas por Importancia:

🥇 Imprescindibles (Usar Siempre):

import math

# === REDONDEO Y ABSOLUTO ===
print(f"round(3.14159, 2): {round(3.14159, 2)}")     # 3.14
print(f"abs(-5): {abs(-5)}")                       # 5
print(f"math.ceil(4.2): {math.ceil(4.2)}")         # 5
print(f"math.floor(4.8): {math.floor(4.8)}")       # 4

# === POTENCIAS Y RAÍCES ===
print(f"math.sqrt(16): {math.sqrt(16)}")           # 4.0
print(f"math.pow(3, 4): {math.pow(3, 4)}")         # 81.0
print(f"3**4: {3**4}")                           # 81 (alternativa más común)

# === TRIGONOMETRÍA BÁSICA ===
angulo_45_grados = math.pi / 4  # 45° en radianes
print(f"sin(45°): {math.sin(angulo_45_grados):.3f}")  # 0.707
print(f"cos(45°): {math.cos(angulo_45_grados):.3f}")  # 0.707

# === CONVERSIONES ESENCIALES ===
print(f"90° en radianes: {math.radians(90):.3f}")    # 1.571 (π/2)
print(f"π/2 en grados: {math.degrees(math.pi/2)}")   # 90.0

🥈 Muy Útiles (Para Estudiantes Avanzados):

import math
import statistics  # Para estadísticas básicas

# === DISTANCIAS Y GEOMETRÍA ===
punto_A = (1, 2)
punto_B = (4, 6)
distancia = math.dist(punto_A, punto_B)
print(f"Distancia entre {punto_A} y {punto_B}: {distancia:.2f}")  # 5.00

# Teorema de Pitágoras (catetos 3 y 4)
hipotenusa = math.hypot(3, 4)
print(f"Hipotenusa de catetos 3 y 4: {hipotenusa}")     # 5.0

# === ESTADÍSTICAS BÁSICAS ===
calificaciones = [85, 92, 78, 96, 88]
promedio = statistics.mean(calificaciones)
mediana = statistics.median(calificaciones)
print(f"Promedio: {promedio:.1f}, Mediana: {mediana}")    # 87.8, 88

# === MATEMÁTICAS DISCRETAS ===
print(f"5! = {math.factorial(5)}")                    # 120
print(f"MCD(48, 18) = {math.gcd(48, 18)}")             # 6

# === COMPARACIÓN SEGURA DE FLOTANTES ===
resultado = 0.1 + 0.2
es_igual_a_03 = math.isclose(resultado, 0.3)
print(f"0.1 + 0.2 ≈ 0.3? {es_igual_a_03}")            # True

🥉 Avanzadas (Para Proyectos Especiales):

import math
import statistics

# === COMBINATORIA (Python 3.8+) ===
n_estudiantes = 5
equipos_de_2 = math.comb(n_estudiantes, 2)
print(f"Equipos de 2 personas con {n_estudiantes} estudiantes: {equipos_de_2}")  # 10

ordenamientos_2 = math.perm(n_estudiantes, 2)
print(f"Ordenamientos posibles de 2 personas: {ordenamientos_2}")  # 20

# === ESTADÍSTICA AVANZADA ===
datos_experimento = [23.1, 24.5, 22.8, 25.2, 23.9]
desviacion_std = statistics.stdev(datos_experimento)
print(f"Desviación estándar: {desviacion_std:.2f}")      # 0.94

# === LOGARITMOS ===
print(f"ln(e) = {math.log(math.e):.1f}")               # 1.0
print(f"log₁₀(1000) = {math.log10(1000)}")             # 3.0
print(f"log₂(32) = {math.log(32, 2)}")                # 5.0

# === VERIFICACIONES ÚTILES ===
valores_test = [100, float('inf'), float('nan')]
for valor in valores_test:
    finito = math.isfinite(valor)
    infinito = math.isinf(valor)
    no_numero = math.isnan(valor)
    print(f"{valor}: finito={finito}, infinito={infinito}, NaN={no_numero}")

🎨 Comparación Visual: Cómo se Ven las Tablas de Python

Estos son los mismos datos mostrados con diferentes librerías de Python:

Estilo Tabulate (fancy_grid)
Función Entrada Salida Categoría
math.sqrt() 16 4.0 Potencias
math.sin() π/2 1.0 Trigonometría
math.log10() 100 2.0 Logaritmos
math.factorial() 5 120 Combinatoria
Estilo Rich (colorido y moderno)
Función Entrada Salida Categoría
math.sqrt() 16 4.0 Potencias
math.sin() π/2 1.0 Trigonometría
math.log10() 100 2.0 Logaritmos
math.factorial() 5 120 Combinatoria
Estilo PrettyTable (ASCII clásico)
Función Entrada Salida Categoría
math.sqrt() 16 4.0 Potencias
math.sin() π/2 1.0 Trigonometría
math.log10() 100 2.0 Logaritmos
math.factorial() 5 120 Combinatoria

💻 Código Python que Genera Estas Tablas

# === CON TABULATE ===
from tabulate import tabulate

datos = [
    ["math.sqrt()", "16", "4.0", "Potencias"],
    ["math.sin()", "π/2", "1.0", "Trigonometría"],
    ["math.log10()", "100", "2.0", "Logaritmos"],
    ["math.factorial()", "5", "120", "Combinatoria"]
]
headers = ["Función", "Entrada", "Salida", "Categoría"]
print(tabulate(datos, headers=headers, tablefmt="fancy_grid"))

# === CON RICH ===
from rich.table import Table
from rich.console import Console

tabla = Table(title="Funciones Math", style="bold blue")
tabla.add_column("Función", style="cyan")
tabla.add_column("Entrada", style="yellow")
tabla.add_column("Salida", style="green")
tabla.add_column("Categoría", style="magenta")

for fila in datos:
    tabla.add_row(*fila)

Console().print(tabla)

# === CON PRETTYTABLE ===
from prettytable import PrettyTable

pt = PrettyTable()
pt.field_names = headers
for fila in datos:
    pt.add_row(fila)
print(pt)

Aplicaciones en Física y Matemáticas: La librería math es esencial para simular fenómenos físicos (trayectorias, ondas), resolver ecuaciones, trabajar con geometría, cálculo, estadística y mucho más. ¡Es una de las primeras herramientas que aprenderás a amar!

Creación de Tablas Elegantes en Python 📊

Aprende a presentar datos de forma profesional con las mejores librerías de Python para crear tablas

1. ¿Por Qué Usar Librerías de Tablas? 🤔

Cuando trabajas con datos en Python, mostrarlos de forma clara y organizada es fundamental. Aunque puedes usar print() simple, las librerías especializadas te permiten:

Visualización Clara

Datos organizados en filas y columnas con bordes y espaciado automático

Estilos Personalizables

Múltiples formatos: ASCII, HTML, Markdown, LaTeX y más

Exportación Fácil

Guarda tus tablas en diferentes formatos para reportes

📊 Antes vs Después: El Poder de las Tablas

Sin Librerías (difícil de leer)

# Datos desordenados con print()
print("Elemento Símbolo Número")
print("Hidrógeno H 1")
print("Helio He 2")
print("Litio Li 3")

Con Librerías (profesional)

# Tabla elegante y organizada
┌───────────┬─────────┬────────┐
│ Elemento  │ Símbolo │ Número │
├───────────┼─────────┼────────┤
│ Hidrógeno │ H       │ 1      │
│ Helio     │ He      │ 2      │
│ Litio     │ Li      │ 3      │
└───────────┴─────────┴────────┘

2. Instalación de las Librerías 📥

Antes de usar estas poderosas herramientas, necesitas instalarlas. Todas se instalan fácilmente con pip:

Tabulate Fácil Clásico

La más simple y directa. Perfecta para principiantes.

pip install tabulate

Rich Moderno Colorido

La más moderna y colorida. Ideal para aplicaciones interactivas.

pip install rich

PrettyTable Clásico Flexible

Veterana y confiable. Gran control sobre el formato.

pip install prettytable

Tip: Para verificar que se instalaron correctamente, prueba importarlas:

import tabulate
import rich
import prettytable
print("✅ ¡Todas las librerías instaladas!")

3. Sintaxis Básica: Creando Tu Primera Tabla 🚀

Todas las librerías siguen un patrón similar: datos + encabezados = tabla. Veamos cómo funciona cada una:

Tabulate: Simple y Directa

from tabulate import tabulate

# Paso 1: Preparar los datos (lista de listas)
datos = [
    ["Mercurio", 4879, 57.9],
    ["Venus", 12104, 108.2],
    ["Tierra", 12756, 149.6]
]

# Paso 2: Definir los encabezados
encabezados = ["Planeta", "Diámetro (km)", "Distancia al Sol (millones km)"]

# Paso 3: Crear la tabla
tabla = tabulate(datos, headers=encabezados, tablefmt="grid")
print(tabla)

📋 Resultado:

+----------+---------------+--------------------------------+
| Planeta  | Diámetro (km) | Distancia al Sol (millones km) |
+==========+===============+================================+
| Mercurio | 4879          | 57.9                           |
+----------+---------------+--------------------------------+
| Venus    | 12104         | 108.2                          |
+----------+---------------+--------------------------------+
| Tierra   | 12756         | 149.6                          |
+----------+---------------+--------------------------------+

Rich: Colorida y Moderna

from rich.table import Table
from rich.console import Console

# Paso 1: Crear objeto tabla
tabla = Table(title="🌍 Planetas del Sistema Solar")

# Paso 2: Añadir columnas con estilos
tabla.add_column("Planeta", style="cyan", no_wrap=True)
tabla.add_column("Diámetro (km)", style="magenta")
tabla.add_column("Distancia al Sol", style="green")

# Paso 3: Añadir filas
tabla.add_row("Mercurio", "4,879", "57.9 millones km")
tabla.add_row("Venus", "12,104", "108.2 millones km")
tabla.add_row("Tierra", "12,756", "149.6 millones km")

# Paso 4: Mostrar la tabla
console = Console()
console.print(tabla)

✨ Características Especiales:

PrettyTable: Control Total

from prettytable import PrettyTable

# Paso 1: Crear objeto tabla
tabla = PrettyTable()

# Paso 2: Definir columnas
tabla.field_names = ["Planeta", "Diámetro (km)", "Distancia al Sol"]

# Paso 3: Añadir filas una por una
tabla.add_row(["Mercurio", 4879, "57.9 millones km"])
tabla.add_row(["Venus", 12104, "108.2 millones km"])
tabla.add_row(["Tierra", 12756, "149.6 millones km"])

# Paso 4: Personalizar apariencia
tabla.align["Planeta"] = "l"  # Alinear a la izquierda
tabla.align["Diámetro (km)"] = "r"  # Alinear a la derecha

print(tabla)

🎯 Ventajas:

4. Creando Tablas desde Diferentes Estructuras 📦

📋 Desde Listas de Listas 

# Ejemplo: Tabla Periódica (primeros elementos)
from tabulate import tabulate

# Datos como lista de listas
elementos = [
    ["H", "Hidrógeno", 1, 1.008],
    ["He", "Helio", 2, 4.003],
    ["Li", "Litio", 3, 6.941],
    ["Be", "Berilio", 4, 9.012],
    ["B", "Boro", 5, 10.81]
]

print(tabulate(
    elementos,
    headers=["Símbolo", "Nombre", "Número Atómico", "Masa Atómica"],
    tablefmt="fancy_grid",
    floatfmt=".3f"  # Formato para decimales
))

📚 Desde Diccionarios 

# Ejemplo: Propiedades Físicas de Materiales
from rich.table import Table
from rich.console import Console

# Datos como diccionario
materiales = {
    "Diamante": {"dureza": 10, "densidad": 3.52, "conductividad": "Excelente"},
    "Cuarzo": {"dureza": 7, "densidad": 2.65, "conductividad": "Baja"},
    "Oro": {"dureza": 2.5, "densidad": 19.3, "conductividad": "Excelente"},
    "Grafito": {"dureza": 1.5, "densidad": 2.26, "conductividad": "Buena"}
}

# Crear tabla Rich
tabla = Table(title="💎 Propiedades de Materiales")
tabla.add_column("Material", style="bold cyan")
tabla.add_column("Dureza (Mohs)", justify="center")
tabla.add_column("Densidad (g/cm³)", justify="center")
tabla.add_column("Conductividad", justify="center")

# Añadir datos del diccionario
for material, props in materiales.items():
    tabla.add_row(
        material,
        str(props["dureza"]),
        f"{props['densidad']:.2f}",
        props["conductividad"]
    )

Console().print(tabla)

🗂️ Desde Lista de Diccionarios (Más Común) 

# Ejemplo: Notas Musicales y Frecuencias
from prettytable import PrettyTable

# Datos como lista de diccionarios (muy común en APIs y JSON)
notas_musicales = [
    {"nota": "Do", "frecuencia": 261.63, "octava": 4, "tecla": "Blanca"},
    {"nota": "Re", "frecuencia": 293.66, "octava": 4, "tecla": "Blanca"},
    {"nota": "Mi", "frecuencia": 329.63, "octava": 4, "tecla": "Blanca"},
    {"nota": "Fa", "frecuencia": 349.23, "octava": 4, "tecla": "Blanca"},
    {"nota": "Sol", "frecuencia": 392.00, "octava": 4, "tecla": "Blanca"}
]

# Crear tabla desde los diccionarios
tabla = PrettyTable()

# Extraer automáticamente las columnas de las claves
tabla.field_names = list(notas_musicales[0].keys())

# Añadir todas las filas
for nota in notas_musicales:
    tabla.add_row([nota[key] for key in tabla.field_names])

# Personalización
tabla.align["frecuencia"] = "r"
tabla.float_format = ".2"

print(tabla)

Consejo Pro: La estructura más versátil es la lista de diccionarios. Es fácil de mantener, clara de leer, y es el formato que devuelven la mayoría de APIs y bases de datos.

5. Ejemplos Temáticos: Ciencia en Tablas 🔬

Exploremos 6 ejemplos prácticos que muestran cómo las tablas pueden hacer brillar tus datos científicos y educativos.

⚛️ Ejemplo 1: Tabla Periódica de los Elementos

Creemos una tabla con información detallada de los primeros 10 elementos químicos. 

from tabulate import tabulate
from rich.table import Table
from rich.console import Console

# Datos de los elementos químicos
elementos_quimicos = [
    {"simbolo": "H", "nombre": "Hidrógeno", "numero": 1, "masa": 1.008, "grupo": "No metal", "estado": "Gas"},
    {"simbolo": "He", "nombre": "Helio", "numero": 2, "masa": 4.003, "grupo": "Gas noble", "estado": "Gas"},
    {"simbolo": "Li", "nombre": "Litio", "numero": 3, "masa": 6.941, "grupo": "Metal alcalino", "estado": "Sólido"},
    {"simbolo": "Be", "nombre": "Berilio", "numero": 4, "masa": 9.012, "grupo": "Metal alcalinotérreo", "estado": "Sólido"},
    {"simbolo": "B", "nombre": "Boro", "numero": 5, "masa": 10.81, "grupo": "Metaloide", "estado": "Sólido"},
    {"simbolo": "C", "nombre": "Carbono", "numero": 6, "masa": 12.01, "grupo": "No metal", "estado": "Sólido"},
    {"simbolo": "N", "nombre": "Nitrógeno", "numero": 7, "masa": 14.01, "grupo": "No metal", "estado": "Gas"},
    {"simbolo": "O", "nombre": "Oxígeno", "numero": 8, "masa": 16.00, "grupo": "No metal", "estado": "Gas"},
    {"simbolo": "F", "nombre": "Flúor", "numero": 9, "masa": 19.00, "grupo": "Halógeno", "estado": "Gas"},
    {"simbolo": "Ne", "nombre": "Neón", "numero": 10, "masa": 20.18, "grupo": "Gas noble", "estado": "Gas"}
]

# === VERSIÓN CON TABULATE ===
print("\n🧪 TABLA PERIÓDICA CON TABULATE:")
# Preparar datos para tabulate
datos_tabla = [[e["simbolo"], e["nombre"], e["numero"], f"{e['masa']:.3f}", e["grupo"], e["estado"]] 
               for e in elementos_quimicos]

print(tabulate(
    datos_tabla,
    headers=["Símbolo", "Elemento", "Nº Atómico", "Masa Atómica", "Grupo", "Estado"],
    tablefmt="fancy_grid",
    numalign="center",
    stralign="left"
))

# === VERSIÓN CON RICH (más colorida) ===
print("\n✨ TABLA PERIÓDICA CON RICH:")
tabla_rich = Table(title="⚛️ Primeros 10 Elementos de la Tabla Periódica", title_style="bold red")

# Definir columnas con colores según el tipo de dato
tabla_rich.add_column("Símbolo", style="bold yellow", justify="center")
tabla_rich.add_column("Elemento", style="cyan")
tabla_rich.add_column("Nº Atómico", style="magenta", justify="center")
tabla_rich.add_column("Masa Atómica", style="green", justify="right")
tabla_rich.add_column("Grupo", style="blue")
tabla_rich.add_column("Estado", style="red", justify="center")

# Añadir filas con formato condicional
for elem in elementos_quimicos:
    # Color especial para gases
    estado_style = "bold red on white" if elem["estado"] == "Gas" else "blue"
    
    tabla_rich.add_row(
        elem["simbolo"],
        elem["nombre"],
        str(elem["numero"]),
        f"{elem['masa']:.3f}",
        elem["grupo"],
        f"[{estado_style}]{elem['estado']}[/{estado_style}]"
    )

Console().print(tabla_rich)

Aplicación: Esta tabla es perfecta para aplicaciones educativas de química. Puedes expandirla con configuración electrónica, electronegatividad, radio atómico, etc.

🌍 Ejemplo 2: Sistema Solar - Datos Planetarios

Exploremos nuestro sistema solar con datos fascinantes sobre cada planeta. 

from prettytable import PrettyTable
import math

# Datos completos del Sistema Solar
planetas = [
    {
        "nombre": "Mercurio",
        "diametro_km": 4879,
        "distancia_sol_mkm": 57.9,
        "periodo_orbital_dias": 88,
        "lunas": 0,
        "temperatura_c": "167°C",
        "tipo": "Rocoso"
    },
    {
        "nombre": "Venus",
        "diametro_km": 12104,
        "distancia_sol_mkm": 108.2,
        "periodo_orbital_dias": 225,
        "lunas": 0,
        "temperatura_c": "464°C",
        "tipo": "Rocoso"
    },
    {
        "nombre": "Tierra",
        "diametro_km": 12756,
        "distancia_sol_mkm": 149.6,
        "periodo_orbital_dias": 365,
        "lunas": 1,
        "temperatura_c": "15°C",
        "tipo": "Rocoso"
    },
    {
        "nombre": "Marte",
        "diametro_km": 6792,
        "distancia_sol_mkm": 227.9,
        "periodo_orbital_dias": 687,
        "lunas": 2,
        "temperatura_c": "-65°C",
        "tipo": "Rocoso"
    },
    {
        "nombre": "Júpiter",
        "diametro_km": 142984,
        "distancia_sol_mkm": 778.5,
        "periodo_orbital_dias": 4333,
        "lunas": 95,
        "temperatura_c": "-110°C",
        "tipo": "Gigante gaseoso"
    },
    {
        "nombre": "Saturno",
        "diametro_km": 120536,
        "distancia_sol_mkm": 1432.0,
        "periodo_orbital_dias": 10747,
        "lunas": 146,
        "temperatura_c": "-140°C",
        "tipo": "Gigante gaseoso"
    },
    {
        "nombre": "Urano",
        "diametro_km": 51118,
        "distancia_sol_mkm": 2867.0,
        "periodo_orbital_dias": 30589,
        "lunas": 27,
        "temperatura_c": "-195°C",
        "tipo": "Gigante helado"
    },
    {
        "nombre": "Neptuno",
        "diametro_km": 49528,
        "distancia_sol_mkm": 4515.0,
        "periodo_orbital_dias": 59800,
        "lunas": 16,
        "temperatura_c": "-200°C",
        "tipo": "Gigante helado"
    }
]

# Crear tabla con PrettyTable
tabla = PrettyTable()
tabla.title = "🌌 DATOS DEL SISTEMA SOLAR 🚀"

# Definir columnas
tabla.field_names = [
    "🪐 Planeta", 
    "📏 Diámetro (km)", 
    "☀️ Distancia (mill. km)",
    "🔄 Órbita (días)",
    "🌙 Lunas",
    "🌡️ Temp. Media",
    "🌍 Tipo"
]

# Añadir datos con formato
for planeta in planetas:
    # Calcular años terrestres para la órbita
    años_orbitales = planeta["periodo_orbital_dias"] / 365.25
    
    tabla.add_row([
        planeta["nombre"],
        f"{planeta['diametro_km']:,}",  # Formato con comas
        planeta["distancia_sol_mkm"],
        f"{planeta['periodo_orbital_dias']:,} ({años_orbitales:.1f} años)",
        planeta["lunas"],
        planeta["temperatura_c"],
        planeta["tipo"]
    ])

# Personalizar apariencia
tabla.align["🪐 Planeta"] = "l"
tabla.align["📏 Diámetro (km)"] = "r"
tabla.align["🌙 Lunas"] = "c"
tabla.align["🌍 Tipo"] = "c"

# Añadir una fila de resumen
tabla.add_row(["-"*10] * 7)  # Línea separadora
total_lunas = sum(p["lunas"] for p in planetas)
tabla.add_row([
    "TOTAL",
    "-",
    "-",
    "-",
    f"🌙 {total_lunas}",
    "-",
    "8 planetas"
])

print(tabla)

Dato Curioso: ¡Júpiter y Saturno tienen más de 240 lunas entre los dos! Las tablas nos ayudan a visualizar estas impresionantes cifras astronómicas.

💎 Ejemplo 3: Propiedades Físicas de Materiales

Comparemos las propiedades físicas de diferentes materiales usando múltiples estilos de tabla. 

from tabulate import tabulate

# Base de datos de materiales con propiedades físicas
materiales = [
    ["Diamante", 10.0, 3.52, 2000, "Excelente", "Transparente", "3567°C"],
    ["Grafito", 1.5, 2.26, 5000, "Excelente", "Opaco", "3642°C"],
    ["Cuarzo", 7.0, 2.65, 0.013, "Muy baja", "Transparente", "1670°C"],
    ["Oro", 2.5, 19.30, 318, "Excelente", "Opaco/Brillante", "1064°C"],
    ["Plata", 2.5, 10.49, 429, "Excelente", "Opaco/Brillante", "962°C"],
    ["Cobre", 3.0, 8.96, 401, "Excelente", "Opaco/Rojizo", "1085°C"],
    ["Hierro", 4.0, 7.87, 80, "Buena", "Opaco/Gris", "1538°C"],
    ["Aluminio", 2.5, 2.70, 237, "Excelente", "Opaco/Plateado", "660°C"],
    ["Vidrio", 5.5, 2.50, 1.0, "Muy baja", "Transparente", "1700°C"],
    ["Madera", 2.0, 0.70, 0.17, "Muy baja", "Opaco", "300°C"]
]

headers = [
    "Material", 
    "Dureza\n(Mohs)", 
    "Densidad\n(g/cm³)", 
    "Conductividad\nTérmica (W/m·K)",
    "Conductividad\nEléctrica",
    "Apariencia",
    "Punto de\nFusión"
]

# Mostrar con diferentes estilos de tabulate
print("\n💎 PROPIEDADES FÍSICAS - Estilo: grid")
print(tabulate(materiales, headers=headers, tablefmt="grid", floatfmt=".2f"))

print("\n💎 PROPIEDADES FÍSICAS - Estilo: pipe (Markdown)")
print(tabulate(materiales, headers=headers, tablefmt="pipe", floatfmt=".2f"))

print("\n💎 PROPIEDADES FÍSICAS - Estilo: orgtbl (Org-mode)")
print(tabulate(materiales, headers=headers, tablefmt="orgtbl", floatfmt=".2f"))

# Análisis adicional: encontrar extremos
print("\n📊 ANÁLISIS DE EXTREMOS:")
mas_duro = max(materiales, key=lambda x: x[1])
mas_denso = max(materiales, key=lambda x: x[2])
mejor_conductor_termico = max(materiales, key=lambda x: x[3])

print(f"🏆 Más duro: {mas_duro[0]} (Dureza: {mas_duro[1]})")
print(f"🏆 Más denso: {mas_denso[0]} (Densidad: {mas_denso[2]} g/cm³)")
print(f"🏆 Mejor conductor térmico: {mejor_conductor_termico[0]} ({mejor_conductor_termico[3]} W/m·K)")

Aplicación Práctica: Esta tabla es útil para ingenieros y científicos de materiales al seleccionar el material adecuado para cada aplicación.

🎵 Ejemplo 4: Notas Musicales y Frecuencias

Exploremos la relación matemática entre las notas musicales y sus frecuencias. 

from rich.table import Table
from rich.console import Console
from rich.text import Text

# Datos musicales: notas, frecuencias y características
notas_musicales = [
    {
        "nota": "Do (C)", 
        "frecuencia_hz": 261.63, 
        "octava": 4, 
        "tipo_tecla": "Blanca",
        "intervalo": "Tónica",
        "color_sinestesia": "Rojo",
        "longitud_onda_m": 1.31
    },
    {
        "nota": "Do# (C#)", 
        "frecuencia_hz": 277.18, 
        "octava": 4, 
        "tipo_tecla": "Negra",
        "intervalo": "2ª menor",
        "color_sinestesia": "Rojo oscuro",
        "longitud_onda_m": 1.24
    },
    {
        "nota": "Re (D)", 
        "frecuencia_hz": 293.66, 
        "octava": 4, 
        "tipo_tecla": "Blanca",
        "intervalo": "2ª mayor",
        "color_sinestesia": "Naranja",
        "longitud_onda_m": 1.17
    },
    {
        "nota": "Re# (D#)", 
        "frecuencia_hz": 311.13, 
        "octava": 4, 
        "tipo_tecla": "Negra",
        "intervalo": "3ª menor",
        "color_sinestesia": "Naranja oscuro",
        "longitud_onda_m": 1.10
    },
    {
        "nota": "Mi (E)", 
        "frecuencia_hz": 329.63, 
        "octava": 4, 
        "tipo_tecla": "Blanca",
        "intervalo": "3ª mayor",
        "color_sinestesia": "Amarillo",
        "longitud_onda_m": 1.04
    },
    {
        "nota": "Fa (F)", 
        "frecuencia_hz": 349.23, 
        "octava": 4, 
        "tipo_tecla": "Blanca",
        "intervalo": "4ª justa",
        "color_sinestesia": "Verde",
        "longitud_onda_m": 0.98
    },
    {
        "nota": "Fa# (F#)", 
        "frecuencia_hz": 369.99, 
        "octava": 4, 
        "tipo_tecla": "Negra",
        "intervalo": "5ª disminuida",
        "color_sinestesia": "Verde azulado",
        "longitud_onda_m": 0.93
    },
    {
        "nota": "Sol (G)", 
        "frecuencia_hz": 392.00, 
        "octava": 4, 
        "tipo_tecla": "Blanca",
        "intervalo": "5ª justa",
        "color_sinestesia": "Azul",
        "longitud_onda_m": 0.88
    },
    {
        "nota": "Sol# (G#)", 
        "frecuencia_hz": 415.30, 
        "octava": 4, 
        "tipo_tecla": "Negra",
        "intervalo": "6ª menor",
        "color_sinestesia": "Azul oscuro",
        "longitud_onda_m": 0.83
    },
    {
        "nota": "La (A)", 
        "frecuencia_hz": 440.00, 
        "octava": 4, 
        "tipo_tecla": "Blanca",
        "intervalo": "6ª mayor",
        "color_sinestesia": "Índigo",
        "longitud_onda_m": 0.78
    },
    {
        "nota": "La# (A#)", 
        "frecuencia_hz": 466.16, 
        "octava": 4, 
        "tipo_tecla": "Negra",
        "intervalo": "7ª menor",
        "color_sinestesia": "Púrpura",
        "longitud_onda_m": 0.74
    },
    {
        "nota": "Si (B)", 
        "frecuencia_hz": 493.88, 
        "octava": 4, 
        "tipo_tecla": "Blanca",
        "intervalo": "7ª mayor",
        "color_sinestesia": "Violeta",
        "longitud_onda_m": 0.70
    }
]

# Crear tabla Rich con estilo musical
console = Console()
tabla = Table(
    title="🎹 Escala Cromática - Octava 4 🎼", 
    title_style="bold magenta",
    caption="La frecuencia de referencia A4 = 440 Hz (afinación estándar)",
    caption_style="italic"
)

# Columnas con colores temáticos
tabla.add_column("🎵 Nota", style="bold cyan", no_wrap=True)
tabla.add_column("📊 Frecuencia (Hz)", style="yellow", justify="right")
tabla.add_column("🎹 Tecla", justify="center")
tabla.add_column("🎶 Intervalo", style="green")
tabla.add_column("🎨 Color", justify="center")
tabla.add_column("🌊 λ (m)", style="blue", justify="right")

# Añadir filas con formato condicional
for nota in notas_musicales:
    # Estilo especial para teclas negras
    tecla_style = "white on black" if nota["tipo_tecla"] == "Negra" else "black on white"
    
    # Color de sinestesia con el color real
    color_map = {
        "Rojo": "red", "Rojo oscuro": "dark_red",
        "Naranja": "orange3", "Naranja oscuro": "dark_orange",
        "Amarillo": "yellow", "Verde": "green",
        "Verde azulado": "cyan", "Azul": "blue",
        "Azul oscuro": "dark_blue", "Índigo": "blue_violet",
        "Púrpura": "purple", "Violeta": "violet"
    }
    
    color_style = color_map.get(nota["color_sinestesia"], "white")
    
    tabla.add_row(
        nota["nota"],
        f"{nota['frecuencia_hz']:.2f}",
        f"[{tecla_style}]{nota['tipo_tecla']}[/{tecla_style}]",
        nota["intervalo"],
        f"[{color_style}]⬤ {nota['color_sinestesia']}[/{color_style}]",
        f"{nota['longitud_onda_m']:.2f}"
    )

console.print(tabla)

# Cálculos adicionales interesantes
print("\n🔬 FÍSICA DE LA MÚSICA:")
print(f"📐 Razón de frecuencias entre octavas: 2:1")
print(f"📐 Razón de quinta justa (Do-Sol): {392.00/261.63:.3f}:1 ≈ 3:2")
print(f"📐 Velocidad del sonido usada: 343 m/s (a 20°C)")

Física Musical: La relación matemática entre las notas es fascinante. Cada octava duplica la frecuencia, y los intervalos musicales corresponden a razones matemáticas simples.

Fechas y Calendarios en Python 📆

Aprende a trabajar con fechas y generar calendarios usando la librería calendar de Python. Muy útil para programar eventos, llevar registros académicos, planificar experimentos y mucho más.

¿Qué es calendar?

calendar es una librería estándar de Python que te permite:

También facilita la creación de herramientas para planificación de clases, exámenes, experimentos y proyectos.

Ejemplo Básico: Mostrar un mes

import calendar

# Mostrar el calendario de junio de 2024
print(calendar.month(2024, 6))

Salida:
June 2024
Mo Tu We Th Fr Sa Su
1 2
3 4 5 6 7 8 9
10 11 12 13 14 15 16
...

Generar un Calendario Anual

import calendar

# Mostrar todo el calendario del año 2025
print(calendar.calendar(2025))

Saber qué día de la semana es una fecha

import calendar

# ¿Qué día de la semana fue el 20 de julio de 1969?
dia = calendar.weekday(1969, 7, 20)
dias = ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado', 'Domingo']
print(dias[dia])  # Salida: 'Domingo'

Aplicación: Perfecto para planificar experimentos, recordatorios de eventos históricos, o saber si una fecha cae fin de semana.

Encontrar todos los lunes de un mes

import calendar

# Todos los lunes de junio de 2024
año = 2024
mes = 6
cal = calendar.monthcalendar(año, mes)
lunes = [semana[0] for semana in cal if semana[0] != 0]
print(lunes)  # Ejemplo de salida: [3, 10, 17, 24]

Útil para planificar clases, reuniones semanales o rutinas de estudio.

Combina calendar y datetime para manipular fechas

import calendar
from datetime import datetime, timedelta

# Fecha actual
hoy = datetime.now()
print("Hoy es:", hoy.strftime("%d/%m/%Y"))

# ¿Cuántos días faltan para el próximo examen el 15 de junio?
proximo_examen = datetime(2024, 6, 15)
dias_faltan = (proximo_examen - hoy).days
print("Días para el examen:", dias_faltan)

Aplicación: Llevar un contador de días para exámenes, entregas o eventos importantes.

TIP: ¿Para qué usar calendar en matemáticas y física?