Las 10 librerías de Python más usadas en 2026

Una de las mayores ventajas de Python es su ecosistema. Hay miles de librerías disponibles, pero un conjunto pequeño concentra la mayoría del uso real en proyectos profesionales: ciencia de datos, desarrollo web, automatización, inteligencia artificial y herramientas de línea de comandos. Esta guía cubre las diez librerías que más vas a encontrar en el mundo laboral, qué hace cada una y cuándo usarla.

1. Requests — HTTP para humanos

Requests es la librería más descargada de todo el ecosistema Python. Su propósito es hacer peticiones HTTP de forma sencilla: consumir APIs, descargar páginas web, enviar formularios o interactuar con cualquier servicio web.

Antes de Requests, hacer una petición HTTP en Python requería varios pasos con la librería estándar urllib. Requests lo simplificó a una sola línea.

import requests

# Petición GET a una API pública
respuesta = requests.get("https://api.github.com/users/python")
datos = respuesta.json()
print(datos["name"])        # Python
print(respuesta.status_code)  # 200

# Petición POST con datos
payload = {"usuario": "ana", "accion": "login"}
r = requests.post("https://mi-api.com/auth", json=payload)
print(r.json())

# Con headers y parámetros de consulta
headers = {"Authorization": "Bearer mi_token"}
params  = {"pagina": 1, "limite": 20}
r = requests.get("https://api.ejemplo.com/productos", headers=headers, params=params)

Instalar: pip install requests

2. NumPy — computación numérica de alto rendimiento

NumPy es la base de prácticamente todo el ecosistema científico de Python. Introduce el array multidimensional (ndarray), una estructura de datos optimizada para operaciones matemáticas que es entre 10 y 100 veces más rápida que las listas de Python para cálculos numéricos.

Si vas a trabajar con datos, machine learning, imágenes o cualquier cálculo matemático serio, NumPy es el punto de partida obligatorio.

import numpy as np

# Crear arrays
a = np.array([1, 2, 3, 4, 5])
b = np.array([10, 20, 30, 40, 50])

# Operaciones vectorizadas (sin bucles)
print(a + b)          # [11 22 33 44 55]
print(a * 2)          # [ 2  4  6  8 10]
print(np.sqrt(a))     # [1.   1.41 1.73 2.   2.23]

# Arrays multidimensionales
matriz = np.zeros((3, 4))          # matriz 3x4 de ceros
identidad = np.eye(3)              # matriz identidad 3x3
aleatorio = np.random.rand(5, 5)   # matriz 5x5 con valores aleatorios

# Operaciones estadísticas
datos = np.array([23, 45, 12, 67, 34, 89, 15])
print(np.mean(datos))    # media
print(np.median(datos))  # mediana
print(np.std(datos))     # desviación estándar
print(np.sort(datos))    # ordenar

Instalar: pip install numpy

3. Pandas — análisis y manipulación de datos

Pandas es la librería de referencia para trabajar con datos tabulares en Python. Introduce el DataFrame, una estructura similar a una hoja de cálculo o a una tabla de base de datos, que permite cargar, limpiar, transformar y analizar datos con una sintaxis muy expresiva.

Si vienes del mundo de Excel o SQL, Pandas te resultará muy familiar.

import pandas as pd

# Crear un DataFrame
datos = {
    "nombre":      ["Ana", "Carlos", "María", "Luis"],
    "departamento": ["Dev", "Diseño", "Dev", "Marketing"],
    "salario":     [4500, 3800, 5200, 4100],
    "activo":      [True, True, False, True]
}
df = pd.DataFrame(datos)

# Explorar el DataFrame
print(df.head())          # primeras 5 filas
print(df.info())          # tipos de datos y valores nulos
print(df.describe())      # estadísticas descriptivas

# Filtrar filas
devs = df[df["departamento"] == "Dev"]
activos_con_buen_salario = df[(df["activo"] == True) & (df["salario"] > 4000)]

# Agrupar y agregar
por_depto = df.groupby("departamento")["salario"].mean()
print(por_depto)

# Leer y escribir archivos
df = pd.read_csv("empleados.csv")
df_limpio = df.dropna()                  # elimina filas con valores nulos
df_limpio.to_csv("empleados_limpios.csv", index=False)
df.to_json("empleados.json", orient="records", force_ascii=False)

Instalar: pip install pandas

4. Matplotlib — visualización de datos

Matplotlib es la librería de visualización más veterana y usada de Python. Genera gráficos de líneas, barras, dispersión, histogramas, tartas y docenas de tipos más, tanto para análisis exploratorio como para informes y publicaciones.

import matplotlib.pyplot as plt
import numpy as np

# Gráfico de líneas
x = np.linspace(0, 2 * np.pi, 100)
plt.figure(figsize=(10, 4))
plt.plot(x, np.sin(x), label="seno", color="steelblue")
plt.plot(x, np.cos(x), label="coseno", color="tomato", linestyle="--")
plt.title("Funciones trigonométricas")
plt.xlabel("x")
plt.ylabel("y")
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.savefig("grafico.png", dpi=150)
plt.show()

# Gráfico de barras
categorias = ["Ene", "Feb", "Mar", "Abr", "May"]
ventas     = [1200, 1850, 1600, 2100, 1900]
plt.bar(categorias, ventas, color="steelblue")
plt.title("Ventas mensuales")
plt.ylabel("Unidades")
plt.show()

# Histograma
datos = np.random.randn(1000)
plt.hist(datos, bins=30, edgecolor="white", color="mediumpurple")
plt.title("Distribución normal")
plt.show()

Instalar: pip install matplotlib

5. Scikit-learn — machine learning clásico

Scikit-learn es la librería de machine learning más popular de Python para algoritmos clásicos: regresión, clasificación, clustering, reducción de dimensionalidad y preprocesado de datos. Tiene una API consistente y muy bien documentada que sigue siempre el mismo patrón: crear el modelo, ajustarlo con fit() y predecir con predict().

from sklearn.model_selection import train_test_split
from sklearn.preprocessing   import StandardScaler
from sklearn.linear_model    import LogisticRegression
from sklearn.metrics         import accuracy_score, classification_report
from sklearn.datasets        import load_iris

# Cargar datos de ejemplo
iris = load_iris()
X, y = iris.data, iris.target

# Dividir en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Escalar características
scaler  = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test  = scaler.transform(X_test)

# Entrenar modelo
modelo = LogisticRegression(max_iter=200)
modelo.fit(X_train, y_train)

# Evaluar
predicciones = modelo.predict(X_test)
print(f"Precisión: {accuracy_score(y_test, predicciones):.2%}")
print(classification_report(y_test, predicciones, target_names=iris.target_names))

Instalar: pip install scikit-learn

6. FastAPI — APIs modernas y de alto rendimiento

FastAPI es el framework web de mayor crecimiento en Python en los últimos años. Está diseñado para construir APIs REST rápidas, con validación automática de datos basada en type hints, documentación interactiva generada automáticamente y rendimiento comparable a frameworks de Node.js y Go.

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing   import Optional

app = FastAPI(title="Mi API", version="1.0.0")

# Modelo de datos con validación automática
class Producto(BaseModel):
    nombre:      str
    precio:      float
    descripcion: Optional[str] = None
    disponible:  bool = True

# Base de datos simulada
productos = {}

@app.get("/")
def inicio():
    return {"mensaje": "API funcionando"}

@app.get("/productos/{producto_id}")
def obtener_producto(producto_id: int):
    if producto_id not in productos:
        raise HTTPException(status_code=404, detail="Producto no encontrado")
    return productos[producto_id]

@app.post("/productos/", status_code=201)
def crear_producto(producto_id: int, producto: Producto):
    if producto_id in productos:
        raise HTTPException(status_code=400, detail="El producto ya existe")
    productos[producto_id] = producto
    return producto

@app.put("/productos/{producto_id}")
def actualizar_producto(producto_id: int, producto: Producto):
    if producto_id not in productos:
        raise HTTPException(status_code=404, detail="Producto no encontrado")
    productos[producto_id] = producto
    return producto

Al ejecutar la aplicación con uvicorn main:app --reload, FastAPI genera automáticamente documentación interactiva en /docs (Swagger UI) y /redoc.

Instalar: pip install fastapi uvicorn

7. SQLAlchemy — bases de datos relacionales con Python

SQLAlchemy es el ORM (Object-Relational Mapper) más completo de Python. Permite interactuar con bases de datos relacionales (PostgreSQL, MySQL, SQLite) usando objetos Python en lugar de escribir SQL directamente, aunque también puedes ejecutar SQL puro cuando lo necesites.

from sqlalchemy import create_engine, Column, Integer, String, Float, Boolean
from sqlalchemy.orm  import DeclarativeBase, Session

# Conectar a SQLite (para producción cambia por postgresql://...)
engine = create_engine("sqlite:///tienda.db", echo=False)

class Base(DeclarativeBase):
    pass

class Producto(Base):
    __tablename__ = "productos"

    id          = Column(Integer, primary_key=True)
    nombre      = Column(String(100), nullable=False)
    precio      = Column(Float, nullable=False)
    disponible  = Column(Boolean, default=True)

    def __repr__(self):
        return f"Producto(id={self.id}, nombre={self.nombre}, precio={self.precio})"

# Crear las tablas
Base.metadata.create_all(engine)

# Insertar registros
with Session(engine) as session:
    productos = [
        Producto(nombre="Laptop",  precio=1299.99, disponible=True),
        Producto(nombre="Teclado", precio=89.99,   disponible=True),
        Producto(nombre="Monitor", precio=399.99,  disponible=False),
    ]
    session.add_all(productos)
    session.commit()

# Consultar
with Session(engine) as session:
    disponibles = session.query(Producto).filter_by(disponible=True).all()
    for p in disponibles:
        print(p)

    # Actualizar
    laptop = session.query(Producto).filter_by(nombre="Laptop").first()
    laptop.precio = 1199.99
    session.commit()

Instalar: pip install sqlalchemy

8. Pydantic — validación de datos con type hints

Pydantic valida datos usando las anotaciones de tipo de Python. Es el estándar de facto para validar entradas en APIs, leer configuraciones y garantizar que los datos tienen la forma correcta antes de procesarlos. FastAPI lo usa internamente, pero también es muy útil por sí solo.

from pydantic import BaseModel, EmailStr, field_validator, model_validator
from typing   import Optional
from datetime import date

class Usuario(BaseModel):
    nombre:    str
    email:     str
    edad:      int
    fecha_alta: date = date.today()
    rol:       Optional[str] = "usuario"

    @field_validator("nombre")
    @classmethod
    def nombre_no_vacio(cls, v):
        if not v.strip():
            raise ValueError("El nombre no puede estar vacío.")
        return v.strip().title()

    @field_validator("edad")
    @classmethod
    def edad_valida(cls, v):
        if not (0 < v < 120):
            raise ValueError("La edad debe estar entre 1 y 119.")
        return v


# Validación automática al crear la instancia
usuario = Usuario(nombre="  ana garcía  ", email="ana@mail.com", edad=28)
print(usuario.nombre)      # Ana García  (normalizado)
print(usuario.fecha_alta)  # 2026-05-31

# Error de validación
try:
    malo = Usuario(nombre="", email="no-es-email", edad=200)
except Exception as e:
    print(e)

# Convertir a diccionario o JSON
print(usuario.model_dump())
print(usuario.model_dump_json())

Instalar: pip install pydantic

9. Pytest — testing profesional en Python

Pytest es el framework de testing más popular de Python. Permite escribir pruebas unitarias e de integración de forma clara y sin boilerplate. Detecta automáticamente los archivos de test, ofrece mensajes de error descriptivos y tiene un ecosistema enorme de plugins.

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

def dividir(a, b):
    if b == 0:
        raise ValueError("No se puede dividir por cero.")
    return a / b

def es_par(n):
    return n % 2 == 0

# archivo: test_calculadora.py
import pytest
from calculadora import sumar, dividir, es_par

# Tests simples
def test_sumar():
    assert sumar(2, 3) == 5
    assert sumar(-1, 1) == 0
    assert sumar(0, 0) == 0

def test_dividir():
    assert dividir(10, 2) == 5.0
    assert dividir(7, 2) == 3.5

def test_dividir_por_cero():
    with pytest.raises(ValueError, match="No se puede dividir por cero"):
        dividir(10, 0)

# Test parametrizado: prueba múltiples casos con una sola función
@pytest.mark.parametrize("numero, esperado", [
    (2, True),
    (3, False),
    (0, True),
    (-4, True),
    (7, False),
])
def test_es_par(numero, esperado):
    assert es_par(numero) == esperado

# Fixture: configuración reutilizable entre tests
@pytest.fixture
def datos_ejemplo():
    return [10, 20, 30, 40, 50]

def test_suma_lista(datos_ejemplo):
    assert sumar(datos_ejemplo[0], datos_ejemplo[1]) == 30

Ejecutar los tests con pytest -v muestra el resultado de cada prueba individualmente. pytest --tb=short muestra solo el fragmento relevante del traceback en caso de fallo.

Instalar: pip install pytest

10. Celery — tareas asíncronas y en segundo plano

Celery es la librería estándar para ejecutar tareas en segundo plano y de forma distribuida en Python. Es indispensable en aplicaciones web cuando necesitas realizar operaciones que tardan tiempo sin bloquear la respuesta al usuario: enviar correos, procesar imágenes, generar PDFs, importar datos o cualquier tarea que no deba ejecutarse en tiempo real.

Celery necesita un broker de mensajes para funcionar, habitualmente Redis o RabbitMQ.

# archivo: tareas.py
from celery import Celery
import time

# Configurar Celery con Redis como broker
app = Celery("tareas", broker="redis://localhost:6379/0", backend="redis://localhost:6379/0")

@app.task
def enviar_email(destinatario, asunto, cuerpo):
    """Simula el envío de un correo electrónico"""
    time.sleep(2)   # simula el tiempo que tarda el servidor de correo
    print(f"Email enviado a {destinatario}: {asunto}")
    return {"estado": "enviado", "destinatario": destinatario}

@app.task
def procesar_imagen(ruta_imagen):
    """Simula el procesamiento de una imagen"""
    time.sleep(5)
    return {"ruta": ruta_imagen, "estado": "procesada"}

# archivo: app.py  (tu aplicación web o script principal)
from tareas import enviar_email, procesar_imagen

# Encolar la tarea (no bloquea, retorna inmediatamente)
resultado = enviar_email.delay("usuario@mail.com", "Bienvenido", "Gracias por registrarte.")
print(f"Tarea encolada con ID: {resultado.id}")

# Verificar el estado de la tarea más adelante
print(resultado.status)   # PENDING, STARTED, SUCCESS, FAILURE
print(resultado.get())    # espera el resultado (bloqueante)

Ejecutar el worker: celery -A tareas worker --loglevel=info

Instalar: pip install celery redis

Resumen comparativo

¿Por dónde empezar?

Si estás empezando, no intentes aprender las diez a la vez. El camino más natural depende de lo que quieras construir:

• Ciencia de datos o IA: empieza por NumPy, luego Pandas, luego Matplotlib y finalmente Scikit-learn. Es la progresión que sigue prácticamente cualquier curso del área.
• Desarrollo web y APIs: empieza por Requests para entender HTTP, luego FastAPI para crear tus propias APIs, añade Pydantic (que FastAPI ya incluye) y SQLAlchemy cuando necesites una base de datos.
• Cualquier proyecto: añade Pytest desde el principio. Escribir tests desde el inicio es un hábito que te ahorrará horas de depuración.

Estas diez librerías no son solo las más descargadas: son las que aparecen en las ofertas de trabajo, en los proyectos open source y en los equipos de desarrollo. Dominarlas te coloca en una posición sólida para trabajar con Python a nivel profesional.