Comprensiones y funciones integradas
Escriba soluciones concisas con comprensiones de list/dict/set, map, filter, zip, enumerate y sorted con funciones key.
Comprensiones y funciones integradas es una lección gratuita de DSA Interview Prep en CoddyKit. Esta es la lección 3 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.
Comprensiones de listas: filtrado conciso
Una list comprehension convierte un bucle for seguido de append en una sola línea limpia: [expr for item in iterable if condition]. Es algo más rápida y demuestra soltura con Python.
# Traditional loop
squares = []
for n in range(1, 6):
squares.append(n * n)
print(squares) # [1, 4, 9, 16, 25]
# List comprehension
squares = [n * n for n in range(1, 6)]
print(squares) # [1, 4, 9, 16, 25]
# With filter
evens = [n for n in range(10) if n % 2 == 0]
print(evens) # [0, 2, 4, 6, 8]Comprensiones anidadas para cuadrículas 2D
Las comprensiones anidadas construyen cuadrículas 2D, la forma habitual de preparar una tabla de DP. Evite [[0]*C]*R, que comparte la misma lista interna entre todas las filas. El código muestra la solución.
# WRONG: all rows are the same object!
bad = [[0] * 3] * 3
bad[0][0] = 9
print(bad) # [[9,0,0],[9,0,0],[9,0,0]] oops!
# CORRECT: each row is a separate list
good = [[0] * 3 for _ in range(3)]
good[0][0] = 9
print(good) # [[9,0,0],[0,0,0],[0,0,0]]Comprensiones de dicts y conjuntos
Las dict and set comprehensions utilizan llaves: {k: v for ...} para un dict y {expr for ...} para un conjunto. Ambas permiten filtrar, así que puede transformar o eliminar duplicados en una sola línea.
# Dict comprehension: square lookup
sq_map = {n: n**2 for n in range(1, 6)}
print(sq_map) # {1:1, 2:4, 3:9, 4:16, 5:25}
# Set comprehension: unique lengths
words = ['cat', 'dog', 'elephant', 'ant']
unique_lengths = {len(w) for w in words}
print(unique_lengths) # {3, 8} (order varies)Expresiones generadoras: eficientes en memoria
Rodee una comprensión con () y obtendrá un generador que produce los valores uno a uno, ahorrando memoria. Páselo directamente a sum, max o cualquier otra función para recorrer secuencias enormes.
# List comprehension builds all values at once
total = sum([n**2 for n in range(1_000_000)])
# Generator yields one at a time — lower memory
total = sum(n**2 for n in range(1_000_000))
print(total) # 333332833333500000
# any/all with generators short-circuit early
nums = [4, 6, 8, 3, 10]
has_odd = any(n % 2 == 1 for n in nums)
print(has_odd) # True (stops at 3)map() y filter(): estilo funcional
map aplica una función a cada elemento; filter conserva los que superan una prueba. Ambas son lazy, así que debe envolverlas en list() para ver los resultados. Las comprensiones suelen ser más claras.
nums = [1, 2, 3, 4, 5]
# map: apply function to each element
doubled = list(map(lambda n: n * 2, nums))
print(doubled) # [2, 4, 6, 8, 10]
# filter: keep elements passing predicate
evens = list(filter(lambda n: n % 2 == 0, nums))
print(evens) # [2, 4]
# Equivalent comprehensions (often preferred)
doubled = [n * 2 for n in nums]
evens = [n for n in nums if n % 2 == 0]zip(): emparejar secuencias
zip empareja dos secuencias y se detiene al llegar a la más corta; es la forma más limpia de recorrer dos listas a la vez. El truco zip(*matrix) transpone una lista 2D. Consulte el código.
keys = ['a', 'b', 'c']
values = [1, 2, 3]
pairs = list(zip(keys, values))
print(pairs) # [('a',1), ('b',2), ('c',3)]
# Build dict from two lists
d = dict(zip(keys, values))
print(d) # {'a':1, 'b':2, 'c':3}
# Transpose a matrix
matrix = [[1,2,3],[4,5,6],[7,8,9]]
transposed = [list(row) for row in zip(*matrix)]
print(transposed) # [[1,4,7],[2,5,8],[3,6,9]]enumerate(): índice más valor
enumerate proporciona (index, value) durante el recorrido, de forma más limpia que range(len(lst)) y sin errores off-by-one. Utilice la opción start para empezar a contar en 1.
fruits = ['apple', 'banana', 'cherry']
# Instead of: for i in range(len(fruits)):
for i, fruit in enumerate(fruits):
print(i, fruit)
# 0 apple / 1 banana / 2 cherry
# Start from 1
for i, fruit in enumerate(fruits, 1):
print(f'{i}. {fruit}')
# 1. apple / 2. banana / 3. cherrysorted() con funciones key
sorted devuelve una lista nueva ordenada y acepta una función key para establecer un orden personalizado. Puede ordenar por longitud, por un campo de una tupla o sin distinguir mayúsculas de minúsculas. El código muestra ordenaciones con varias claves.
# Sort by second element of tuple
intervals = [(1,3),(2,1),(0,5)]
print(sorted(intervals, key=lambda x: x[1]))
# [(2,1),(1,3),(0,5)]
# Sort strings case-insensitively
words = ['Banana', 'apple', 'Cherry']
print(sorted(words, key=str.lower))
# ['apple', 'Banana', 'Cherry']
# Sort by multiple keys: first by length, then alphabetically
words = ['fig', 'apple', 'ant', 'kiwi']
print(sorted(words, key=lambda w: (len(w), w)))
# ['ant', 'fig', 'kiwi', 'apple']min() y max() con key
min y max también aceptan una key, de modo que puede obtener en una sola llamada el elemento cuyo valor transformado sea menor o mayor, como la palabra más larga. Consulte el código.
words = ['banana', 'fig', 'strawberry', 'kiwi']
longest = max(words, key=len)
print(longest) # strawberry
shortest = min(words, key=len)
print(shortest) # fig
# Find interval with earliest end
intervals = [(2,6),(1,3),(4,5)]
earlist_end = min(intervals, key=lambda x: x[1])
print(earlist_end) # (1, 3)any() y all() para comprobaciones con cortocircuito
any se detiene en el primer elemento truthy; all se detiene en el primero falsy. Ambas aplican cortocircuito, así que, combinadas con un generador, comprueban condiciones de forma rápida y lazy.
nums = [2, 4, 6, 7, 8]
all_even = all(n % 2 == 0 for n in nums)
print(all_even) # False (7 is odd)
has_large = any(n > 5 for n in nums)
print(has_large) # True (6 qualifies, stops there)
# Practical: check if sudoku row has no duplicates
row = [1, 2, 3, 4, 5, 6, 7, 8, 9]
valid = all(1 <= n <= 9 for n in row) and len(set(row)) == 9
print(valid) # Truesum(), abs() y divmod()
Tres utilidades matemáticas aparecen por todas partes: sum, abs y divmod. divmod(a, b) devuelve a la vez el cociente y el resto, lo que resulta perfecto para extraer dígitos.
# sum with generator
print(sum(n**2 for n in range(1, 6))) # 55
# abs for distance problems
print(abs(-7)) # 7
# divmod for digit extraction
num = 1234
digits = []
while num:
num, d = divmod(num, 10)
digits.append(d)
digits.reverse()
print(digits) # [1, 2, 3, 4]Comprobación rápida
Comprobación rápida: veamos cómo ha asimilado las comprensiones y las funciones integradas. Una pregunta; puede hacerlo. ✅
Resumen de la lección
Resumen: las comprehensions convierten los bucles en expresiones de una línea, las funciones integradas como zip y sorted aceptan funciones key y los generators ahorran memoria en tareas de un solo recorrido.
Preguntas frecuentes
¿La lección «Comprensiones y funciones integradas» es gratis?
Sí — el texto completo de «Comprensiones y funciones integradas» 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 «Comprensiones y funciones integradas»?
Escriba soluciones concisas con comprensiones de list/dict/set, map, filter, zip, enumerate y sorted con funciones key. 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 3 de 4.
¿Cuánto tiempo toma la lección «Comprensiones y funciones integradas»?
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