IntroPython_Listas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listas en Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type([]) # la lista vacía [] es una instancia de la clase list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len([]) # la longitud es el número de elementos que contiene"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len([10,20,30])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['uno', 2, 'tres']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[\"uno\",2,\"tres\"] # pueden tener valores de tipo diferente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Además de con [], una lista vacía se puede crear con list:\n",
    "[] == list()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Las listas son objetos\n",
    "\n",
    "Y las variables que contienen una lista son meras referencias a ellos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = []\n",
    "b = []\n",
    "c = a\n",
    "print(a == b) # = pregunta si SON IGUALES\n",
    "print(a is c) # is pregunta si son EL MISMO objeto\n",
    "print(a is b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Las listas son **MUTABLES**\n",
    "\n",
    "Observa en este ejemplo que si modifico la variable `a` se modifica el contenido de la lista `c` pero no el de la lista `b`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['hola'] ['bolígrafo'] ['hola']\n"
     ]
    }
   ],
   "source": [
    "a.append(\"hola\")\n",
    "b.append(\"bolígrafo\")\n",
    "print(a,b,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Las listas, como cualquier objeto Python, tienen identidad:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "139848767659144\n",
      "139848767659464\n",
      "139848767659144\n"
     ]
    }
   ],
   "source": [
    "print(id(a)) # id(x) devuelve un número único para cada objeto\n",
    "print(id(b))\n",
    "print(id(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos acceder a los elementos de una lista utilizando índices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'uno'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [\"uno\",\"dos\",\"tres\",\"cuatro\",\"cinco\"]\n",
    "a[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(a)):\n",
    "    print(i) # imprime los números 0 a len(a)-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 uno\n",
      "1 dos\n",
      "2 tres\n",
      "3 cuatro\n",
      "4 cinco\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(a)):\n",
    "    print(i, a[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "uno\n",
      "dos\n",
      "tres\n",
      "cuatro\n",
      "cinco\n"
     ]
    }
   ],
   "source": [
    "for x in a:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 uno\n",
      "1 dos\n",
      "2 tres\n",
      "3 cuatro\n",
      "4 cinco\n"
     ]
    }
   ],
   "source": [
    "for i,x in enumerate(a):\n",
    "    print(i,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cinco\n"
     ]
    }
   ],
   "source": [
    "print(a[-1]) # índices negativos permiten acceder desde el final"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algunas operaciones sencillas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3] + [4,5,6] # concatenar listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 1, 1, 1]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1] * 5 # una lista formada por 5 1's"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[], [], [], [], []]\n"
     ]
    }
   ],
   "source": [
    "a = [[]]*5 # una lista de 5 listas\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['hola'], ['hola'], ['hola'], ['hola'], ['hola']]\n"
     ]
    }
   ],
   "source": [
    "# se puede pensar que es útil para hacer una matriz mediante lista de listas\n",
    "# ¡¡¡pero es peligroso!!!\n",
    "a[0].append(\"hola\")\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[], [], [], [], []]\n",
      "[['Hola'], [], [], [], []]\n"
     ]
    }
   ],
   "source": [
    "# la forma correcta de hacer una lista de listas es:\n",
    "a = [[] for i in range(5)] # listas intensionales, se ven en otro notebook\n",
    "print(a)\n",
    "a[0].append(\"Hola\")\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Es posible acceder utilizando un *slice* en lugar de un simple índice:\n",
    "\n",
    "La sintaxis de un *slice* puede llevar uno o dos \":\" y en medio podemos tener 0,1,2 ó 3 valores enteros (sea un literal sea una expresión): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['tres', 'cuatro']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2:4] # desde el índice 2 hasta el 4 NO INCLUSIVE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['tres', 'cuatro', 'cinco']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['uno', 'dos', 'tres']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2:2] # con este slice no se obtiene nada pq 2>=2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['uno', 'dos', 'tres', 'cuatro', 'cinco']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:] # con este slice no se obtiene una lista del mismo tamaño pero es NUEVA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "a = ['uno', 'dos', 'tres', 'cuatro', 'cinco', 'la original']\n",
      "b = ['uno', 'dos', 'tres', 'cuatro', 'cinco', 'la nueva']\n"
     ]
    }
   ],
   "source": [
    "# con más detalle:\n",
    "b = a[:] # b es una COPIA de a, no son el mismo objeto\n",
    "print(a is b)\n",
    "a.append(\"la original\")\n",
    "b.append(\"la nueva\")\n",
    "print(\"a =\",a)\n",
    "print(\"b =\",b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "a = ['uno', 'dos', 'tres', 'cuatro', 'cinco', 'la original', 'la original', 'la original']\n",
      "b = ['uno', 'dos', 'tres', 'cuatro', 'cinco', 'la original', 'la original', 'la nueva']\n"
     ]
    }
   ],
   "source": [
    "# b = a[:] es una forma de copiar una lista, otra forma es:\n",
    "b = a.copy()\n",
    "print(a is b)\n",
    "a.append(\"la original\")\n",
    "b.append(\"la nueva\")\n",
    "print(\"a =\",a)\n",
    "print(\"b =\",b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['uno', 'tres', 'cinco']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [\"uno\",\"dos\",\"tres\",\"cuatro\",\"cinco\"]\n",
    "# un slice puede tener un tercer argumento que es el step o paso:\n",
    "a[::2] # de 2 en 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cinco', 'cuatro', 'tres', 'dos']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# con un step o paso negativo se puede recorrer hacia atrás:\n",
    "a[5:0:-1] # observa que para en el 1 y no en el 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cinco', 'cuatro', 'tres', 'dos', 'uno']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['uno', 'dos', 'tres', 'cuatro', 'cinco']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['cinco', 'cuatro', 'tres', 'dos', 'uno']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# por cierto, otra forma de darle la vuelta a una lista:\n",
    "print(a)\n",
    "list(reversed(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n",
      "['h', 'o', 'l', 'a']\n"
     ]
    }
   ],
   "source": [
    "# list permite construir una lista con cualquier cosa que sea ITERABLE:\n",
    "print(list(range(5)))\n",
    "print(list(\"hola\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<list_reverseiterator at 0x7f0784b88128>"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mientras que reversed NO devuelve una lista sino que es algo que puede ser iterado:\n",
    "reversed(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cero\n",
      "uno\n",
      "dos\n"
     ]
    }
   ],
   "source": [
    "for x in reversed(a):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a antes de reverse: ['cero', 'uno', 'dos']\n",
      "el resultado de reverse es: None\n",
      "ahora a vale ['dos', 'uno', 'cero']\n"
     ]
    }
   ],
   "source": [
    "# NO CONFUNDIR reversed(lista) con lista.reverse()\n",
    "print(\"a antes de reverse:\",a)\n",
    "b = a.reverse() # da la vuelta a la lista IN PLACE, es decir, NO DEVUELVE NADA\n",
    "print(\"el resultado de reverse es:\", b)\n",
    "print(\"ahora a vale\",a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['uno', 'dos', 'tres', 'cuatro', 'cinco']\n",
      "['cinco', 'cuatro', 'dos', 'tres', 'uno']  (es el orden lexicográfico o alfabético)\n",
      "el método sort devuelve None\n",
      "tras sort, a vale: ['cinco', 'cuatro', 'dos', 'tres', 'uno']\n"
     ]
    }
   ],
   "source": [
    "# de forma similar, tenemos un método sort() que no hay que confundir con sorted:\n",
    "print(a)\n",
    "print(sorted(a),\" (es el orden lexicográfico o alfabético)\")\n",
    "b = a.sort() # la variable b se guarda lo que devuelve el método sort\n",
    "print(\"el método sort devuelve\",b)\n",
    "print(\"tras sort, a vale:\",a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['uno', 'dos', 'tres', 'cuatro', 'cinco']\n",
      "['uno', 'segunda posición', 'tres', 'cuatro', 'cinco']\n"
     ]
    }
   ],
   "source": [
    "# al indexar una lista también podemos asignar un valor a una posición:\n",
    "print(a)\n",
    "a[1] = \"segunda posición\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list assignment index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-5d5bdc983b64>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# pero no podemos salirnos de rango:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m\"cero\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"uno\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"dos\"\u001b[0m \u001b[0;31m# a[2] no existe en una lista de longitud 2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: list assignment index out of range"
     ]
    }
   ],
   "source": [
    "# pero no podemos salirnos de rango:\n",
    "a = [\"cero\", \"uno\"]\n",
    "a[2] = \"dos\" # a[2] no existe en una lista de longitud 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Utilización de un slice en una asignación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 50, 30, 40]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# esto ya debería de estar claro:\n",
    "a = [10,20,30,40]\n",
    "a[1] = 50\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 8, 9, 30, 40]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# pero también es posible utilizar un slice:\n",
    "a[:2] = [7,8,9] # reemplaza los 2 primeros valores por 7,8,9\n",
    "# observa que el tamaño de la lista cambia:\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[200, 300]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# en particular, esto permite cosas como esta:\n",
    "a[:] = [200,300]\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ¿qué diferencia hay entre la instrucción anterior y esta otra?\n",
    "a = [200,300]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La diferencia es que `a[:] = ...` no cambia la identidad de `a` mientras que `a= [...` sí lo hace."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Algunos métodos más de la clase `list`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[] []\n"
     ]
    }
   ],
   "source": [
    "a = [8,9,10]\n",
    "b = a # b es una REFERENCIA A LA MISMA LISTA que a\n",
    "a.clear() # se carga el contenido de a\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[] [8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "a = [8,9,10]\n",
    "b = a\n",
    "a = []\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cero', 'uno', 'dos']"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# una forma correcta de añadir algo al final de una lista:\n",
    "a = [\"cero\", \"uno\"]\n",
    "a.append(\"dos\")\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cero', 'uno', 'dos']\n",
      "['cero', 'uno', 'dos', 'tres', 'cuatro', 'cinco']\n"
     ]
    }
   ],
   "source": [
    "# si queremos insertar varias cosas podemos utilizar el método extend:\n",
    "print(a)\n",
    "a.extend(['tres','cuatro','cinco'])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cero', 'uno', 'dos', 'tres', 'cuatro', 'cinco']\n",
      "cinco\n",
      "['cero', 'uno', 'dos', 'tres', 'cuatro']\n"
     ]
    }
   ],
   "source": [
    "# lo contrario de append sería pop:\n",
    "print(a)\n",
    "print(a.pop())\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cero\n",
      "['uno', 'dos', 'tres', 'cuatro']\n"
     ]
    }
   ],
   "source": [
    "# pop permite que le digamos de qué posición sacar el elemento:\n",
    "print(a.pop(0))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# index permite buscar un elemento dentro de una lista:\n",
    "a = ['hola','adios','hola']\n",
    "a.index('adios')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# index permite dar 2 argumentos más indicando el rango de posiciones donde buscar:\n",
    "print(a.index('hola'))   # devuelve 0\n",
    "print(a.index('hola',1)) # devuelve 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "'hello' is not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-95-2b1ac3a61a5b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# pero dispara un error si el elemento no se encuentra:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"hello\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: 'hello' is not in list"
     ]
    }
   ],
   "source": [
    "# pero dispara un error si el elemento no se encuentra:\n",
    "a.index(\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El elemento no se ha encontrado\n"
     ]
    }
   ],
   "source": [
    "# Podemos capturar la excepción con un bloque try except:\n",
    "try:\n",
    "    posicion = a.index(\"hello\")\n",
    "    print(\"El elemento se encuentra en la posicion\",pos)\n",
    "except ValueError:\n",
    "    print(\"El elemento no se ha encontrado\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello no se encuentra en la lista ['hola', 'adios', 'hola']\n"
     ]
    }
   ],
   "source": [
    "# una forma de ver si un elemento se encuentra en una lista (sin saber su posición)\n",
    "# es utilizar in:\n",
    "w = \"hello\"\n",
    "if w in a:\n",
    "    print(w,\"se encuentra en la lista\",a)\n",
    "else:\n",
    "    print(w,\"no se encuentra en la lista\",a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello se encuentra 3 veces en ['hello', 'world', 'hello', 'hello']\n"
     ]
    }
   ],
   "source": [
    "# y para saber el número de veces que se encuentra:\n",
    "w = 'hello'\n",
    "a = ['hello','world','hello','hello']\n",
    "veces = a.count(w)\n",
    "print(w,'se encuentra',veces,'veces en',a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello se encuentra 3 veces en ['hello', 'world', 'hello', 'hello']\n"
     ]
    }
   ],
   "source": [
    "# otra forma utilizando el método format de str:\n",
    "print('{} se encuentra {} veces en {}'.format(w,a.count(w),a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello se encuentra 3 veces en ['hello', 'world', 'hello', 'hello']\n"
     ]
    }
   ],
   "source": [
    "# otra forma utilizando cadenas con formato:\n",
    "print(f'{w} se encuentra {a.count(w)} veces en {a}')"
   ]
  },
  {
   "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}