La función `zip`¶

La función zip() en Python combina elementos de dos o más iterables en una secuencia de tuplas.
Cada tupla contiene los elementos correspondientes de los iterables originales.

Ejemplo 1¶

En este ejemplo, zip() combina los elementos de las listas numeros, letras y simbolos en una secuencia de tuplas.
Luego, se itera sobre la secuencia de tuplas y se imprime cada tupla.
Cada tupla contiene los elementos correspondientes de las listas originales en el mismo orden.

In [1]:

numeros = [1, 2, 3]
letras = ['a', 'b', 'c']
simbolos = ['!', '@', '#']

combinados = zip(numeros, letras, simbolos)

print(combinados)   # objeto iterable de tipo zip
print(type(combinados))
print()

for tupla in combinados:
    print(tupla)

<zip object at 0x7ff3980ff7c0>
<class 'zip'>

(1, 'a', '!')
(2, 'b', '@')
(3, 'c', '#')

Ejemplo 2¶

En este ejemplo, zip() combina los elementos de las listas nombres, edades y ciudades en una secuencia de tuplas. Luego, se itera sobre la secuencia de tuplas y se desempaquetan los elementos en las variables nombre, edad y ciudad.

Finalmente, se imprime la información de cada persona utilizando los valores desempaquetados.

In [2]:

nombres = ['Juan', 'María', 'Pedro']
edades = [25, 30, 35]
ciudades = ['Madrid', 'Malaga', 'Santander']

informacion = zip(nombres, edades, ciudades)

for nombre, edad, ciudad in informacion:
    print(f"{nombre} tiene {edad} años y vive en {ciudad}")

Juan tiene 25 años y vive en Madrid
María tiene 30 años y vive en Malaga
Pedro tiene 35 años y vive en Santander

Ejemplo 3¶

Con el uso del operador asterisco *
En este ejemplo, zip() combina los elementos de las listas numeros y letras en una secuencia de tuplas.
Luego, utilizamos el operador asterisco * junto con zip() para desempaquetar las tuplas en dos secuencias separadas.
Finalmente, convertimos las secuencias desempaquetadas en una lista y las imprimimos.
En este caso, desempaquetados contendrá dos listas: una con los números (1, 2, 3) y otra con las letras ('a', 'b', 'c').
El operador asterisco * nos permite desempaquetar las tuplas y separar sus elementos en diferentes secuencias.

In [3]:

numeros = [1, 2, 3]
letras = ['a', 'b', 'c']

combinados = zip(numeros, letras)

desempaquetados = list(zip(*combinados))

print(desempaquetados)

[(1, 2, 3), ('a', 'b', 'c')]

In [4]:

numeros = [1, 2, 3]
letras = ['a', 'b', 'c']

print(list(zip(numeros, letras)))       # objeto zip convertido en una lista de tuplas
print(list(zip(*zip(numeros, letras)))) # el asterisco desempaqueta y luego volvemos a empaquetar

[(1, 'a'), (2, 'b'), (3, 'c')]
[(1, 2, 3), ('a', 'b', 'c')]

Ejemplo 4¶

En este ejemplo, zip(*puntos) desempaqueta las coordenadas de la lista de tuplas puntos en dos tuplas separadas, una para las coordenadas X y otra para las coordenadas Y.

In [5]:

puntos = [(1, 2), (3, 4), (5, 6)]

x_coords, y_coords = zip(*puntos)

print("Coordenadas X:", x_coords)
print("Coordenadas Y:", y_coords)

Coordenadas X: (1, 3, 5)
Coordenadas Y: (2, 4, 6)

Ejemplo 5¶

La función zip() nos proporciona un iterable.
Los iterables cuando se recorren se agotan.
Para entender esto veamos tres variantes en este ejemplo.

Variante 1¶

In [6]:

nombres = ["Ana", "Juan", "María"]
edades = [25, 30, 28]

combinados = zip(nombres, edades)
print(list(combinados))

[('Ana', 25), ('Juan', 30), ('María', 28)]

Variante 2¶

In [7]:

nombres = ["Ana", "Juan", "María"]
edades = [25, 30, 28]

combinados = zip(nombres, edades)

for tupla in combinados:
    print(tupla)

('Ana', 25)
('Juan', 30)
('María', 28)

Variante 3¶

El comportamiento de esta variante nos puede resultar sorprendente ya que únicamente se imprime la lista de tuplas pero parece que el bucle no se ejecuta. El bucle no imprime nada ya que el iterable está vacío.
Esto se debe a que combinados se vacía de contenido por ser un iterable.
La razón detrás de esta anomalía se debe a cómo funciona la función zip() y cómo se comportan los iteradores en Python.
En la VARIANTE 3, después de imprimir list(combinados), el iterador combinados se agota, lo que significa que ya no tiene más elementos para recorrer.
Cuando intentas iterar nuevamente sobre combinados en el segundo bucle for, este ya no tiene elementos y, por lo tanto, no imprime nada.

Aquí está el flujo paso a paso:

VARIANTE 3:

Creas el iterador combinados con zip(nombres, edades).
Imprimes list(combinados), lo que agota el iterador y muestra los elementos en forma de lista.
Intentas iterar sobre combinados nuevamente en el segundo bucle for, pero el iterador ya está agotado, por lo que no imprime nada.
Para lograr el resultado que esperábamos, podemos almacenar los resultados de list(combinados) en una variable y luego usarla en el segundo bucle for, como se muestra a continuación:

In [8]:

nombres = ["Ana", "Juan", "María"]
edades = [25, 30, 28]

combinados = zip(nombres, edades)
print(list(combinados))     # al imprimir el iterador se agota

for tupla in combinados:    # este bucle no imprime nada ya que
    print(tupla)            # el contenido del iterador combinados está vacío

[('Ana', 25), ('Juan', 30), ('María', 28)]

Solución¶

Recuerda que una vez que agotas un iterador, no puedes volver a iterar sobre él sin recrearlo o almacenar sus elementos en una estructura de datos como una lista, tupla, etc.

In [9]:

nombres = ["Ana", "Juan", "María"]
edades = [25, 30, 28]

combinados = zip(nombres, edades)
resultados = list(combinados)

print(resultados)
print()

for tupla in resultados:
    print(tupla)

[('Ana', 25), ('Juan', 30), ('María', 28)]

('Ana', 25)
('Juan', 30)
('María', 28)

Ejemplo 6¶

In [10]:

def celsius_to_fahrenheit(celsius):
    return celsius * 9/5 + 32

celsius_temperatures = [0, 10, 20, 30, 40]
fahrenheit_temperatures = [celsius_to_fahrenheit(c) for c in celsius_temperatures]

combined_temperatures = zip(celsius_temperatures, fahrenheit_temperatures)


# Imprimir las temperaturas en ambas escalas
for celsius, fahrenheit in combined_temperatures:
    print(f"{celsius}°C = {fahrenheit}°F")

0°C = 32.0°F
10°C = 50.0°F
20°C = 68.0°F
30°C = 86.0°F
40°C = 104.0°F

Ejemplo 7 `zip` y `map`¶

In [11]:

a = (1, 2)
b = (10, 20)

c = list(map(sum, zip(a, b)))
print(c)

[11, 22]

Ejemplo 8 `zip` y `map`¶

Cuatro amigos de digerentes edades acuerdan reunirse dentro de 5 años.
Imprimir las edades que tendrán en ese momento.

In [12]:

def increase_age(age):
    return age + 5

names = ["Alicia", "Borja", "Clara", "David"]
ages = [25, 32, 40, 45]

combined_data = zip(names, map(increase_age, ages))

for i, (name, age) in enumerate(combined_data):
    print(f"Friend {i+1}: {name} \t→ \tEdad: {age}")

Friend 1: Alicia 	→ 	Edad: 30
Friend 2: Borja 	→ 	Edad: 37
Friend 3: Clara 	→ 	Edad: 45
Friend 4: David 	→ 	Edad: 50

Ejemplo 8 `map` y `zip`¶

In [13]:

def calculate_product(pair):
    return pair[0] * pair[1]

numbers1 = [2, 4, 6, 8, 10]
numbers2 = [3, 5, 7, 9, 11]

product_results = map(calculate_product, zip(numbers1, numbers2))

for result in product_results:
    print("Producto:", result)

Producto: 6
Producto: 20
Producto: 42
Producto: 72
Producto: 110

Ejemplo 9 `map` sin `zip` con listas de diferente longitud¶

Si las listas list1 y list2 son de diferenete longitud al trabajar con ellas no da error, simplemente se usan el número de elementos de la lista más corta, que en este ejemplo son 5.
En este ejemplo construimos una lista con los productos de los 5 primeros elementos, por parejas de las listas utlizadas.

In [14]:

def producto(a, b):
    return a * b

list1 = [1,2,3,4,5]
list2 = [1,2,3,4,5,6,7]

result = list(map(producto, list1, list2))
print(result)

[1, 4, 9, 16, 25]

El mismo resultado se obtendría usando una función lambda.

In [15]:

list1 = [1, 2, 3, 4, 5]
list2 = [1, 2, 3, 4, 5, 6, 7]

result = list(map(lambda a,b: a*b,  list1, list2))
print(result)

[1, 4, 9, 16, 25]

La función zip¶