Python Master Completo

1. Fundamentos del Lenguaje

Python es un lenguaje interpretado, de alto nivel, tipado dinámico y fuertemente tipado. Todo en Python es un objeto.

Variables y Tipos Primitivos

No se declaran tipos explícitos. El tipo se infiere en tiempo de ejecución.

int: Enteros de precisión arbitraria (x = 10**100 es válido).
float: Punto flotante (IEEE 754, doble precisión).
bool: True y False (subclases de int, 1 y 0).
str: Cadenas inmutables Unicode. Soportan f-strings (f"Hola {nombre}").
None: El objeto nulo (Singleton).

Control de Flujo

La indentación (4 espacios) es obligatoria y define bloques de código. No hay llaves {}.

if x > 0:
    print("Positivo")
elif x == 0:
    print("Cero")
else:
    print("Negativo")

# Operador ternario
estado = "Activo" if is_active else "Inactivo"
          

Bucles (Loops)

for itera sobre cualquier iterable. while ejecuta mientras la condición sea cierta.

for i in range(5):  # 0, 1, 2, 3, 4
    if i == 2: continue
    print(i)
else:
    print("Terminó sin break")
          

2. Estructuras de Datos

Python posee estructuras integradas muy potentes y optimizadas en C.

Listas (`list`)

Secuencias mutables, ordenadas y heterogéneas.

lst = [1, "dos", 3.0]
lst.append(4)        # Añadir al final O(1)
x = lst.pop()        # Sacar del final O(1)
sub = lst[1:3]       # Slicing: desde índice 1 hasta 2
rev = lst[::-1]      # Copia invertida
          

Tuplas (`tuple`)

Secuencias inmutables. Más ligeras que las listas. Usadas para datos fijos y claves de diccionarios.

punto = (10, 20)
x, y = punto  # Desempaquetado (Unpacking)
          

Diccionarios (`dict`)

Mapas Hash (Tabla Hash). Claves inmutables, valores mutables. Búsqueda promedio O(1).

user = {"id": 1, "name": "Ana"}
valor = user.get("age", 18)  # Devuelve 18 si no existe 'age'
keys = user.keys()
items = user.items() # Pares (key, value)
          

Conjuntos (`set`)

Colección no ordenada de elementos únicos. Útiles para operaciones matemáticas (unión, intersección) y eliminar duplicados.

A = {1, 2, 3}
B = {3, 4, 5}
print(A & B) # Intersección: {3}
print(A | B) # Unión: {1, 2, 3, 4, 5}
          

3. Funciones y Modularidad

Funciones son objetos de primera clase (se pueden pasar como argumentos).

Argumentos

Posicionales: Estándar.
Nombrados (Keyword): func(a=1).
*args: Tupla de argumentos posicionales variables.
**kwargs: Diccionario de argumentos nombrados variables.

def super_func(a, b=0, *args, **kwargs):
    print(args)   # Tupla
    print(kwargs) # Diccionario

super_func(1, 2, 3, 4, mode="fast")
          

Funciones Lambda

Funciones anónimas de una sola línea. lambda x: x**2.

Ámbito (Scope) - LEGB

Local, Enclosing (nonlocal), Global, Built-in.

4. Programación Orientada a Objetos

Clases, herencia múltiple y encapsulamiento (convención _private).

Clases y Métodos Mágicos (Dunder)

Los métodos que empiezan y terminan con __ definen comportamientos especiales.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        # Sobrecarga operador +
        return Vector(self.x + other.x, self.y + other.y)
        
    def __str__(self):
        return f"({self.x}, {self.y})"
          

Propiedades y Métodos Estáticos

Uso de decoradores @property, @staticmethod, @classmethod.

5. Python Avanzado

Iteradores y Generadores

Un generador usa yield para devolver valores uno a uno, ahorrando memoria (Lazy evaluation).

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b
          

Decoradores

Funciones que modifican el comportamiento de otras funciones. Son "azúcar sintáctico" para funciones de orden superior.

def log(func):
    def wrapper(*args, **kwargs):
        print(f"Llamando a {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@log
def suma(a,b): return a+b
          

Gestores de Contexto (Context Managers)

El bloque with asegura la liberación de recursos (archivos, sockets, locks).

with open("file.txt", "r") as f:
    content = f.read()
# El archivo se cierra automáticamente aquí
          

Concurrencia: GIL y AsyncIO

El Global Interpreter Lock (GIL) impide que múltiples hilos nativos ejecuten bytecode Python a la vez. Para paralelismo real en CPU se usa multiprocessing. Para E/S (red, disco) se usa threading o asyncio (con async/await).

Nivel 1: Fundamentos (10)

1. Hola Mundo Avanzado Basic

Función que recibe nombre y edad, y retorna un f-string formateado.

def presentacion(nombre, edad):
    return f"Me llamo {nombre} y tengo {edad} años."

2. FizzBuzz Basic

for i in range(1, 101):
    if i % 3 == 0 and i % 5 == 0: print("FizzBuzz")
    elif i % 3 == 0: print("Fizz")
    elif i % 5 == 0: print("Buzz")
    else: print(i)

3. Invertir String Basic

s = "Python"
inv = s[::-1]  # Slicing con paso negativo

4. Contador de Vocales Basic

def contar_vocales(s):
    return sum(1 for c in s.lower() if c in 'aeiou')

5. Máximo de una lista Basic

nums = [10, 5, 8, 20]
max_val = max(nums)
# Manual:
m = nums[0]
for x in nums:
    if x > m: m = x

6. Tabla de Multiplicar Basic

n = 5
for i in range(1, 11):
    print(f"{n} x {i} = {n*i}")

7. Eliminar duplicados Basic

lista = [1, 2, 2, 3, 1]
unicos = list(set(lista))

8. Año Bisiesto Basic

def es_bisiesto(year):
    return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)

9. Factorial Recursivo Basic

def factorial(n):
    return 1 if n == 0 else n * factorial(n-1)

10. Suma de pares Basic

suma = sum(x for x in range(101) if x % 2 == 0)

Nivel 2: Intermedio (10)

11. Comprensión de Listas Inter

Cuadrados de números pares del 0 al 9.

[x**2 for x in range(10) if x % 2 == 0]

12. Diccionario de Frecuencias Inter

texto = "hola mundo hola"
freq = {}
for palabra in texto.split():
    freq[palabra] = freq.get(palabra, 0) + 1

13. Ordenar por clave en Dict Inter

data = [{"name": "A", "age": 30}, {"name": "B", "age": 25}]
ordenado = sorted(data, key=lambda x: x["age"])

14. Manejo de Archivos (CSV) Inter

import csv
with open('data.csv', newline='') as f:
    reader = csv.reader(f)
    for row in reader: print(row)

15. Clase Rectángulo Inter

class Rect:
    def __init__(self, w, h): self.w, self.h = w, h
    def area(self): return self.w * self.h

16. Decorador de Tiempo Inter

import time
def timer(func):
    def wrapper(*args, **kw):
        t1 = time.time()
        res = func(*args, **kw)
        print(time.time()-t1)
        return res
    return wrapper

17. Generador de Primos Inter

def gen_primos():
    n = 2
    while True:
        if all(n % i != 0 for i in range(2, int(n**0.5)+1)):
            yield n
        n += 1

18. Map y Filter Inter

nums = [1, 2, 3, 4]
res = list(map(lambda x: x*2, filter(lambda x: x%2==0, nums)))
# Resultado: [4, 8]

19. Argumentos *args **kwargs Inter

def suma_total(*args):
    return sum(args)
print(suma_total(1, 2, 3, 4)) # 10

20. Excepciones Personalizadas Inter

class MiError(Exception): pass
def check(x):
    if x < 0: raise MiError("Negativo!")

Nivel 3: Experto (10)

21. Metaclasses (Singleton) Adv

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class DB(metaclass=Singleton): pass

22. AsyncIO (Corrutinas) Adv

import asyncio
async def main():
    print("Hola")
    await asyncio.sleep(1)
    print("Mundo")
asyncio.run(main())

23. Context Manager (Clase) Adv

class Timer:
    def __enter__(self): self.start = time.time()
    def __exit__(self, *args): print(time.time() - self.start)

with Timer():
    time.sleep(1)

24. Context Manager (Generator) Adv

from contextlib import contextmanager
@contextmanager
def open_file(name):
    f = open(name, 'r')
    try: yield f
    finally: f.close()

25. Multiprocessing (CPU bound) Adv

from multiprocessing import Pool
def f(x): return x*x
if __name__ == '__main__':
    with Pool(5) as p:
        print(p.map(f, [1, 2, 3]))

26. Descriptores de Datos Adv

class Ten:
    def __get__(self, obj, objtype=None): return 10
class A:
    x = Ten()  # A().x siempre es 10

27. Decorador con Argumentos Adv

def repeat(n):
    def decorator(func):
        def wrapper(*args, **kw):
            for _ in range(n): func(*args, **kw)
        return wrapper
    return decorator

28. Web Scraping (BeautifulSoup) Adv

import requests
from bs4 import BeautifulSoup
html = requests.get("http://example.com").text
soup = BeautifulSoup(html, 'html.parser')
print(soup.title.string)

29. API REST con Flask Adv

from flask import Flask, jsonify
app = Flask(__name__)
@app.route('/')
def home(): return jsonify({"msg": "Hello"})
# app.run()

30. Type Hinting Complejo Adv

from typing import List, Dict, Union, Optional

def process(data: List[Dict[str, Union[int, str]]]) -> Optional[int]:
    return data[0]['id'] if data else None

Python Master Class