Bloque 3: Funciones, módulos y ficheros

Funciones: define y reutiliza

Una función es un bloque de código con nombre que recibe valores (argumentos), hace algo y devuelve un resultado. Se define con def y se invoca con paréntesis. Es la pieza básica para no repetir código.

def area_circulo(radio):
    # return devuelve el resultado al que llama
    return 3.1416 * radio ** 2

a = area_circulo(5)
print(f"{a:.2f} u²")   # 78.54 u²

1.1 · Parámetros y valores por defecto

Un parámetro con = valor es opcional. Los opcionales siempre van después de los obligatorios:

def saludar(nombre, idioma="es"):
    if idioma == "es":
        return f"Hola, {nombre}"
    return f"Hello, {nombre}"

print(saludar("Ana"))          # Hola, Ana (usa el default)
print(saludar("Ana", "en"))  # Hello, Ana (lo pasamos explícito)

1.2 · Argumentos por nombre (keywords)

Puedes llamar a una función pasando los valores en orden (posicionales) o indicando el nombre del parámetro. Por nombre es más legible y no dependes del orden:

def crear_usuario(nombre, email, rol="alumno"):
    return {"nombre": nombre, "email": email, "rol": rol}

u1 = crear_usuario("Luis", "l@x.es")
u2 = crear_usuario(email="r@x.es", nombre="Rita", rol="admin")

Argumentos avanzados y lambda

2.1 · *args: un número variable de posicionales

*args recoge TODOS los argumentos posicionales en una tupla. Ideal para sumar n números:

def suma_total(*args):
    return sum(args)

print(suma_total(1, 2))        # 3
print(suma_total(1, 2, 3, 4))  # 10

2.2 · **kwargs: argumentos nombrados variables

**kwargs recoge los argumentos por nombre en un diccionario:

def configurar(**kwargs):
    for clave, valor in kwargs.items():
        print(f"{clave} = {valor}")

configurar(host="localhost", puerto=5432, modo="debug")

2.3 · Lambda: funciones pequeñas y anónimas

Una lambda es una función de una sola expresión, sin def ni return. Se usa sobre todo como «clave» de sorted, min, max o con map/filter:

personas = [("Ana", 25), ("Luis", 40), ("Rita", 30)]

# ordenar por la edad (segundo elemento de cada tupla)
ordenadas = sorted(personas, key=lambda persona: persona[1])

# la persona más joven
mas_joven = min(personas, key=lambda p: p[1])

print(ordenadas)   # [('Ana', 25), ('Rita', 30), ('Luis', 40)]
print(mas_joven)   # ('Ana', 25)

2.4 · Funciones como ciudadanas de primera clase

En Python las funciones son valores: puedes guardarlas en variables, pasarlas como argumento y devolverlas. Eso abre la puerta a la programación funcional:

def aplicar(funcion, valor):
    return funcion(valor)

def doble(x):
    return x * 2

print(aplicar(doble, 5))         # 10
print(aplicar(lambda x: x * x, 3)) # 9

Ámbitos, docstrings y buenas prácticas

3.1 · Ámbito local y global

Las variables creadas dentro de una función son locales (viven solo ahí). Las creadas al nivel superior del programa son globales. Para leer una global desde una función no hace falta nada; para modificarla, necesitas global:

contador = 0   # global

def incrementar():
    global contador        # indica que vamos a modificar la global
    contador += 1

incrementar()
incrementar()
print(contador)   # 2

3.2 · Docstrings: la documentación en el código

Un docstring es un texto con comillas triples justo después de def. Explica QUÉ hace la función, qué parámetros espera y qué devuelve. Herramientas como help() lo leen:

def precio_con_iva(precio, iva=15):
    """Devuelve el precio con el IVA aplicado y redondeado a 2 decimales.

    Args:
        precio (float): precio base
        iva (int): porcentaje de IVA (por defecto 15)

    Returns:
        float: precio final con IVA
    """
    return round(precio * (1 + iva / 100), 2)

print(precio_con_iva(100))      # 115.0
print(precio_con_iva(100, 21))  # 121.0

3.3 · Buenas prácticas

Módulos y excepciones

4.1 · Módulos: importar código

Un módulo es un archivo .py con funciones, clases y variables que puedes reutilizar en otros programas mediante import:

# módulos de la biblioteca estándar
import math
import random
import datetime as dt      # alias
from collections import Counter  # importar algo concreto

print(math.sqrt(16))             # 4.0
print(random.randint(1, 6))  # un número del 1 al 6
print(dt.date.today())          # 2026-09-01

También puedes importar tus propios archivos. Si creas utilidades.py con una función, otro archivo hace from utilidades import generar_id. Eso es lo que separa un script de un programa modular.

4.2 · pip: instalar librerías de terceros

pip instala paquetes del índice oficial (pypi.org):

$ pip install requests        # instala un paquete
$ pip list                    # los paquetes instalados
$ pip uninstall requests      # desinstala
$ pip freeze                  # lista versiones (para guardar en requirements.txt)

4.3 · Excepciones: errores controlados

En Python, cuando algo falla se lanza una excepción. Si no la capturas, el programa muere. Con try/except la controlas tú:

texto = input("Edad: ")

try:
    edad = int(texto)
    print(f"Dentro de 10 años tendrás {edad + 10}")
except ValueError:
    print("Eso no es un número válido")

Excepciones habituales: ValueError (valor inválido para int()), KeyError (dict sin clave), IndexError (índice fuera de rango), FileNotFoundError (fichero inexistente), ZeroDivisionError. Puedes encadenar except con distintos tipos.

Ficheros: persistir datos

Para que un programa recuerde datos entre ejecuciones hay que guardarlos en disco. Python trabaja con ficheros de texto y con formatos estructurados como CSV y JSON.

5.1 · Leer y escribir con with

El bloque with cierra el archivo automáticamente al terminar, incluso si hay un error. Es la forma recomendada, nunca olvides cerrarlo:

# escribir (w: sobrescribe, a: añade al final)
with open("notas.txt", "w", encoding="utf-8") as f:
    f.write("Línea uno\n")
    f.write("Línea dos\n")

# leer todo el contenido
with open("notas.txt", encoding="utf-8") as f:
    contenido = f.read()
    print(contenido)

5.2 · Leer por líneas

with open("notas.txt", encoding="utf-8") as f:
    for linea in f:
        print(linea.strip())   # strip quita el salto de línea

5.3 · Trabajar con JSON

JSON es el formato universal para intercambiar datos. Python lo maneja con el módulo json:

import json

datos = {"nombre": "Ana", "edad": 25, "activo": True}

# guardar (serializar)
with open("usuario.json", "w", encoding="utf-8") as f:
    json.dump(datos, f, ensure_ascii=False, indent=2)

# leer (deserializar)
with open("usuario.json", encoding="utf-8") as f:
    recuperado = json.load(f)

print(recuperado["nombre"])   # Ana — y ya es un dict de Python