Clase16_Listas_Bidimensionales_2019.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"images/di.png\" alt=\"\" width=\"200px\" align=\"left\"/>\n",
    "<img src=\"images/utfsm.png\" alt=\"\" width=\"150px\" align=\"right\"/>\n",
    "\n",
    "<br/>\n",
    "<div align=\"center\">\n",
    "<h1>IWI131 Programación</h1><br/>\n",
    "<h2>Listas Bi-dimensionales (listas de listas)</h2>\n",
    "<br/><br/>\n",
    "Departamento de Informática<br/>\n",
    "Universidad Técnica Federico Santa María\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Listas Bi-dimensionales: Definición"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Las listas bi-dimensionales se caracterizan por que **al menos** un elemento de la lista es,  a su vez, otra lista."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Tambien se les llama: **listas de listas** o **listas anidadas**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Las listas de listas tienen las mismas caractersiticas que una lista normal (o uni-dimensional). Es decir:\n",
    "* Se les puede aplicar los métodos ya vistos: `.append()`, `.sort()`, `.remove()`, etc. \n",
    "* Estas listas pueden tener cualquier tamaño, incluso pueden crearse como listas vacias.\n",
    "* Pueden contener cualquier tipo de dato. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Ejemplo de listas de listas pueden ser:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista L1: [1, 2, 3, [4, 5, 6, 7, 8], 9]\n",
      "Lista L2: [True, 234, [1988, 4, 12], 'lista de listas', [False, '789']]\n",
      "Lista L3: [[], []]\n"
     ]
    }
   ],
   "source": [
    "L1 = [1,2,3, [4,5,6,7,8], 9]\n",
    "L2 = [True, 234, [1988, 4, 12], 'lista de listas', [False, '789']]\n",
    "L3 = [[],[]]\n",
    "print('Lista L1:', L1)\n",
    "print('Lista L2:', L2)\n",
    "print('Lista L3:', L3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Se debe tener conciencia que en estos casos, los elementos de las listas pueden ser elemetnos que pueden contener a su vez otros elementos. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Ejemplo** Los elementos de la lista `L1` son 5: 1, 2, 3, [4,5,6,7,8] y 9. Entonces, el cuarto elemento, es decir el elemento con el indice 3, es: [4,5,6,7,8] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "print(L1[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "print(L1[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Entonces, teniendo las listas `L1`, `L2`, y `L3`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista L1: [1, 2, 3, [4, 5, 6, 7, 8], 9]\n",
      "Lista L2: [True, 234, [1988, 4, 12], 'lista de listas', [False, '789']]\n",
      "Lista L3: [[], []]\n"
     ]
    }
   ],
   "source": [
    "print('Lista L1:', L1)\n",
    "print('Lista L2:', L2)\n",
    "print('Lista L3:', L3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "¿Qué nos entrega las siguientes instrucciones?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "v1 = L2[0]\n",
    "v2 = L2[-1]\n",
    "v3 = L3[1]\n",
    "v4 = L1[3:]\n",
    "v5 = L1[:3]\n",
    "v6 = L2[2:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "[False, '789']\n",
      "[]\n",
      "[[4, 5, 6, 7, 8], 9]\n",
      "[1, 2, 3]\n",
      "[[1988, 4, 12]]\n"
     ]
    }
   ],
   "source": [
    "print(v1)\n",
    "print(v2)\n",
    "print(v3)\n",
    "print(v4)\n",
    "print(v5)\n",
    "print(v6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Listas Bi-dimensionales: manejo de indices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "El manejo de indices en listas de listas aumenta un poco su complejidad, pero es importante entenderlo ya que es posible obtener cualquier valor y esto facilita mucho el trabajo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Hasta ahora sabemos que para obtener el valor de un elemento de una lista es necesario usar los paréntesis cuadrados o corchetes **[ ]**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Este operador (operador rebanador) nos permite acceder a elementos de un iterable, es decir: lista y string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Entonces, podemos usar tantas veces como queramos el operador rebanador, siempre y cuando tengamos al lado izquierda una lista o string.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Volvamos al ejemplo anterior, es decir, con las listas `L1`, `L2`, y `L3`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista L1: [1, 2, 3, [4, 5, 6, 7, 8], 9]\n",
      "Lista L2: [True, 234, [1988, 4, 12], 'lista de listas', [False, '789']]\n",
      "Lista L3: [[], []]\n"
     ]
    }
   ],
   "source": [
    "print('Lista L1:', L1)\n",
    "print('Lista L2:', L2)\n",
    "print('Lista L3:', L3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Si sabemos que: L1[3] es la lista [4,5,6,7,8], entonces podemos obtener el primer elemento de la siguiente manera:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El primer elemento de la sublista es: 4\n"
     ]
    }
   ],
   "source": [
    "sub_lista = L1[3]\n",
    "primer_elem = sub_lista[0]\n",
    "print('El primer elemento de la sublista es:',primer_elem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "De una manera abreviada, y más conveniente, podemos escribir lo mismo de la siguiente manera:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El primer elemento de la sublista es: 4\n"
     ]
    }
   ],
   "source": [
    "primer_elem = L1[3][0]\n",
    "print('El primer elemento de la sublista es:',primer_elem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Los paréntesis corchetes: **[ ]**, permiten acceder a la ubicación que le damos con el valor entero (positivo o negativo), pero además, **es posible realizar esto tantas veces como queramos siempre y cuando lo que este a lado izquierda sea una lista o un string.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Otro ejemplo: vamos a acceder a la palabra \"de\" del string \"listas de listas\" de la lista `L2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista L2: [True, 234, [1988, 4, 12], 'lista de listas', [False, '789']]\n"
     ]
    }
   ],
   "source": [
    "print('Lista L2:', L2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "de\n"
     ]
    }
   ],
   "source": [
    "string_completo = L2[3]\n",
    "palabra_de = string_completo[6:8]\n",
    "print(palabra_de)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "De manera abreviada, y **más conveniente** seria:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "de\n"
     ]
    }
   ],
   "source": [
    "print(L2[3][6:8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Entonces, ¿qué nos entrega las siguientes instrucciones?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista L1: [1, 2, 3, [4, 5, 6, 7, 8], 9]\n",
      "Lista L2: [True, 234, [1988, 4, 12], 'lista de listas', [False, '789']]\n",
      "Lista L3: [[], []]\n"
     ]
    }
   ],
   "source": [
    "print('Lista L1:', L1)\n",
    "print('Lista L2:', L2)\n",
    "print('Lista L3:', L3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x1 = L1[3][-1]\n",
    "x2 = L2[-1][0]\n",
    "x3 = L2[3][9:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "False\n",
      "listas\n"
     ]
    }
   ],
   "source": [
    "print(x1)\n",
    "print(x2)\n",
    "print(x3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "¿Y si generalizamos incluyendo más paréntesis corchetes?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "z1 = L1[3:][0][1]\n",
    "z2 = L2[:][-1][-1][-1]\n",
    "z3 = L2[::-1][1][::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "9\n",
      "satsil ed atsil\n"
     ]
    }
   ],
   "source": [
    "print(z1)\n",
    "print(z2)\n",
    "print(z3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Listas Bi-dimensioanles: recorrerlas mediante `for`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "La forma de recorrer las listas mediante `for` es muy sencilla. Se debe seguir las mismas reglas que para recorrer una lista uni-dimensional.\n",
    "\n",
    "Se debe poner atención que valores toma ahora la variable que se crea en el `for`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Veamos un ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista L2: [True, 234, [1988, 4, 12], 'lista de listas', [False, '789']]\n"
     ]
    }
   ],
   "source": [
    "print('Lista L2:', L2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valor de la variable elemento: True\n",
      "Valor de la variable elemento: 234\n",
      "Valor de la variable elemento: [1988, 4, 12]\n",
      "Valor de la variable elemento: lista de listas\n",
      "Valor de la variable elemento: [False, '789']\n"
     ]
    }
   ],
   "source": [
    "for elemento in L2:\n",
    "    print('Valor de la variable elemento:', elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Veamos otro ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Progra tiene 3 creditos\n",
      "Mate tiene 5 creditos\n",
      "Fisica tiene 3 creditos\n",
      "Ed.Fisica tiene 1 creditos\n",
      "Inmanente tiene 2 creditos\n"
     ]
    }
   ],
   "source": [
    "ramos = [['Progra','IWI-131', 3],\n",
    "         ['Mate', 'MAT-021', 5],\n",
    "         ['Fisica', 'FIS-100', 3],\n",
    "         ['Ed.Fisica', 'DEW-100', 1],\n",
    "         ['Inmanente', 'HRW-102', 2],\n",
    "        ]\n",
    "\n",
    "for nombre, sigla, c in ramos: # 3 variables en vez de 1\n",
    "    print(nombre, 'tiene', c, 'creditos')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**En la línea del `for` ahora hay 3 variables en vez de 1**. Esto es posible ya que sabemos que cada elemento de la lista ramos, **siempre**, tendrá 3 elementos. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "La lista **ramos** es una lista de listas, donde cada sub-lista siempre tiene 3 elementos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Cada variable creada en la linea del `for`, tomará cada valor de las sub-listas. Esto será en orden, es decir: primera variable con el primer elemento de la sub-lista, y así sucesivamente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Siguiendo el ejemplo anterior, es posible recorrer cada sub-lista para así obtener cada elemento uno por uno sin que falte ninguno. Esto se hace con un `for` adicional:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valor de la variable asignatura: ['Progra', 'IWI-131', 3]\n",
      "Valor de la variable dato: Progra\n",
      "Valor de la variable dato: IWI-131\n",
      "Valor de la variable dato: 3\n",
      "Valor de la variable asignatura: ['Mate', 'MAT-021', 5]\n",
      "Valor de la variable dato: Mate\n",
      "Valor de la variable dato: MAT-021\n",
      "Valor de la variable dato: 5\n",
      "Valor de la variable asignatura: ['Fisica', 'FIS-100', 3]\n",
      "Valor de la variable dato: Fisica\n",
      "Valor de la variable dato: FIS-100\n",
      "Valor de la variable dato: 3\n",
      "Valor de la variable asignatura: ['Ed.Fisica', 'DEW-100', 1]\n",
      "Valor de la variable dato: Ed.Fisica\n",
      "Valor de la variable dato: DEW-100\n",
      "Valor de la variable dato: 1\n",
      "Valor de la variable asignatura: ['Inmanente', 'HRW-102', 2]\n",
      "Valor de la variable dato: Inmanente\n",
      "Valor de la variable dato: HRW-102\n",
      "Valor de la variable dato: 2\n"
     ]
    }
   ],
   "source": [
    "ramos = [['Progra','IWI-131', 3],\n",
    "         ['Mate', 'MAT-021', 5],\n",
    "         ['Fisica', 'FIS-100', 3],\n",
    "         ['Ed.Fisica', 'DEW-100', 1],\n",
    "         ['Inmanente', 'HRW-102', 2],\n",
    "        ]\n",
    "\n",
    "for asignatura in ramos: \n",
    "    print('Valor de la variable asignatura:', asignatura)\n",
    "    for dato in asignatura:\n",
    "        print('Valor de la variable dato:', dato)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Listas N-dimensionales o listas de listas de listas de listas ... de listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Como hemos visto, podemos imaginar, y nada nos prohibe, crear listas n-dimensionales. \n",
    "Esto quiere decir que podemos tener varias \"listas anidadas\" dentro de una gran lista. \n",
    "Veamos un ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3, 4, [11, 22, 33]], [5, 6, 7, [66]], [[88, 99], 8, 9, [88, 99, [888, [8888, 9999]]]]]\n"
     ]
    }
   ],
   "source": [
    "L = [[1,2,3,4,[11,22,33]],[5,6,7,[66]],[[88,99],8,9, [88,99,[888,[8888,9999]]]]]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a1 = L[0]\n",
    "a2 = L[2][3][0]\n",
    "a3 = L[1][-1]\n",
    "a4 = L[-1][-1][-1][1][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, [11, 22, 33]]\n",
      "88\n",
      "[66]\n",
      "8888\n"
     ]
    }
   ],
   "source": [
    "print(a1)\n",
    "print(a2)\n",
    "print(a3)\n",
    "print(a4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Cada paréntesis corchete nos permite adentrarnos más a la lista. Recuerdar que esto es posible si el elemento de la lista es un iterable: string o lista**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Ejercicios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "1.- Dada las siguientes listas, diga que entrega las expresiones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = [5, 1, 4, 9, 0]\n",
    "b = list(range(3, 10)) + list(range(20, 23))\n",
    "c = [[1, 2], [3, 4, 5], [6, 7]]\n",
    "d = ['perro', 'gato', 'jirafa', 'elefante']\n",
    "e = ['a', a, 2 * a]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fin\n"
     ]
    }
   ],
   "source": [
    "a[2]\n",
    "b[9]\n",
    "c[1][2]\n",
    "e[0] == e[1]\n",
    "len(c)\n",
    "len(c[0])\n",
    "len(e)\n",
    "c[-1]\n",
    "c[-1][+1]\n",
    "c[2:] + d[2:]\n",
    "a[3:10]\n",
    "a[3:10:2]\n",
    "d.index('jirafa')\n",
    "e[c[0][1]].count(5)\n",
    "a.sort()\n",
    "a[2]\n",
    "print('fin')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**2.** Usted desea ir al cine a ver la próxima película del estudio _Marvel_ lo antes posible para evitar los molestos _spoilers_. Para ello la página del cine le muestra la lista `sala` con la disponibilidad de asientos. La sala del cine siempre será representada por una lista con `n` listas, cada una de ellas con `n` strings. Cada string puede tener los valores `O` que indica que el asiento está disponible o `X` que indica que está ocupado. El siguiente es un ejemplo para `n` igual a 5. **Nota:** el valor de `n` no debería ser importante.\n",
    "\n",
    "```\n",
    "sala = [\n",
    "[\"X\",\"X\",\"X\",\"O\",\"O\"],\n",
    "[\"X\",\"X\",\"X\",\"X\",\"O\"],\n",
    "[\"X\",\"O\",\"X\",\"O\",\"X\"],\n",
    "[\"X\",\"X\",\"X\",\"X\",\"O\"],\n",
    "[\"O\",\"O\",\"X\",\"O\",\"O\"],\n",
    "]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "sala = [\n",
    "[\"X\",\"X\",\"X\",\"O\",\"O\"],\n",
    "[\"X\",\"X\",\"X\",\"X\",\"O\"],\n",
    "[\"X\",\"O\",\"X\",\"O\",\"X\"],\n",
    "[\"X\",\"X\",\"X\",\"X\",\"O\"],\n",
    "[\"O\",\"O\",\"X\",\"O\",\"O\"],\n",
    "]\n",
    "\n",
    "sala2 = [\n",
    "[\"X\",\"X\",\"X\"],\n",
    "[\"X\",\"X\",\"X\"],\n",
    "[\"X\",\"X\",\"X\"],\n",
    "[\"X\",\"X\",\"X\"]\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Escriba la función `asientos_disponibles(sala)` que indique si la sala del cine tiene asientos disponibles. La función debe retornar `True` si la sala tiene asientos disponibles y `False` en caso contrario.\n",
    "```python\n",
    ">>> asientos_disponibles(sala)\n",
    "True\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def asientos_disponibles(sala):\n",
    "    for fila in sala:\n",
    "        for asiento in fila:\n",
    "            if asiento == 'O':\n",
    "                return True #encontramos algun asiento disponible\n",
    "    return False #nunca encontramos un asiento disponible"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "asientos_disponibles(sala)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "asientos_disponibles(sala2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Escriba la función `disponible(fila,columna,sala)` que reciba una `sala` del cine. La función debe retornar `True` si el asiento de la `fila` y `columna` ingresados está disponible y `False` en caso contrario. Si ingresa una `fila` o `columna` que no existan también deberá retornar `False`.\n",
    "\n",
    "```python\n",
    ">>> disponible(2, 4, sala)\n",
    "False\n",
    ">>> disponible(10, 4, sala)\n",
    "False\n",
    ">>> disponible(0, 3, sala)\n",
    "True\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def disponible(fila, columna, sala):\n",
    "    if -len(sala) <= fila < len(sala):# que significa esta condicion\n",
    "        if -len(sala[fila]) < columna < len(sala[fila]): #que significa esta condicion\n",
    "            return sala[fila][columna] == \"O\"\n",
    "        else:\n",
    "            return False\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "disponible(2, 4, sala)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "disponible(10, 4, sala)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "disponible(0, 3, sala)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Escriba la función `porcentaje_disponible(sala)` que indique porcentualmente la disponibilidad de una sala de cine.\n",
    "```python \n",
    ">>> porcentaje_disponible(sala)\n",
    "0.2\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def porcentaje_disponible(sala):\n",
    "    cantidad_asientos = 0\n",
    "    cantidad_disponible = 0\n",
    "    for fila in sala:\n",
    "        for asiento in fila:\n",
    "            if asiento == 'O':\n",
    "                cantidad_disponible+=1\n",
    "            cantidad_asientos+=1\n",
    "    return round(cantidad_disponible/cantidad_asientos,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "porcentaje_disponible(sala)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "porcentaje_disponible(sala2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Usted desea ir con sus `m` amigos a ver la película y todos quieren ir a ver la película en la misma sala de cine. Debid al grán éxito en la pre-venta es posible que no queden muchos asientos. Escriba la función `hay_espacio_suficiente(m,sala)` que reciba un entero `m` con la cantidad de amigos (usted incluido) que quieren ir a ver la película y la `sala` del cine. La función debe retornar `True` si hay espacio suficiente para que todos puedan ver la película en la sala de cine o `False` en caso contrario :(\n",
    "\n",
    "```python\n",
    ">>> hay_espacio_suficiente(12, sala)\n",
    "False\n",
    ">>> hay_espacio_suficiente(3, sala)\n",
    "True\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def hay_espacio_suficiente(m,sala):\n",
    "    cantidad_disponible = 0\n",
    "    for fila in sala:\n",
    "        for asiento in fila:\n",
    "            if asiento == 'O':\n",
    "                cantidad_disponible+=1\n",
    "    if m <= cantidad_disponible:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hay_espacio_suficiente(12,sala)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hay_espacio_suficiente(3,sala)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hay_espacio_suficiente(5,sala)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ingrese numero1\n",
      "ingrese numero4\n",
      "ingrese numero2\n",
      "ingrese numero4\n",
      "ingrese numero3\n",
      "['1', '4', '2', '4', '3']\n"
     ]
    }
   ],
   "source": [
    "nueva_lista = []\n",
    "for i in range(5):\n",
    "    a = input(\"ingrese numero\")\n",
    "    nueva_lista.append(a)\n",
    "print(nueva_lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1,2,3,4]\n",
      "[1,2,3,4]\n"
     ]
    }
   ],
   "source": [
    "a = input()\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}