Funciones, cierres y lambda
Defina funciones auxiliares reutilizables, use argumentos predeterminados y aplique expresiones lambda a la ordenación y a patrones funcionales en problemas de entrevistas.
Funciones, cierres y lambda es una lección gratuita de DSA Interview Prep en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de DSA Interview Prep, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de DSA Interview Prep incluye 4 lecciones en total.
Definir funciones en Python
Las funciones son first-class en Python: puede pasarlas, devolverlas y almacenarlas. Unos helpers con nombres claros hacen que el código de una entrevista sea fácil de leer. Aborde primero los casos límite.
def is_palindrome(s: str) -> bool:
'''Return True if s reads the same forwards and backwards.'''
s = s.lower()
return s == s[::-1]
print(is_palindrome('Racecar')) # True
print(is_palindrome('hello')) # False
# Functions as values
checks = [is_palindrome]
print(checks[0]('level')) # TrueArgumentos predeterminados y de palabra clave
Los valores predeterminados permiten omitir argumentos al llamar a una función. Pero nunca utilice un valor predeterminado mutable, como una lista: todos los llamadores lo comparten. La solución es usar None como valor predeterminado y crear la lista dentro. Consulte el código.
# WRONG: shared mutable default
def bad_append(val, lst=[]):
lst.append(val)
return lst
print(bad_append(1)) # [1]
print(bad_append(2)) # [1, 2] surprise!
# CORRECT: use None sentinel
def good_append(val, lst=None):
if lst is None:
lst = []
lst.append(val)
return lst
print(good_append(1)) # [1]
print(good_append(2)) # [2]*args y **kwargs
*args reúne los argumentos posicionales adicionales en una tupla; **kwargs reúne los argumentos de palabra clave adicionales en un dict. El símbolo * también desempaqueta una secuencia al llamar a una función.
def total(*args):
return sum(args)
print(total(1, 2, 3)) # 6
print(total(1, 2, 3, 4)) # 10
# Unpack a list as positional args
point = [3, 7]
print(max(*point)) # 7
# **kwargs
def greet(**kwargs):
name = kwargs.get('name', 'World')
return f'Hello, {name}!'
print(greet(name='Alice')) # Hello, Alice!Expresiones lambda
Una lambda es una función pequeña de una sola línea: lambda params: expression. Es perfecta como key rápida en sorted o max. Para algo más extenso, una def con nombre se lee con mayor claridad.
# Lambda as sort key
pairs = [(1, 3), (2, 1), (3, 2)]
sorted_by_second = sorted(pairs, key=lambda p: p[1])
print(sorted_by_second) # [(2,1),(3,2),(1,3)]
# Lambda with map
double = list(map(lambda n: n * 2, [1, 2, 3]))
print(double) # [2, 4, 6]
# Named function is clearer for complex logic
def sort_key(p):
return (p[1], -p[0]) # secondary sort
print(sorted(pairs, key=sort_key))Funciones anidadas y closures
Un closure es una función que recuerda las variables de la función que la contiene. Defina un helper dentro de otra función y podrá utilizar las variables externas; resulta útil para DFS.
def make_counter(start=0):
count = [start] # list to allow mutation
def increment():
count[0] += 1
return count[0]
return increment
counter = make_counter()
print(counter()) # 1
print(counter()) # 2
# Alternative: nonlocal keyword
def make_counter2():
count = 0
def increment():
nonlocal count
count += 1
return count
return incrementClosures en DFS recursivo
Un patrón habitual consiste en definir un helper dfs dentro de la función principal y permitir que acumule los resultados en una variable externa. La función interna es un closure sobre ese ámbito.
def max_depth(root):
'''Closure pattern for tree DFS.'''
max_d = [0] # mutable container for closure
def dfs(node, depth):
if node is None:
return
max_d[0] = max(max_d[0], depth)
dfs(node.left, depth + 1)
dfs(node.right, depth + 1)
dfs(root, 1)
return max_d[0]
# This pattern avoids a class or global state.Memoización con functools.lru_cache
lru_cache (o @cache a partir de la versión 3.9) recuerda los resultados de una función según sus argumentos, y convierte el Fibonacci ingenuo de O(2^n) en O(n). Los argumentos deben ser hashable, así que utilice tuplas.
from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
if n <= 1:
return n
return fib(n - 1) + fib(n - 2)
print(fib(40)) # 102334155 fast!
print(fib.cache_info()) # hits, misses, sizeFunciones de orden superior
Una función de orden superior recibe o devuelve una función. sorted, map y filter cumplen esta definición. Escribir las suyas propias permite abstraer patrones repetidos. El código muestra la composición.
def apply_twice(f, x):
return f(f(x))
print(apply_twice(lambda n: n * 2, 3)) # 12 (3*2*2)
# Composing transformations
def compose(f, g):
return lambda x: f(g(x))
double = lambda n: n * 2
add_one = lambda n: n + 1
double_then_add = compose(add_one, double)
print(double_then_add(5)) # 11 ((5*2)+1)Recursión con funciones auxiliares
Muchas soluciones combinan una función externa que gestiona la configuración y los casos límite con un helper interno que realiza la recursión. Así se obtiene una API pública limpia y una lógica aislada. Consulte el código.
def flatten(nested):
'''Flatten an arbitrarily nested list.'''
result = []
def _flatten(lst):
for item in lst:
if isinstance(item, list):
_flatten(item)
else:
result.append(item)
_flatten(nested)
return result
print(flatten([1, [2, [3, 4], 5], 6]))
# [1, 2, 3, 4, 5, 6]Funciones parciales con functools.partial
functools.partial completa de antemano algunos argumentos y devuelve un nuevo objeto invocable. Resulta útil cuando una API requiere una función sin argumentos, pero usted necesita fijar un parámetro.
from functools import partial
def power(base, exp):
return base ** exp
square = partial(power, exp=2)
cube = partial(power, exp=3)
print(square(5)) # 25
print(cube(3)) # 27
print(list(map(square, [1, 2, 3, 4]))) # [1, 4, 9, 16]Lambda para comparadores personalizados
Python 3 eliminó los comparadores de dos argumentos, pero cmp_to_key los recupera para ordenaciones complejas, como organizar números para que su concatenación sea la mayor posible. Consulte el código.
from functools import cmp_to_key
def largest_number(nums):
def compare(a, b):
if a + b > b + a: return -1
if a + b < b + a: return 1
return 0
strs = list(map(str, nums))
strs.sort(key=cmp_to_key(compare))
result = ''.join(strs)
return '0' if result[0] == '0' else result
print(largest_number([3, 30, 34, 5, 9])) # '9534330'Comprobación rápida
Comprobación rápida: demuestre lo que ha aprendido sobre funciones, closures y lambdas. Respire hondo y adelante. 🚀
Resumen de la lección
Resumen: nunca utilice valores predeterminados mutables (use None), los closures permiten que los helpers internos accedan a variables externas para DFS y las herramientas de functools, como lru_cache, potencian soluciones rápidas.
Preguntas frecuentes
¿La lección «Funciones, cierres y lambda» es gratis?
Sí — el texto completo de «Funciones, cierres y lambda» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de DSA Interview Prep, actualiza a CoddyKit PRO. El curso de DSA Interview Prep incluye 4 lecciones en total.
¿Qué aprenderé en «Funciones, cierres y lambda»?
Defina funciones auxiliares reutilizables, use argumentos predeterminados y aplique expresiones lambda a la ordenación y a patrones funcionales en problemas de entrevistas. Practicas DSA Interview Prep con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar DSA Interview Prep?
No se requiere experiencia previa. DSA Interview Prep en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Funciones, cierres y lambda»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de DSA Interview Prep?
Sí. Cada lección de DSA Interview Prep incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Listas, tuplas y slicing
- Diccionarios y conjuntos en Python
- Comprensiones y funciones integradas
- Funciones, cierres y lambda