{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"provenance": [],
"authorship_tag": "ABX9TyNqaPjPSTK4YGxA8IhYxJqu",
"include_colab_link": true
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
}
},
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "view-in-github",
"colab_type": "text"
},
"source": [
"![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\")
"
]
},
{
"cell_type": "markdown",
"source": [
"# La función `zip`\n",
"* La función zip() en Python combina elementos de dos o más iterables en una secuencia de tuplas.\n",
"* Cada tupla contiene los elementos correspondientes de los iterables originales."
],
"metadata": {
"id": "D3kUfH1LQoBr"
}
},
{
"cell_type": "markdown",
"source": [
"## Ejemplo 1\n",
"* En este ejemplo, `zip()` combina los elementos de las listas `numeros`, `letras` y `simbolos` en una secuencia de tuplas.\n",
"* Luego, se itera sobre la secuencia de tuplas y se imprime cada tupla.\n",
"* Cada tupla contiene los elementos correspondientes de las listas originales en el mismo orden."
],
"metadata": {
"id": "c76ByM-CRk_X"
}
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "jE-WJfx2QgW9",
"outputId": "c07e4e71-a63c-4998-8d77-c5ffcf80776d"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"\n",
"\n",
"\n",
"(1, 'a', '!')\n",
"(2, 'b', '@')\n",
"(3, 'c', '#')\n"
]
}
],
"source": [
"numeros = [1, 2, 3]\n",
"letras = ['a', 'b', 'c']\n",
"simbolos = ['!', '@', '#']\n",
"\n",
"combinados = zip(numeros, letras, simbolos)\n",
"\n",
"print(combinados) # objeto iterable de tipo zip\n",
"print(type(combinados))\n",
"print()\n",
"\n",
"for tupla in combinados:\n",
" print(tupla)"
]
},
{
"cell_type": "markdown",
"source": [
"## Ejemplo 2\n",
"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`.\n",
"* Finalmente, se imprime la información de cada persona utilizando los valores desempaquetados."
],
"metadata": {
"id": "5Ex3FUy1SZSk"
}
},
{
"cell_type": "code",
"source": [
"nombres = ['Juan', 'María', 'Pedro']\n",
"edades = [25, 30, 35]\n",
"ciudades = ['Madrid', 'Malaga', 'Santander']\n",
"\n",
"informacion = zip(nombres, edades, ciudades)\n",
"\n",
"for nombre, edad, ciudad in informacion:\n",
" print(f\"{nombre} tiene {edad} años y vive en {ciudad}\")\n"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "gnrLFcr6Scd6",
"outputId": "089e33d4-1788-4fb6-d57a-276430d06b3a"
},
"execution_count": 2,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Juan tiene 25 años y vive en Madrid\n",
"María tiene 30 años y vive en Malaga\n",
"Pedro tiene 35 años y vive en Santander\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"## Ejemplo 3\n",
"* Con el uso del operador asterisco `*`\n",
"* En este ejemplo, `zip()` combina los elementos de las listas `numeros` y `letras` en una secuencia de tuplas.\n",
"* Luego, utilizamos el operador asterisco `*` junto con `zip()` para desempaquetar las tuplas en dos secuencias separadas.\n",
"* Finalmente, convertimos las secuencias desempaquetadas en una lista y las imprimimos.\n",
"* En este caso, desempaquetados contendrá dos listas: una con los números `(1, 2, 3)` y otra con las letras `('a', 'b', 'c')`.\n",
"* El operador asterisco `*` nos permite desempaquetar las tuplas y separar sus elementos en diferentes secuencias."
],
"metadata": {
"id": "g0FX8QNzS4yq"
}
},
{
"cell_type": "code",
"source": [
"numeros = [1, 2, 3]\n",
"letras = ['a', 'b', 'c']\n",
"\n",
"combinados = zip(numeros, letras)\n",
"\n",
"desempaquetados = list(zip(*combinados))\n",
"\n",
"print(desempaquetados)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "c6WoiY89TAJO",
"outputId": "d0764303-804f-470e-b752-f6b2e7ea1fee"
},
"execution_count": 3,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"[(1, 2, 3), ('a', 'b', 'c')]\n"
]
}
]
},
{
"cell_type": "code",
"source": [
"numeros = [1, 2, 3]\n",
"letras = ['a', 'b', 'c']\n",
"\n",
"print(list(zip(numeros, letras))) # objeto zip convertido en una lista de tuplas\n",
"print(list(zip(*zip(numeros, letras)))) # el asterisco desempaqueta y luego volvemos a empaquetar"
],
"metadata": {
"id": "icdsYIsCI42Y",
"outputId": "9f2c2140-7397-4aec-c775-443e5b4a53a4",
"colab": {
"base_uri": "https://localhost:8080/"
}
},
"execution_count": 4,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"[(1, 'a'), (2, 'b'), (3, 'c')]\n",
"[(1, 2, 3), ('a', 'b', 'c')]\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"## Ejemplo 4\n",
"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`."
],
"metadata": {
"id": "EP4_mcsU3j8F"
}
},
{
"cell_type": "code",
"source": [
"puntos = [(1, 2), (3, 4), (5, 6)]\n",
"\n",
"x_coords, y_coords = zip(*puntos)\n",
"\n",
"print(\"Coordenadas X:\", x_coords)\n",
"print(\"Coordenadas Y:\", y_coords)"
],
"metadata": {
"id": "KNMqTUKI3oTX",
"outputId": "6d4a2bc4-918e-4c61-807d-efa8a38a8223",
"colab": {
"base_uri": "https://localhost:8080/"
}
},
"execution_count": 5,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Coordenadas X: (1, 3, 5)\n",
"Coordenadas Y: (2, 4, 6)\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"## Ejemplo 5\n",
"* La función `zip()` nos proporciona un iterable.\n",
"* Los iterables cuando se recorren se agotan.\n",
"* Para entender esto veamos tres variantes en este ejemplo."
],
"metadata": {
"id": "QowEoulQ79Cl"
}
},
{
"cell_type": "markdown",
"source": [
"### Variante 1"
],
"metadata": {
"id": "irRdfKPo8aEl"
}
},
{
"cell_type": "code",
"source": [
"nombres = [\"Ana\", \"Juan\", \"María\"]\n",
"edades = [25, 30, 28]\n",
"\n",
"combinados = zip(nombres, edades)\n",
"print(list(combinados))"
],
"metadata": {
"id": "BRJ2i1eE4Thu",
"outputId": "7dfafa16-9207-49b5-c136-dbea440f6120",
"colab": {
"base_uri": "https://localhost:8080/"
}
},
"execution_count": 6,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"[('Ana', 25), ('Juan', 30), ('María', 28)]\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"### Variante 2"
],
"metadata": {
"id": "mNhH-9Ja8h6L"
}
},
{
"cell_type": "code",
"source": [
"nombres = [\"Ana\", \"Juan\", \"María\"]\n",
"edades = [25, 30, 28]\n",
"\n",
"combinados = zip(nombres, edades)\n",
"\n",
"for tupla in combinados:\n",
" print(tupla)"
],
"metadata": {
"id": "2QDbL-dD4ur_",
"outputId": "38cbe480-5ecd-43b3-e309-375feea49179",
"colab": {
"base_uri": "https://localhost:8080/"
}
},
"execution_count": 7,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"('Ana', 25)\n",
"('Juan', 30)\n",
"('María', 28)\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"### Variante 3\n",
"* 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.\n",
"* Esto se debe a que `combinados` se vacía de contenido por ser un iterable.\n",
"* 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.\n",
"\n",
"* 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.\n",
"* Cuando intentas iterar nuevamente sobre `combinados` en el segundo bucle `for`, este ya no tiene elementos y, por lo tanto, no imprime nada.\n",
"\n",
"Aquí está el flujo paso a paso:\n",
"\n",
"VARIANTE 3:\n",
"\n",
"* Creas el iterador `combinados` con `zip(nombres, edades)`.\n",
"\n",
"* Imprimes `list(combinados)`, lo que agota el iterador y muestra los elementos en forma de lista.\n",
"\n",
"* Intentas iterar sobre combinados nuevamente en el segundo bucle `for`, pero el iterador ya está agotado, por lo que no imprime nada.\n",
"\n",
"* 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:"
],
"metadata": {
"id": "wnRoUDx28kpL"
}
},
{
"cell_type": "code",
"source": [
"nombres = [\"Ana\", \"Juan\", \"María\"]\n",
"edades = [25, 30, 28]\n",
"\n",
"combinados = zip(nombres, edades)\n",
"print(list(combinados)) # al imprimir el iterador se agota\n",
"\n",
"for tupla in combinados: # este bucle no imprime nada ya que\n",
" print(tupla) # el contenido del iterador combinados está vacío"
],
"metadata": {
"id": "hSY-JKSy4wt-",
"outputId": "86b4033c-5378-486b-8ffc-d5b37d7bf245",
"colab": {
"base_uri": "https://localhost:8080/"
}
},
"execution_count": 8,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"[('Ana', 25), ('Juan', 30), ('María', 28)]\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"### Solución\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."
],
"metadata": {
"id": "2nC8BlK79IV9"
}
},
{
"cell_type": "code",
"source": [
"nombres = [\"Ana\", \"Juan\", \"María\"]\n",
"edades = [25, 30, 28]\n",
"\n",
"combinados = zip(nombres, edades)\n",
"resultados = list(combinados)\n",
"\n",
"print(resultados)\n",
"print()\n",
"\n",
"for tupla in resultados:\n",
" print(tupla)"
],
"metadata": {
"id": "dxYY58Ri9PXT",
"outputId": "716cd1fe-f887-4e32-c1a8-dbec8ea1b07a",
"colab": {
"base_uri": "https://localhost:8080/"
}
},
"execution_count": 9,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"[('Ana', 25), ('Juan', 30), ('María', 28)]\n",
"\n",
"('Ana', 25)\n",
"('Juan', 30)\n",
"('María', 28)\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"## Ejemplo 6"
],
"metadata": {
"id": "JAeCGxjtU64R"
}
},
{
"cell_type": "code",
"source": [
"def celsius_to_fahrenheit(celsius):\n",
" return celsius * 9/5 + 32\n",
"\n",
"celsius_temperatures = [0, 10, 20, 30, 40]\n",
"fahrenheit_temperatures = [celsius_to_fahrenheit(c) for c in celsius_temperatures]\n",
"\n",
"combined_temperatures = zip(celsius_temperatures, fahrenheit_temperatures)\n",
"\n",
"\n",
"# Imprimir las temperaturas en ambas escalas\n",
"for celsius, fahrenheit in combined_temperatures:\n",
" print(f\"{celsius}°C = {fahrenheit}°F\")"
],
"metadata": {
"id": "waQ40xEAR2MC",
"outputId": "b65e0ea1-c2a5-42c4-bd41-4d597d01d69a",
"colab": {
"base_uri": "https://localhost:8080/"
}
},
"execution_count": 10,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"0°C = 32.0°F\n",
"10°C = 50.0°F\n",
"20°C = 68.0°F\n",
"30°C = 86.0°F\n",
"40°C = 104.0°F\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"## Ejemplo 7 `zip` y `map`"
],
"metadata": {
"id": "ewDbjYV9NKjM"
}
},
{
"cell_type": "code",
"source": [
"a = (1, 2)\n",
"b = (10, 20)\n",
"\n",
"c = list(map(sum, zip(a, b)))\n",
"print(c)"
],
"metadata": {
"id": "WQq2QsW1a6xH",
"outputId": "b02fc72b-8e44-4051-8e88-ec39ad520643",
"colab": {
"base_uri": "https://localhost:8080/"
}
},
"execution_count": 11,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"[11, 22]\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"## Ejemplo 8 `zip` y `map`\n",
"* Cuatro amigos de digerentes edades acuerdan reunirse dentro de 5 años.\n",
"* Imprimir las edades que tendrán en ese momento."
],
"metadata": {
"id": "nEGIKYNqbkH_"
}
},
{
"cell_type": "code",
"source": [
"def increase_age(age):\n",
" return age + 5\n",
"\n",
"names = [\"Alicia\", \"Borja\", \"Clara\", \"David\"]\n",
"ages = [25, 32, 40, 45]\n",
"\n",
"combined_data = zip(names, map(increase_age, ages))\n",
"\n",
"for i, (name, age) in enumerate(combined_data):\n",
" print(f\"Friend {i+1}: {name} \\t→ \\tEdad: {age}\")"
],
"metadata": {
"id": "CxVyUtqcUK6h",
"outputId": "65c8ecab-3955-4a5f-85f5-fd2b96221ea6",
"colab": {
"base_uri": "https://localhost:8080/"
}
},
"execution_count": 12,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Friend 1: Alicia \t→ \tEdad: 30\n",
"Friend 2: Borja \t→ \tEdad: 37\n",
"Friend 3: Clara \t→ \tEdad: 45\n",
"Friend 4: David \t→ \tEdad: 50\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"## Ejemplo 8 `map` y `zip`"
],
"metadata": {
"id": "vx7cDX8wcJd_"
}
},
{
"cell_type": "code",
"source": [
"def calculate_product(pair):\n",
" return pair[0] * pair[1]\n",
"\n",
"numbers1 = [2, 4, 6, 8, 10]\n",
"numbers2 = [3, 5, 7, 9, 11]\n",
"\n",
"product_results = map(calculate_product, zip(numbers1, numbers2))\n",
"\n",
"for result in product_results:\n",
" print(\"Producto:\", result)"
],
"metadata": {
"id": "z_OhKsryXOFz",
"outputId": "bcab5376-13a5-47d5-83fc-7751413183bd",
"colab": {
"base_uri": "https://localhost:8080/"
}
},
"execution_count": 13,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Producto: 6\n",
"Producto: 20\n",
"Producto: 42\n",
"Producto: 72\n",
"Producto: 110\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"## Ejemplo 9 `map` sin `zip` con listas de diferente longitud\n",
"\n",
"* 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.\n",
"* En este ejemplo construimos una lista con los productos de los 5 primeros elementos, por parejas de las listas utlizadas."
],
"metadata": {
"id": "Kmg5AsoFYgPo"
}
},
{
"cell_type": "code",
"source": [
"def producto(a, b):\n",
" return a * b\n",
"\n",
"list1 = [1,2,3,4,5]\n",
"list2 = [1,2,3,4,5,6,7]\n",
"\n",
"result = list(map(producto, list1, list2))\n",
"print(result)"
],
"metadata": {
"id": "FH5isbaHYqs7",
"outputId": "03a987ca-9544-466f-a336-8245f15d8181",
"colab": {
"base_uri": "https://localhost:8080/"
}
},
"execution_count": 14,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"[1, 4, 9, 16, 25]\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"El mismo resultado se obtendría usando una función `lambda`."
],
"metadata": {
"id": "iL_JvfakZ8jA"
}
},
{
"cell_type": "code",
"source": [
"list1 = [1, 2, 3, 4, 5]\n",
"list2 = [1, 2, 3, 4, 5, 6, 7]\n",
"\n",
"result = list(map(lambda a,b: a*b, list1, list2))\n",
"print(result)"
],
"metadata": {
"id": "ia3plJIIaDya",
"outputId": "5a1edbe0-c75e-4a11-a178-da61dc0d8a2f",
"colab": {
"base_uri": "https://localhost:8080/"
}
},
"execution_count": 15,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"[1, 4, 9, 16, 25]\n"
]
}
]
}
]
}