Aprende Python · lección gratuita

Lección 21 · Scope, lambda, map y filter

Resumen

Hasta ahora escribiste funciones con def y nombres bien definidos. En esta lección verás dónde viven las variables (su ámbito o scope) y cómo crear funciones diminutas y anónimas con lambda. Combinarás esas funciones pequeñas con map() y filter() para transformar y filtrar colecciones sin escribir bucles. Estas herramientas vienen del estilo funcional de Python y hacen tu código más corto y declarativo.

• El scope local es el de las variables creadas dentro de una función; sólo existen ahí.
• El scope global es el del módulo; con global puedes modificar una variable global desde dentro de una función.
• Una lambda argumentos: expresión es una función anónima de una sola línea que devuelve su expresión.
• map(función, iterable) aplica la función a cada elemento y produce uno nuevo.
• filter(función, iterable) conserva sólo los elementos donde la función devuelve True.
• map() y filter() devuelven objetos perezosos: usa list(...) para verlos.

Conceptos

Cada vez que Python ejecuta una función crea un espacio de nombres local. Las variables asignadas dentro de la función son locales: nacen al entrar y mueren al salir, y no chocan con variables del mismo nombre fuera. Cuando lees una variable, Python busca primero en el ámbito local, luego en el global y por último en los nombres internos (regla LEGB). Si quieres reasignar una variable global desde dentro de una función, debes declararla con global; si sólo la lees, no hace falta.

contador = 0          # variable global

def incrementar():
    global contador   # sin esto, la asignación crearía una local
    contador += 1

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

Una función lambda es una forma compacta de definir una función sin nombre. lambda x: x 2 equivale a una función que recibe x y devuelve x 2. No lleva return: el resultado de la expresión es el valor devuelto. Las lambdas brillan cuando necesitas una función pequeña "de paso", justo lo que piden map() y filter(). map(f, datos) recorre datos y aplica f a cada elemento; filter(f, datos) recorre datos y se queda con los elementos para los que f devuelve un valor verdadero. Ambas son perezosas (no calculan hasta que recorres el resultado), así que normalmente las envuelves en list().

numeros = [1, 2, 3, 4]
dobles = list(map(lambda n: n * 2, numeros))   # [2, 4, 6, 8]
pares = list(filter(lambda n: n % 2 == 0, numeros))  # [2, 4]
print(dobles)
print(pares)

Ejemplos

# 1) lambda guardada en una variable (se puede llamar como una función)
cuadrado = lambda x: x * x
print(cuadrado(5))            # 25

# 2) map() para transformar cada elemento
precios = [10, 20, 30]
con_iva = list(map(lambda p: p * 1.18, precios))
print(con_iva)               # [11.799999999999999, 23.6, 35.4]

# 3) filter() para quedarte sólo con algunos
palabras = ["sol", "mar", "montaña", "rio"]
cortas = list(filter(lambda w: len(w) <= 3, palabras))
print(cortas)                # ['sol', 'mar', 'rio']

# 4) scope local: 'x' dentro no afecta a 'x' fuera
x = 100
def prueba():
    x = 5                    # variable LOCAL distinta
    return x
print(prueba())              # 5
print(x)                     # 100

💡 Usa lambda sólo para lógica corta de una línea. Si la función crece o necesitas reutilizarla, defínela con def y dale un nombre claro: el código se lee mejor.

Cheatsheet

Sintaxis	Qué hace	Ejemplo
lambda a: a + 1	Función anónima de un argumento	f = lambda a: a + 1
lambda a, b: a + b	Lambda con varios argumentos	(lambda a, b: a+b)(2, 3) → 5
map(f, it)	Aplica f a cada elemento	list(map(str, [1,2])) → ['1','2']
filter(f, it)	Conserva donde f es True	list(filter(lambda n: n>0, xs))
list(...)	Materializa map/filter	list(map(f, datos))
global v	Permite reasignar global dentro de función	def g(): global v; v = 9

---

← args, kwargs y desempaquetadoStrings a fondo →

Ver todas las lecciones de Aprende Python →