5.Trabajando con Tuplas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5.Trabajando con tuplas\n",
    "\n",
    "Una tupla es una secuencia de elementos que puede almacenar datos heterogeneos tales como: float, strings, listas y diccionarios. Como los strings, las tuplas son inmutables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Así se crea una tupla vacía\n",
    "tupl = ()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para crear una tupla, se almacenan los valores separados por comas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup = (1, 2, 3, 4.6, 'hola', 'a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si se define una variable así, también se creará una tupla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 1, 2, 3\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexamiento de tuplas con subscript"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acceder a un valor particular de una tupla se especifica su posición con corchetes ```[]```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "avengers = (\"Ironman\", \"Spiderman\", \"Ant-man\", \"Hulk\", \"Thor\", \"The Wasp\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ironman'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avengers[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The Wasp'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avengers[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obtener una parte de la tupla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Spiderman', 'Ant-man')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avengers[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('The Wasp', 'Thor', 'Hulk', 'Ant-man', 'Spiderman', 'Ironman')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avengers[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si se intenta indexar por fuera de la tupla, se retorna una tupla vacía:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avengers[len(avengers):len(avengers)+1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una forma rápida de desempacar y asignar variables de una tupla es la siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: 1 b: 2 c: 3\n"
     ]
    }
   ],
   "source": [
    "tup1 = (1,2,3)\n",
    "a, b, c = tup1\n",
    "print('a:', a, 'b:', b, 'c:', c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si se intentan obtener más valores de los que tiene la tupla se obtendrá el error: ```ValueError```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#tup1 = (5,6)\n",
    "#a,b,c = tup1 #ValueError!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones de Tuplas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Longitud de la tupla: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup = (1,2,3,4)\n",
    "len(tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Máximo y mínimo de una tupla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (4,5,-1,6,7) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (4,-1,4.0,-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (4.0,-1,4,-2)\n",
    "max(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'zorg'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup1 = ('alice', 'bob', 'zorg')\n",
    "max(tup1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'alice'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(tup1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convertir de string a tupla\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('D', 'u', 'm', 'b', 'l', 'e', 'd', 'o', 'r', 'e')\n"
     ]
    }
   ],
   "source": [
    "magician = 'Dumbledore'\n",
    "tm = tuple(magician) \n",
    "print(tm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```del``` se puede utilizar para eliminar una tupla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "del(tm)\n",
    "#tm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operaciones sobre tuplas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup1 = ('A', 'B', 'C', 'E')\n",
    "tup2 = (1,2,3,4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('A', 'B', 'C', 'E', 1, 2, 3, 4, 5)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup1+tup2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup3 = tup2*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible crear tuplas anidadas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((0, 1, 2, 3), ('A', 'B', 'C'))\n"
     ]
    }
   ],
   "source": [
    "tuple1 = (0, 1, 2, 3) \n",
    "tuple2 = ('A', 'B', 'C') \n",
    "tuple3 = (tuple1, tuple2) \n",
    "print(tuple3) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hacer swap de variables sin una variable auxiliar es posible con tuplas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 3\n",
    "(a, b) = (b, a)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La función ```map(function, tuple|list)```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejecuta un método para cada uno de los valores de una tupla o una lista. Un truco muy usado es leer todos los valores de una tupla en una sola línea:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n",
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "t = tuple(map(int, input().split(' ')))\n",
    "print(t) #digite por ejemplo 1 2 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 1\n",
    "\n",
    "Obtener por código el elemento 20 de la siguiente tupla:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "aTuple = (\"Orange\", [10, 20, 30], (5, 15, 25))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 2\n",
    "\n",
    "Dados dos números enteros construya una función que retorne al mismo tiempo el cociente y el residuo de la división utilizando tuplas:\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "    <td>input</td><td>output</td>\n",
    "    <tr>\n",
    "    <tr>\n",
    "    <td>10<br>3</td><td>cociente: 3<br>residuo: 1</td>\n",
    "    <tr>\n",
    "<table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 3 - Distancia entre dos puntos\n",
    "\n",
    "Utilizando tuplas elabore un método que retorne la distancia entre dos puntos $p$ y $q$ definidos en un espacio de 3 dimensiones:\n",
    "\n",
    "La distancia corresponde a aplicar: $d = \\sqrt{(x_2-x_1)^2, (y_2-y_1)^2, (z_2-z_1)^2}$ \n",
    "\n",
    "\n",
    "![](images/3dpoints.gif)\n",
    "\n",
    "### Entrada\n",
    "La entrada corresponde a los valores de cada una de las coordenadas x, y, z de cada punto:\n",
    "\n",
    "### Salida\n",
    "Un único valor correspondiente a la distancia entre los dos puntos.\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>Input</td><td>output</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>0 1 1<br>-1 -1 4</td><td>3.7416573867739413</td>\n",
    "    </tr>\n",
    "    \n",
    "Para una mayor referencia puede consultar [distancias en el espacio](https://www.vadenumeros.es/segundo/distancias-en-el-espacio.htm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Referencias:\n",
    "\n",
    "https://www.geeksforgeeks.org/tuples-in-python/\n",
    "\n",
    "Das, B. N. (2017). Learn Python in 7 Days. Packt Publishing Ltd.\n",
    "\n",
    "[https://www.wolframalpha.com](https://www.wolframalpha.com/input/?i=distance+between+two+points&assumption=%7B%22MC%22%2C+%22%22%7D+-%3E+%7B%22Calculator%22%7D&assumption=%7B%22F%22%2C+%22DistanceCalculator%22%2C+%22point1%22%7D+-%3E%22%7B0%2C+1%2C+1%7D%22&assumption=%7B%22F%22%2C+%22DistanceCalculator%22%2C+%22point2%22%7D+-%3E%22%7B-1%2C+-1%2C+4%7D%22)\n",
    "\n",
    "https://www.vadenumeros.es/segundo/distancias-en-el-espacio.htm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}