6. Trabajando con Datos Ordenados.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Trabajando con Datos Ordenados\n",
    "\n",
    "Uno de los usos de python está relacionado con el procesamiento de datos. La mayoría de programas adquiere datos, procesa datos y entiende datos. Para esto python incluye una coleccción de estructuras de datos: listas, diccionarios, tuplas y conjuntos (lists, dictionaries, tuples and sets). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Todo en python es un objeto. Los números, las cadenas, las funciones y los módulos son objetos. En ese sentido pueden ser asignados a variables. Como son objetos, van a ser una colección de estados (variables o atributos) y de comportamientos (métodos). Aunque todo sea objeto no se requiere definir uno especial para ejecutar código en python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listas, tuplas, diccionarios y conjuntos no necesitan ser importados pues su uso es parte del lenguaje."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listas\n",
    "\n",
    "Una lista es muy similar a la noción de un arreglo. En este sentido puede entenderse como una colección indexada de objetos. A cada elemento le corresponde una posición. Una lista puede almacenar objetos de diferente tipo en la misma estructura. Es posible también añadir, remover, o cambiar objetos. Esto quiere decir que las listas son mutables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuplas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es una colección ordenada de objetos. Pero en este caso dicha colección no es mutable. Una vez se define o se asignan elementos a la tupla, la tupla no podrá ser cambiada bajo ninguna circunstancia. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas y las tuplas son útiles cuando se requiere mantener y conocer el orden de los elementos que se van a almacenar en ella. Sin embargo el orden no es importante en todos los casos. Un ejemplo de esto, es el almacenamiento de los detalles de un usuario (nombre, contraseña). Almacenar estos datos no requiere un orden específico."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diccionarios\n",
    "\n",
    "Permite almacenar parejas de tipo llave/valor. La llave se asume única y cada llave va a tener un valor asociado. Las llaves pueden ser de cualquier tipo de dato. Los diccionarios no mantienen un orden y son una estructura con dos columnas. Son estructuras de datos mutables, así que pueden crecer en tamaño."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conjuntos (Sets)\n",
    "\n",
    "Son muy útiles para remover elementos duplicados de cualquier otra colección. Adicionalmente presenta operaciones de unión, intersección o diferencia. Son una estructura de datos mutable por lo cual pueden cambiar su tamaño."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Programando listas\n",
    "\n",
    "Ya hemos definido listas antes. Para esto, hemos definido valores que se encuentran dentro de corchetes. Los valores se encuentran separados por coma. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible definir listas de forma literal (se crea la lista y se le asigna un contenido): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado']\n",
      "[32.0, 212.0, 0.0, 81.6, 100.0]\n",
      "['Toyota', 'RAV4', 2.2, 60807]\n"
     ]
    }
   ],
   "source": [
    "dias = ['lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado']\n",
    "\n",
    "print(dias)\n",
    "\n",
    "temps = [ 32.0, 212.0, 0.0, 81.6, 100.0]\n",
    "\n",
    "print(temps)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para saber si un elemento está en una lista se puede usar el operador ```in```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Si\n"
     ]
    }
   ],
   "source": [
    "dias = ['lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado']\n",
    "if('lunes' in dias):\n",
    "    print('Si')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para saber si un elemento no se encuentra en una lista se puede usar ```not in```:\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Si\n"
     ]
    }
   ],
   "source": [
    "dias = ['lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado']\n",
    "if('juernes' not in dias):\n",
    "    print('Si')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una lista puede almacenar distintos tipos de objeto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dato Toyota tipo: <class 'str'>\n",
      "dato RAV4 tipo: <class 'str'>\n",
      "dato 2.2 tipo: <class 'float'>\n",
      "dato 60807 tipo: <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "car_details = ['Toyota', 'RAV4', 2.2, 60807]\n",
    "\n",
    "for detail in car_details:\n",
    "    print(\"dato \" + str(detail) + \" tipo: \" + str(type(detail)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible tener una lista de listas:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], ['a', 'b', 'c']]\n",
      "[1, 2, 3]\n",
      "['a', 'b', 'c']\n",
      "b\n"
     ]
    }
   ],
   "source": [
    "mi_lista = [[1,2,3], ['a', 'b', 'c']]\n",
    "\n",
    "print(mi_lista)\n",
    "\n",
    "print(mi_lista[0])\n",
    "print(mi_lista[1])\n",
    "print(mi_lista[1][1])\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio:\n",
    "\n",
    "Dada una frase averiguar cuantas vocales tiene y mostrarlas. Para esto, se debe usar la siguiente lista ```vowels = ['a', 'e', 'i', 'o', 'u']```\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>Input</td><td>Output</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>externocleidomastoideo</td><td>11</td>\n",
    "    </tr>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lojavengers\n",
      "o\n",
      "a\n",
      "e\n",
      "e\n",
      "se encontraron: 4 vocales.\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para crear la lista y añadir elementos de forma dinámica se puede hacer lo siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "found=[] #se crea la lista vacía\n",
    "len(found) #este método calcula la longitud de la lista\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "found.append('a')\n",
    "found.append('e')\n",
    "found.append('i')\n",
    "found.append('o')\n",
    "found.append('u')\n",
    "\n",
    "len(found)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'e', 'i', 'o', 'u']\n"
     ]
    }
   ],
   "source": [
    "print(found)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para validar si un elemento no está en la lista se puede utilizar ```not in```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "esta_en_lista = 'x' not in found\n",
    "print(esta_en_lista)\n",
    "\n",
    "esta_en_lista = 'a' not in found\n",
    "print(esta_en_lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tambien es posible remover la ocurrencia de un valor específico en la lista. Remove toma como argumento el objeto que se va a eliminar, remueve el elemento de la lista y reduce en uno su tamaño. Si el elemento no se encuentra en la lista se lanza un error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "found.remove('i')\n",
    "found\n",
    "print(len(found))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el caso en el que se requiera eliminar un elemento de una posición específica de la lista. El método pop recibe como parámetro la posición del elemento a remover. Las posiciones en las listas empiezan en cero. Si no se especifican parámetros, se remueve el último elemento de la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Arles', 'Johan', 'Monica', 'María', 'Mabel']\n",
      "['Arles', 'Monica', 'María', 'Mabel']\n",
      "Mabel ha sido eliminada de la lista.\n",
      "['Arles', 'Monica', 'María']\n"
     ]
    }
   ],
   "source": [
    "nombres = ['Arles', 'Johan', 'Monica', 'María', 'Mabel']\n",
    "print(nombres)\n",
    "nombres.pop(1) #remueve a Johan\n",
    "print(nombres)\n",
    "nombre_borrado = nombres.pop() # remueve a Mabel\n",
    "print(nombre_borrado + \" ha sido eliminada de la lista.\")\n",
    "print(nombres)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible agregar una lista al final de otra lista. Para esto se puede utilizar el método ```extend```. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Arles', 'Johan', 'Monica', 'María', 'Mabel', 'Barry', 'John', 'Guttag']\n"
     ]
    }
   ],
   "source": [
    "nombres = ['Arles', 'Johan', 'Monica', 'María', 'Mabel']\n",
    "otros_nombres = ['Barry', 'John', 'Guttag']\n",
    "\n",
    "nombres.extend(otros_nombres)\n",
    "print(nombres)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para agregar elementos en una posición específica de una lista se puede utilizar el método ```insert```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Guttag', 'Arles', 'Peter', 7891247812, 'Johan', 'Monica', 'María', 'Mabel']\n"
     ]
    }
   ],
   "source": [
    "nombres = ['Arles', 'Johan', 'Monica', 'María', 'Mabel']\n",
    "nombres.insert(0, 'Guttag') #posición valor\n",
    "nombres.insert(2, 'Peter') #list_name.insert(posición,valor)\n",
    "nombres.insert(len(nombres)//2, 7891247812)\n",
    "print(nombres)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como pedir ayuda sobre un método específico?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "append(self, object, /)\n",
      "    Append object to the end of the list.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(list.append)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio: \n",
    "\n",
    "Transforme la cadena ```El mejor regalo? El perdón...``` en ```regalo el perdón``` utilizando únicamente los métodos de listas que hemos visto. La nueva cadena debe guardarse en la variable ```nueva_frase```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El mejor regalo? El perdón...\n",
      "['E', 'l', ' ', 'm', 'e', 'j', 'o', 'r', ' ', 'r', 'e', 'g', 'a', 'l', 'o', '?', ' ', 'E', 'l', ' ', 'p', 'e', 'r', 'd', 'ó', 'n', '.', '.', '.']\n",
      "['r', 'e', 'g', 'a', 'l', 'o', ' ', 'e', 'l', ' ', 'p', 'e', 'r', 'd', 'ó', 'n']\n",
      "regalo el perdón\n"
     ]
    }
   ],
   "source": [
    "frase = \"El mejor regalo? El perdón...\"\n",
    "list_frase = list(frase)\n",
    "print(frase)\n",
    "print(list_frase) #deben jugar con esta lista\n",
    "\n",
    "#Aquí va la solución...\n",
    "\n",
    "nueva_frase = ''.join(list_frase)\n",
    "print(list_frase)\n",
    "print(nueva_frase)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias: \n",
    "\n",
    "Barry, P. (2016). Head First Python: A Brain-Friendly Guide. \" O'Reilly Media, Inc.\".\n",
    "\n",
    "Guttag, John. Introduction to Computation and Programming Using Python: With Application to Understanding Data Second Edition. MIT Press, 2016. ISBN: 9780262529624.\n",
    "\n",
    "\n",
    "https://www.w3schools.com/PYTHON/"
   ]
  },
  {
   "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
}