Clases y métodos especiales en Python

__all__ = ["Hijo", "Padre"]  # Controla las importaciones con from modulo import *

class Hijo(Padre):
    def __init__(self):
        super().__init__()
    
    def __call__(self, param):  # Permite invocar el objeto como una función
        pass

    def __len__(self):  # Habilita el uso de len(objeto)
        pass

    def __iter__(self):  # Facilita la iteración con for elemento in objeto
        pass

    def __getitem__(self, idx):  # Permite el acceso mediante objeto[indice]
        pass

    def __str__(self):  # Define la representación con str(objeto)
        pass

    def __repr__(self):
        pass

Manipulación de cadenas de texto

"CONTIENE" in "texto_contiene_subcadena"  # Devuelve True

cadena.lstrip().rstrip()  # Elimina espacios en blanco al inicio y final
lista_partes = texto.split(separador)  # Divide la cadena en una lista

Variables de entorno con os

import os

os.environ["mi_variable"] = "valor_personalizado"  # Establece una variable de entorno

Operaciones con archivos y directorios

import os, shutil, glob

ruta_completa = os.path.join(directorio1, directorio2, archivo)
archivos = glob.glob(patron_ruta)  # Retorna lista de archivos que coinciden, sin recursión
archivos.sort()

nombre_archivo = os.path.basename(ruta_completa)  # Extrae el nombre del archivo
lista_contenido = os.listdir(ruta_directorio)  # Lista archivos y carpetas en un directorio

shutil.copy(origen, destino)  # Copia un archivo
shutil.rmtree(ruta_directorio)  # Elimina un directorio recursivamente
os.remove(ruta_archivo)  # Elimina un archivo específico
os.rename(nombre_antiguo, nombre_nuevo)  # Renombra archivo o directorio
shutil.move(origen, destino)  # Mueve un archivo o directorio

Visualización con Matplotlib

import matplotlib.pyplot as plt
import numpy as np

# Mostrar una imagen desde un arreglo NumPy
plt.imshow(datos_imagen)
plt.axis('off')  # Oculta los ejes para una visualización limpia
plt.show()

# Gráfico de dispersión
x_vals = np.linspace(0, 10, 50)
y_vals = np.sin(x_vals)
plt.scatter(x_vals, y_vals, color='green', marker='o', size=10)
plt.title("Gráfico de Dispersión")
plt.show()

# Gráfico de líneas
plt.plot(x_vals, y_vals, label='Función seno', color='orange', linewidth=2)
plt.xlabel("Eje X")
plt.ylabel("Eje Y")
plt.legend(loc='best')
plt.savefig("grafico_lineas.pdf", format='pdf')
plt.show()

# Gráfico circular
proporciones = [40, 30, 20, 10]
plt.pie(proporciones, labels=['A', 'B', 'C', 'D'])
plt.show()

# Histograma para distribución de datos
datos_histograma = np.random.normal(0, 1, 1000)
plt.hist(datos_histograma, bins=30, edgecolor='black')
plt.show()

Serialización con JSON

import json

diccionario = {
    "clave": "valor",
    "lista": [1, 2, 3]
}
cadena_json = json.dumps(diccionario, indent=2)  # Convierte objeto a cadena JSON

objeto_original = json.loads(cadena_json)  # Parsea cadena JSON a objeto Python

Gestión del tiempo

import time
from datetime import datetime

marca_temporal = time.time()  # Obtiene el tiempo actual en segundos desde época
ahora = datetime.now()  # Retorna fecha y hora actual como objeto datetime

DataFrames con Pandas y Polars

import pandas as pd

# Configuración de visualización
pd.set_option('display.width', None)
pd.set_option('display.max_rows', 100)
pd.set_option('display.max_columns', 50)

# Lectura y escritura de datos
df = pd.read_csv("datos.csv")  # Desde CSV
df = pd.read_excel("datos.xlsx")  # Desde Excel
df.to_parquet("salida.parquet", index=False)  # Guardar en formato Parquet

# Selección de datos
subset_columnas = df[['col1', 'col2']]
fila_especifica = df.at[0, 'col1']  # Acceso rápido a un valor escalar

# Exploración básica
primeras_filas = df.head(5)
ultimas_filas = df.tail(3)
total_filas = len(df)

# Eliminación de duplicados
df_unique = df.drop_duplicates(subset=['campo_clave'])

# Creación de nuevas columnas
df['nueva_col'] = df['col_a'] * df['col_b']

# Iteración (no recomendado para grandes datasets)
for _, fila in df.iterrows():
    proceso = fila['columna']

# Filtrado de datos
filtro_simple = df[df['estado'].isin(['activo', 'pendiente'])]
filtro_compuesto = df[(df['valor'] > 100) & (df['categoria'] == 'A')]

# Agrupación y agregación
grupo = df.groupby(['grupo1', 'grupo2'])
conteo_grupo = grupo.size().reset_index(name='conteo')

# Unión de DataFrames
df_merged = pd.merge(
    df1,
    df2[['col_relevante']],
    left_on='id_comun',
    right_on='id',
    how='left',
    suffixes=('_original', '_nueva')
)

# Copia profunda
df_copia = df.copy()

# Reinicio de índice
df_reiniciado = df.reset_index(drop=True)

import polars as pl  # Alternativa moderna para manipulación de datos

Patrón Singleton con hilos

import threading

class Singleton:
    _bloqueo = threading.Lock()
    _instancia = None

    def __new__(cls, *args, **kwargs):
        if cls._instancia is None:
            with cls._bloqueo:
                if cls._instancia is None:
                    cls._instancia = super().__new__(cls)
        return cls._instancia

Consumo de APIs con requests

import requests
from time import sleep

url_api = "https://api.ejemplo.com/datos"
cabeceras = {"Autorización": "token_ejemplo"}
parametros = {"pagina": 1}

respuesta = requests.get(
    url=url_api,
    headers=cabeceras,
    params=parametros,
    proxies={"http": "http://proxy.local:8080"},
    timeout=30
)
if respuesta.status_code == 200:
    datos_json = respuesta.json()
    sleep(1)  # Espera para evitar sobrecarga

Conexión a bases de datos MySQL

# Requiere instalar mysql-connector-python
import mysql.connector

conexion = mysql.connector.connect(
    host="localhost",
    usuario="admin",
    contraseña="secreto",
    base_datos="mi_bd"
)
cursor = conexion.cursor()
cursor.execute("SELECT * FROM tabla_ejemplo")
resultados = cursor.fetchall()
conexion.close()

Cálculos numéricos con NumPy

import numpy as np

matriz_a = np.array([[1, 2], [3, 4]])
matriz_b = np.array([[5], [6]])

# Multiplicación de matrices
producto = np.dot(matriz_a, matriz_b)  # También: producto = matriz_a @ matriz_b
print(producto)