Desempaquetado en Python: asterisco, intercambio y anidamiento

Intermedio20 min5 ejercicios70 XP

Esta lección es una traducción del original en inglés.Read in English Avisar de un error de traducción

Antes de empezar

Tuplas en Python: cuándo y por qué usar secuencias inmutables

0/5 ejercicios

Imagina que pides por internet un paquete con tres cosas: un libro, unos auriculares y una funda para el teléfono. Cuando llega la caja, la abres y pones cada cosa en su sitio. El libro va a la estantería, los auriculares al escritorio y la funda al teléfono.

El desempaquetado en Python funciona igual. Tomas una colección de valores (una tupla, una lista o cualquier iterable) y asignas cada valor a su propia variable en una sola línea limpia. No necesitas acceder a los elementos uno a uno con índices.

En esta lección aprenderás el desempaquetado básico, el elegante truco para intercambiar variables, las expresiones con asterisco que recogen varios elementos, el desempaquetado dentro de bucles y cómo desestructurar datos anidados.

¿Cómo funciona el desempaquetado básico?

Cuando tienes una tupla o una lista con varios valores, puedes asignar cada valor a una variable distinta en una sola línea. El número de variables de la izquierda debe coincidir con el número de elementos de la derecha.

Desempaquetado básico de tuplas y listas

# Unpacking a tuple

coordinates = (10, 20, 30)

x, y, z = coordinates

print(x) # 10

print(y) # 20

print(z) # 30

# Unpacking a list

colors = ['red', 'green', 'blue']

first, second, third = colors

print(first) # red

print(second) # green

print(third) # blue

Salida

10
20
30
red
green
blue

Sin desempaquetado, tendrías que acceder a cada elemento por su índice. El desempaquetado hace que el código sea más corto y mucho más fácil de leer.

Sin desempaquetado (más largo)

point = (10, 20, 30)
x = point[0]
y = point[1]
z = point[2]
print(x, y, z)

Con desempaquetado (más limpio)

point = (10, 20, 30)
x, y, z = point
print(x, y, z)

También puedes desempaquetar directamente en una asignación, sin guardar antes la tupla en una variable. Python crea la tupla automáticamente cuando separas los valores con comas.

Desempaquetar sin paréntesis

# Direct unpacking (no parentheses needed)

name, age, city = 'Alice', 25, 'Paris'

print(name) # Alice

print(age) # 25

print(city) # Paris

# This works because Python sees commas and creates a tuple

print(type(('Alice', 25, 'Paris'))) # <class 'tuple'>

Salida

Alice
25
Paris
<class 'tuple'>

Cómo intercambiar variables en una línea

En la mayoría de los lenguajes de programación, intercambiar dos variables requiere una variable temporal. Con el desempaquetado de Python no hace falta. Puedes intercambiar valores en una sola línea elegante.

Intercambiar dos variables

a = 'hello'

b = 'world'

# Swap in one line!

a, b = b, a

print(a) # world

print(b) # hello

Salida

world
hello

Esto funciona porque Python evalúa primero el lado derecho, empaqueta los valores en una tupla (b, a) y luego los desempaqueta en a, b. Todo ocurre de forma segura en un solo paso.

Otros lenguajes (necesitan una variable temporal)

a = 1
b = 2
temp = a
a = b
b = temp
print(a, b)  # 2 1

Python (una línea)

a = 1
b = 2
a, b = b, a
print(a, b)  # 2 1

Puedes intercambiar tres o más variables de la misma forma. Python lo resuelve todo en un solo paso.

Rotar tres variables

# Rotate three variables

a, b, c = 1, 2, 3

print(f'Before: a={a}, b={b}, c={c}')

a, b, c = b, c, a

print(f'After: a={a}, b={b}, c={c}')

Salida

Before: a=1, b=2, c=3
After:  a=2, b=3, c=1

¿Qué son las expresiones con asterisco (*rest)?

A veces no sabes exactamente cuántos elementos tiene una colección, o solo te interesan unos pocos. La expresión con asterisco (*variable) recoge en una lista todos los elementos que sobran.

Las expresiones con asterisco recogen los elementos sobrantes

# Capture the first item and everything else

numbers = [1, 2, 3, 4, 5]

first, *rest = numbers

print(first) # 1

print(rest) # [2, 3, 4, 5]

# Capture the last item and everything before it

*beginning, last = numbers

print(beginning) # [1, 2, 3, 4]

print(last) # 5

Salida

1
[2, 3, 4, 5]
[1, 2, 3, 4]
5

También puedes poner el asterisco en medio. Es ideal cuando te interesan el primer y el último elemento y quieres saltarte todo lo que hay entre ellos.

El asterisco en medio

scores = [95, 80, 75, 90, 85, 70, 88]

# Get the first, last, and everything in between

first, *middle, last = scores

print(f'First: {first}') # 95

print(f'Middle: {middle}') # [80, 75, 90, 85, 70]

print(f'Last: {last}') # 88

Salida

First: 95
Middle: [80, 75, 90, 85, 70]
Last: 88

Asterisco con cero elementos y con cadenas

# Star captures zero items (still a list)

a, b, *rest = [10, 20]

print(a) # 10

print(b) # 20

print(rest) # []

# Star from a string

first, *middle, last = 'Hello'

print(first) # H

print(middle) # ['e', 'l', 'l']

print(last) # o

Salida

10
20
[]
H
['e', 'l', 'l']
o

Cómo usar el desempaquetado en bucles for

El desempaquetado brilla dentro de los bucles for. Cuando recorres una lista de tuplas (o de listas), puedes desempaquetar cada elemento directamente en variables con nombre, en lugar de acceder a sus partes por índice.

Desempaquetar tuplas en un bucle for

# List of (name, age) tuples

students = [

('Alice', 16),

('Bob', 15),

('Charlie', 17),

]

# Unpack each tuple in the loop

for name, age in students:

print(f'{name} is {age} years old')

Salida

Alice is 16 years old
Bob is 15 years old
Charlie is 17 years old

Este patrón se usa constantemente con enumerate() y dict.items(). Ambos devuelven tuplas, y el desempaquetado deja el código mucho más limpio.

Desempaquetado con enumerate() y dict.items()

# enumerate() returns (index, value) tuples

fruits = ['apple', 'banana', 'cherry']

for i, fruit in enumerate(fruits):

print(f'{i}: {fruit}')

print()

# dict.items() returns (key, value) tuples

ages = {'Alice': 16, 'Bob': 15, 'Charlie': 17}

for name, age in ages.items():

print(f'{name} -> {age}')

Salida

0: apple
1: banana
2: cherry

Alice -> 16
Bob -> 15
Charlie -> 17

Cómo desempaquetar estructuras de datos anidadas

El desempaquetado en Python puede bajar varios niveles. Si un valor de tu colección es a su vez una tupla o una lista, puedes desempaquetarlo con paréntesis anidados en el lado izquierdo.

Desempaquetado anidado con paréntesis

# A tuple containing a nested tuple

record = ('Alice', (95, 87, 92))

# Nested unpacking

name, (score1, score2, score3) = record

print(f'{name}: {score1}, {score2}, {score3}')

Salida

Alice: 95, 87, 92

Esto funciona a cualquier profundidad. Incluso puedes combinar el desempaquetado anidado con expresiones con asterisco para tener la máxima flexibilidad.

Desempaquetado anidado en bucles

# List of students with (name, (math, science, english))

students = [

('Alice', (95, 87, 92)),

('Bob', (78, 85, 90)),

('Charlie', (88, 92, 76)),

]

for name, (math, science, english) in students:

avg = (math + science + english) / 3

print(f'{name}: average = {avg:.1f}')

Salida

Alice: average = 91.3
Bob: average = 84.3
Charlie: average = 85.3

Errores comunes al desempaquetar que debes evitar

El desempaquetado es intuitivo cuando te acostumbras a él, pero hay algunas trampas en las que suelen caer los principiantes.

Errores comunes al desempaquetar

# Mistake 1: Forgetting parentheses in nested unpacking

# Wrong: name, x, y = ('Alice', (10, 20)) -> ValueError!

# Right:

name, (x, y) = ('Alice', (10, 20))

print(name, x, y)

# Mistake 2: Unpacking a single-item tuple

# You need the comma to make it a tuple!

value, = (42,) # Note the comma after 42

print(value) # 42

# Mistake 3: Forgetting that * always creates a list

first, *rest = 'AB'

print(type(rest)) # <class 'list'>, not str!

Salida

Alice 10 20
42
<class 'list'>

Ejercicios de práctica

Desempaqueta una coordenada

Escribe el código

Desempaqueta la tupla point en tres variables: x, y y z. Luego imprímelas en una línea, separadas por espacios, con print(x, y, z).

point = (7, 14, 21)

# Unpack into x, y, z and print them

Intercambia dos variables

Escribe el código

Las variables first y second tienen los valores cambiados. Intercámbialos con la sintaxis de desempaquetado de Python (una línea, sin variable temporal) y luego imprime ambas.

first = 'goodbye'

second = 'hello'

# Swap first and second in one line

print(first)

print(second)

Cabeza y cola con asterisco

Escribe el código

Usa una expresión con asterisco para desempaquetar la lista numbers en head (el primer elemento) y tail (todo lo demás). Imprime ambos en líneas separadas.

numbers = [10, 20, 30, 40, 50]

# Unpack into head and tail using *

Predice la salida del desempaquetado

Predice la salida

¿Qué imprime este código? Piensa en qué recoge el asterisco y de qué tipo es el resultado.

a, *b, c = [1, 2, 3, 4, 5, 6]
print(a)
print(b)
print(c)

Ejecuta el código para comprobar tu predicción.

# What does this print?

a, *b, c = [1, 2, 3, 4, 5, 6]

print(a)

print(b)

print(c)

Desempaqueta los registros de estudiantes

Escribe el código

Tienes una lista de registros de estudiantes. Cada registro es una tupla de la forma (name, (math_score, english_score)). Usa desempaquetado anidado en un bucle for para calcular e imprimir la nota media de cada estudiante.

Imprime cada línea con el formato Name: average, donde average es la media redondeada a 1 decimal con :.1f.

students = [

('Alice', (90, 80)),

('Bob', (70, 90)),

('Charlie', (85, 95)),

]

# Loop with nested unpacking and print averages

¿Cómo funciona el desempaquetado básico?

Cómo intercambiar variables en una línea

¿Qué son las expresiones con asterisco (*rest)?

Cómo usar el desempaquetado en bucles for

Cómo desempaquetar estructuras de datos anidadas

Errores comunes al desempaquetar que debes evitar

Ejercicios de práctica

Tutoriales relacionados