Introducción a Python

La abstracción de proceso es la capacidad de usar una función conociendo solo qué hace — sus entradas y su salida — sin necesitar saber cómo lo hace internamente. Ejemplos de clases anteriores: sorted() — ordena una lista sin revelar el algoritmo; sum() — suma los elementos sin mostrar el bucle; dict.get() — accede con valor por defecto sin exponer la lógica interna.

Con la versión sin funciones, habría que copiar y pegar el bloque completo diez veces — con el riesgo de introducir errores en cada copia. Con calcular_media(datos), basta con llamarla diez veces con cada lista. Si hay un error en el cálculo, se corrige en un único lugar y afecta a todos los usos.

Las funciones pequeñas permiten verificar cada parte por separado antes de combinarlas. Si un script de 200 líneas falla, no sabes en qué parte está el error. Si falla una función de 10 líneas, el problema está acotado. Además, si la IA genera una función incorrecta, puedes pedirle que la corrija o sustituirla sin tocar el resto.

saludar tiene tipo <class 'function'>. len tiene tipo <class 'builtin_function_or_method'>. Ambos tienen id — son objetos en memoria como cualquier lista o número. Esto confirma que en Python las funciones son ciudadanos de primera clase — objetos completos con identidad, tipo y valor. Lo desarrollaremos en detalle en la Clase 6b.

len(texto) → función independiente. texto.upper() → método del objeto string. texto.__class__ → atributo — sin paréntesis, devuelve <class 'str'>. texto.replace("P", "J") → método del objeto string. type(texto) → función independiente — equivalente a texto.__class__ pero más legible.

callable(sorted) → True — función built-in. callable(3.14) → False — float. callable(dict) → True — clase callable. callable({"a": 1}) → False — instancia dict. callable(print) → True — función built-in.

df.shape es un atributo — devuelve una tupla con las dimensiones. No necesita paréntesis porque no ejecuta ningún cálculo, solo accede a un valor almacenado. df.head() es un método — ejecuta código que construye y devuelve las primeras filas.

df.shape() produciría un TypeError: 'tuple' object is not callable — intentas llamar a una tupla como si fuera una función. df.head sin paréntesis devuelve el objeto método sin ejecutarlo — verías algo como <bound method DataFrame.head ...>.

def calcular_imc(peso, altura):
    """Calcula el Índice de Masa Corporal.

    Parámetros:
        peso (float): peso en kilogramos
        altura (float): altura en metros

    Retorna:
        float: el IMC redondeado a 2 decimales
    """
    return round(peso / altura ** 2, 2)

print(calcular_imc.__name__)      # 'calcular_imc'
print(calcular_imc.__doc__)       # el docstring
print(calcular_imc.__defaults__)  # None — sin defaults

__defaults__ devuelve None cuando ningún parámetro tiene valor por defecto. Si al menos uno tiene default, devuelve una tupla con esos valores.

print(doble) → <function doble at 0x...> — el objeto función. print(doble(5)) → 10 — resultado de ejecutar. print(doble.__name__) → 'doble'. print(type(doble)) → <class 'function'>. print(callable(doble)) → True.

Un comentario con # es ignorado por Python — no existe en tiempo de ejecución y no se puede acceder a él desde el código. Un docstring es una cadena de texto que Python almacena como atributo __doc__ del objeto función. Se puede leer programáticamente, aparece en la ayuda interactiva con help(funcion) y es la forma estándar que usan todas las librerías de Python para documentar sus funciones.

dir(funcion) devuelve todos los atributos del objeto — los dunder methods más los atributos propios. La lista es larga porque las funciones en Python son objetos completos con muchos atributos internos. Nos dice que una función no es solo código a ejecutar — es un objeto con estado, con atributos accesibles, con métodos propios. En Python no hay distinción entre "función" y "objeto": toda función es un objeto del tipo function.

Imprime "A", luego 5.0, luego "B", luego falla con ZeroDivisionError al ejecutar dividir(10, 0). El "C" nunca se imprime. La función se definió sin error — el fallo ocurre solo en la segunda llamada, con los argumentos que producen la división por cero.

No lanza error porque Python no ejecuta el cuerpo de procesar al procesarlo con def. Solo crea el objeto función. El error aparecería al llamar procesar(lista) con cualquier lista de menos de 101 elementos. Si nadie llama nunca a procesar, el IndexError nunca aparece — aunque el código incorrecto esté en el fichero.

La función tiene un error silencioso: cuando anterior = 0 produce una división por cero. Las dos primeras llamadas funcionan correctamente — +20.0 y -20.0. La tercera lanza ZeroDivisionError.

Es exactamente el tipo de error que la IA no anticipa: el código es correcto para los casos normales pero falla en el caso límite anterior = 0. La corrección:

def pct_cambio(anterior, nuevo):
    if anterior == 0:
        return None   # o raise ValueError
    return (nuevo - anterior) / anterior * 100

Un error de ejecución lanza una excepción — Python avisa, el programa se detiene y sabes exactamente dónde está el problema. Un error lógico no lanza ninguna excepción — la función devuelve un resultado incorrecto sin ningún aviso.

f(5) entra en el if, ejecuta return 10 — no llega al print. a = 10. f(-3) no entra en el if, ejecuta print("negativo") y termina sin return — devuelve None. b = None.

Imprime: "negativo" al ejecutar f(-3), luego 10, luego None, luego False (a no es None), luego True (b es None).

El error es que calcular_descuento usa print en lugar de return. Devuelve None y la lista finales es [None, None, None]. sum(finales) lanza un TypeError al intentar sumar None. La corrección:

def calcular_descuento(precio, pct):
    descuento = precio * pct / 100
    return precio - descuento   # ← return en lugar de print

precios = [100, 250, 80]
finales = [calcular_descuento(p, 10) for p in precios]
print(f"total: {sum(finales):.2f}€")   # 387.00€

Devuelve una tupla de dos elementos: ([2, 4, 6], [1, 3, 5]). type(resultado) es tuple. Aunque el return no tiene paréntesis, Python empaqueta los dos valores separados por coma en una tupla automáticamente.

print tiene sentido cuando la función es de diagnóstico — para mostrar información al usuario o para depurar — y el resultado no se necesita para nada más. Por ejemplo, una función mostrar_resumen(df) que imprime estadísticas formateadas sin devolver nada.

return es siempre mejor cuando el resultado se va a usar en un cálculo, guardar en una variable, pasar a otra función o incluir en una comprehension. En general: si no estás seguro, usa return — siempre puedes hacer print del resultado fuera de la función.

El Caso 1 tiene 5 pasos: procesar def, llamar area_circulo(4) con creación del frame, ejecutar pi = 3.1416, ejecutar return y volver al frame global. El frame de area_circulo aparece en el paso 2 — al hacer la llamada — y desaparece en el paso 4 — al ejecutar return.

area vive en el frame local de area_circulo — solo existe mientras la función se está ejecutando. No se puede acceder a ella desde fuera después de que termine porque el frame desaparece con todas sus variables. Intentar acceder con print(area) fuera de la función produciría un NameError. Esto es el concepto de scope local que veremos en detalle en la Clase 6b.

area4 vale 'pipipipipipipipipipipipipipipipi' — el string 'pi' repetido 16 veces (radio ** 2 = 16). Python no lanza excepción porque multiplicar un string por un entero es una operación válida en Python — repite el string. Es un error lógico silencioso: el código es sintácticamente correcto y no viola ninguna regla de tipos, pero el resultado no es el esperado. Solo lo detectas si verificas el resultado — o si usas Python Tutor para ver el valor en cada paso.

Al llamar la función dos veces, Python Tutor muestra que cada llamada crea su propio frame con sus propias variables locales — completamente independiente de la llamada anterior. Los parámetros se vinculan a los nuevos argumentos y las variables locales empiezan desde cero. Esto demuestra que las variables locales de una función no persisten entre llamadas — cada ejecución es un estado limpio.

Parámetros: nombre y saludo — son los nombres en la definición. saludo tiene valor por defecto "Hola". Primera llamada: argumentos "Ana" — saludo usa el default. Resultado: "Hola, Ana". Segunda llamada: argumentos "Bob" y "Buenos días" — el default se ignora. Resultado: "Buenos días, Bob".

interes_compuesto(1000) → 1050.0 — r=0.05, n=1 por defecto. interes_compuesto(1000, n=5) → 1276.28 — r=0.05 por defecto, n=5 explícito. interes_compuesto(1000, 5) → 6000.0 — r=5 por posición, n=1 por defecto. El tercer caso es la trampa: el 5 se asigna a r por posición, no a n. interes_compuesto(1000, 0.5, 10) → 57665.04 — todos explícitos.

Produce SyntaxError porque edad — sin default — aparece después de rol — con default. Python no puede determinar si el segundo argumento en la llamada es para rol o para edad. La corrección es poner los parámetros sin default primero:

def crear_usuario(nombre, edad, rol="usuario"):
    return {"nombre": nombre,
            "rol": rol,
            "edad": edad}

Llamada correcta: precio_actual=115, precio_base=100 → 115.0 — correcto. Llamada invertida: precio_actual=100, precio_base=115 → 86.96 — incorrecto pero sin error. El IPC debería ser 115 pero obtenemos 86.96 porque estamos dividiendo al revés. Es un error silencioso típico de posicionales con nombres similares — el resultado es plausible y nadie avisa del problema.

describir("Ana", 28) → "Ana, 28 años, desconocida" — ciudad usa default. describir(edad=28, nombre="Ana") → "Ana, 28 años, desconocida" — mismo resultado, orden distinto. describir(*datos) → "Bob, 35 años, Madrid" — la lista se desempaqueta como posicionales. describir(**config) → "Eva, 22 años, desconocida" — el dict se desempaqueta como keywords, ciudad usa default.

El segundo y tercer print producen el mismo resultado porque los keyword arguments se vinculan por nombre — el orden en que aparecen en la llamada no importa, solo importa qué nombre corresponde a qué parámetro. Con funciones de muchos parámetros, los keyword arguments eliminan la necesidad de recordar el orden exacto de la definición y hacen el código autoexplicativo.

Imprime para cada llamada:

título: Ventas 2024
color: red, lw: 2, alpha: 0.8
título: Costes 2024
color: red, lw: 2, alpha: 0.8

La ventaja es que el estilo está definido en un solo lugar. Si quieres cambiar el color de todos los gráficos, solo modificas el dict en un punto — no tienes que buscar y cambiar cada llamada. Es el mismo principio que reutilizar una función en lugar de copiar código.

Produce un TypeError: f() takes 3 positional arguments but 4 were given. *nums desempaqueta la lista completa como cuatro argumentos posicionales — f(1, 2, 3, 4) — pero f solo acepta tres. La corrección: usar solo los tres primeros elementos f(*nums[:3]) o definir la función para aceptar un número variable de argumentos con *args — que veremos en la Parte IV.

analizar() → TypeError: missing 2 required positional arguments: 'df' and 'columna' — faltan los dos obligatorios.

analizar("df", "col", "media", True, "extra") → TypeError: takes from 2 to 4 positional arguments but 5 were given — un argumento de más.

analizar("df", "col", metodos="media") → TypeError: got an unexpected keyword argument 'metodos' — nombre incorrecto (metodos en lugar de metodo).

analizar("df", columna="col", columna="col2") → SyntaxError: keyword argument repeated — columna aparece dos veces.

Las claves "min" y "max" no coinciden con los parámetros minimo y maximo. Produce: TypeError: got an unexpected keyword argument 'min'. La corrección es usar las claves correctas:

params = {
    "datos": [1, 2, 3],
    "minimo": 0,       # ← corregido
    "maximo": 10,      # ← corregido
    "incluir_bordes": True
}
filtrar(**params)

# Completamente posicional
informe("Ventas", 2024, 3, True)

# Completamente por nombre
informe(titulo="Ventas", año=2024,
        trimestre=3, publicar=True)

# Mixta — posicionales primero
informe("Ventas", 2024, trimestre=3, publicar=True)

Las tres producen el mismo output: Ventas — 2024 T3 — pub: True. La versión por nombre es la más legible y la más resistente a cambios en la definición.

Tres problemas:

Primera llamada normalizar(**config): la clave "method" no coincide con el parámetro "metodo" — TypeError. Además falta "datos" — argumento obligatorio.

Segunda llamada normalizar(metodo="minmax", [1, 2, 3]): argumento posicional después de keyword — SyntaxError.

Tercera llamada normalizar([1,2,3], "zscore", (0,1), True): cuatro argumentos pero la función solo acepta tres — TypeError.

Caso 1: K=1000, r=0.05, n=1 → i_c = 1050.0. Caso 2: K=1000, r=0.05, n=5 → i_c = 1276.28. Caso 3: K=1000, r=5, n=1 → i_c = 6000.0. Caso 4: K=1000, r=0.4, n=10 → i_c = 28925.27.

i_c = 6000.0 porque r=5 — un tipo de interés del 500% — en lugar del 5% esperado. El resultado es enorme pero plausible como número, por eso no lanza error. La versión correcta para n=5 y r=0.05:

# Por nombre — imposible de confundir
i_c = interes_compuesto(1000, n=5)
# K=1000, r=0.05 (default), n=5 → 1276.28

El error aparece al llamar la función — en el momento en que Python intenta desempaquetar el dict y vincularlo a los parámetros. El mensaje es: TypeError: got an unexpected keyword argument 'tasa'. No falla al definir el dict ni al ejecutar el cuerpo — falla exactamente en la llamada, antes de que el frame se cree completamente.

En los tres casos Python Tutor muestra el mismo frame con los tres parámetros vinculados a sus valores — independientemente de cómo se pasaron. Esto confirma que el frame es el estado interno de la función: Python resuelve la vinculación antes de entrar en el cuerpo, y el cuerpo siempre ve los mismos nombres con sus valores ya asignados.

info("a"): primero="a", resto=(), total: 1 argumentos.

info("a", "b", "c"): primero="a", resto=('b', 'c'), total: 3 argumentos.

info(1, 2, 3, 4, 5): primero=1, resto=(2, 3, 4, 5), total: 5 argumentos.

redondear viene después de *numeros en la definición. Todo lo que va después de un * solo puede pasarse por nombre. Si escribes operar("promedio", 1, 2, 3, False), el False va a numeros — la tupla sería (1, 2, 3, False) — y redondear usaría su default True. El resultado sería incorrecto porque se intenta hacer sum((1, 2, 3, False)) — que funciona porque False vale 0 — pero no es lo que se quería.

def maximo_de(*args):
    if not args:
        return None
    maximo = args[0]
    for n in args:
        if n > maximo:
            maximo = n
    return maximo

print(maximo_de(3, 1, 7, 2))   # 7
print(maximo_de(5))             # 5
print(maximo_de())              # None

combinar("-", "python", "es", "genial") → "python-es-genial". combinar(" ", "hola", "mundo") → "hola mundo". combinar(",") → "" — string vacío, palabras es tupla vacía. combinar("+", "uno", 2, "tres") → TypeError — str.join() requiere que todos los elementos sean strings, y 2 es un entero. Ese es el problema: la función no valida que todos los argumentos en *palabras sean strings.

analizar([1,2,3]): datos=[1,2,3], opciones={}.

analizar([1,2], metodo="media", redondear=True): datos=[1,2], opciones={'metodo': 'media', 'redondear': True}.

analizar([1], **{"umbral": 0.5, "verbose": False}): datos=[1], opciones={'umbral': 0.5, 'verbose': False} — el dict se desempaqueta como keywords antes de llegar a la función.

Uso A — **kwargs en la definición: la función acepta cualquier número de keyword arguments y los empaqueta en un dict. Se usa cuando diseñas una función flexible.

Uso B — **d en la llamada: desempaqueta el diccionario como keyword arguments antes de pasarlos. Se usa cuando tienes los argumentos en un dict y quieres pasarlos a una función.

def crear_etiqueta(texto, **kwargs):
    color   = kwargs.get("color",   "negro")
    tamaño  = kwargs.get("tamaño",  12)
    negrita = kwargs.get("negrita", False)
    estilo  = "negrita" if negrita else "normal"
    return (f"[{texto}] "
            f"color={color}, "
            f"tamaño={tamaño}, "
            f"estilo={estilo}")

print(crear_etiqueta("Título"))
print(crear_etiqueta("Alerta", color="rojo", negrita=True))
print(crear_etiqueta("Nota", tamaño=10, color="gris"))

Primera llamada: posicionales: ('evento1', 'evento2'), nombrados: {'usuario': 'Ana', 'nivel': 'info'}, total args: 4.

Segunda llamada: posicionales: (), nombrados: {}, total args: 0.

Tercera llamada: posicionales: (), nombrados: {'usuario': 'Bob'}, total args: 1.

Cuarta llamada: SyntaxError: keyword argument repeated: usuario — usuario aparece dos veces como keyword. Los diccionarios no permiten claves duplicadas y Python detecta este error antes de ejecutar.

X y y están antes de / → solo posicionales — obligatorios. test_size está entre / y * → flexible — posición o keyword, tiene default por lo que es opcional. random_state y verbose están después de * → solo keyword — opcionales con default.

f(1, 2, 3, d=4) → válida: a=1, b=2 por posición, c=3 flexible, d=4 keyword.

f(1, 2, c=3, d=4) → válida: a=1, b=2 por posición, c=3 y d=4 por keyword.

f(a=1, b=2, c=3, d=4) → TypeError: a y b están antes de / — solo pueden ir por posición.

f(1, 2, 3, 4) → TypeError: d está después de * — solo puede ir por keyword, no por posición.

len() no acepta argumentos por nombre porque su parámetro interno se llama obj en CPython — un detalle de implementación que no es parte de la interfaz. Si se pudiera llamar con len(obj=[1,2,3]), cambiar el nombre interno en una nueva versión de Python rompería todo el código que lo usara así. Forzarlo posicional protege la implementación interna.

df y columna antes de / → solo posicionales, obligatorios. metodo y umbral después de * → solo keyword, opcionales. **opciones → cualquier keyword extra.

Llamadas válidas: analizar(df, "ventas") ✓, analizar(df, "ventas", metodo="mediana") ✓, analizar(df, "ventas", verbose=True) ✓ — verbose va a **opciones.

Llamadas inválidas: analizar(df, columna="ventas") → TypeError — columna es solo posicional. analizar(df, "ventas", "media") → TypeError — "media" es posicional pero no hay tercer parámetro posicional.