Python_CoderDojo10.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python_CoderDojo10.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMsDemzM3u++3s63qfCNwVC",
      "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": [
        "<a href=\"https://colab.research.google.com/github/seldoncode/Python_CoderDojo/blob/main/Python_CoderDojo10.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l9p5vZJhKiiq"
      },
      "source": [
        "# Métodos\n",
        "Los métodos son funciones que se aplican a objetos.\n",
        "Por ejemplo:\n",
        "* los objetos de tipo string (```str```) o cadena alfanumérica tienen una serie de métodos, por ejemplo ```len```\n",
        "* los objetos de tipo lista tienen otra serie de métodos, por ejemplo ```len```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DAM14rbTKemi",
        "outputId": "dc7c04c6-58b4-4c19-cb5b-590fc4963784"
      },
      "source": [
        "len('Hola')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SDZkr-zMLQzx",
        "outputId": "d0a28c44-400d-4fcd-dd4d-ce9bc4126792"
      },
      "source": [
        "len([10,20,30])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xvVLRTDQLZe5"
      },
      "source": [
        "## Listar los métodos de un tipo de objeto con ```dir```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9QUIzxOMLilz",
        "outputId": "7179b0d1-9d71-4525-a160-f838ad7831de"
      },
      "source": [
        "dir(str)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['__add__',\n",
              " '__class__',\n",
              " '__contains__',\n",
              " '__delattr__',\n",
              " '__dir__',\n",
              " '__doc__',\n",
              " '__eq__',\n",
              " '__format__',\n",
              " '__ge__',\n",
              " '__getattribute__',\n",
              " '__getitem__',\n",
              " '__getnewargs__',\n",
              " '__gt__',\n",
              " '__hash__',\n",
              " '__init__',\n",
              " '__init_subclass__',\n",
              " '__iter__',\n",
              " '__le__',\n",
              " '__len__',\n",
              " '__lt__',\n",
              " '__mod__',\n",
              " '__mul__',\n",
              " '__ne__',\n",
              " '__new__',\n",
              " '__reduce__',\n",
              " '__reduce_ex__',\n",
              " '__repr__',\n",
              " '__rmod__',\n",
              " '__rmul__',\n",
              " '__setattr__',\n",
              " '__sizeof__',\n",
              " '__str__',\n",
              " '__subclasshook__',\n",
              " 'capitalize',\n",
              " 'casefold',\n",
              " 'center',\n",
              " 'count',\n",
              " 'encode',\n",
              " 'endswith',\n",
              " 'expandtabs',\n",
              " 'find',\n",
              " 'format',\n",
              " 'format_map',\n",
              " 'index',\n",
              " 'isalnum',\n",
              " 'isalpha',\n",
              " 'isascii',\n",
              " 'isdecimal',\n",
              " 'isdigit',\n",
              " 'isidentifier',\n",
              " 'islower',\n",
              " 'isnumeric',\n",
              " 'isprintable',\n",
              " 'isspace',\n",
              " 'istitle',\n",
              " 'isupper',\n",
              " 'join',\n",
              " 'ljust',\n",
              " 'lower',\n",
              " 'lstrip',\n",
              " 'maketrans',\n",
              " 'partition',\n",
              " 'replace',\n",
              " 'rfind',\n",
              " 'rindex',\n",
              " 'rjust',\n",
              " 'rpartition',\n",
              " 'rsplit',\n",
              " 'rstrip',\n",
              " 'split',\n",
              " 'splitlines',\n",
              " 'startswith',\n",
              " 'strip',\n",
              " 'swapcase',\n",
              " 'title',\n",
              " 'translate',\n",
              " 'upper',\n",
              " 'zfill']"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aY0JdG9JLwmx"
      },
      "source": [
        "### ```upper```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "S3N5yHmWL1A6",
        "outputId": "072faf45-8592-4d6a-aa6f-1e5c277c100e"
      },
      "source": [
        "cadena = \"Vivo en Los Ángeles pero en Navidad regreso a Madrid.\"\n",
        "cadena.upper()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'VIVO EN LOS ÁNGELES PERO EN NAVIDAD REGRESO A MADRID.'"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vycpp-1VMJr_"
      },
      "source": [
        "## ```lower```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "-jc3edToMPB5",
        "outputId": "f839f7ce-ecb2-45ac-900e-840459b8cdc6"
      },
      "source": [
        "minusculas = cadena.lower()              # asignamos el resultado a una nueva variable, la variable original 'cadena' no ha variado\n",
        "minusculas"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'vivo en los ángeles pero en navidad regreso a madrid.'"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AWXS0kmEMVGx"
      },
      "source": [
        "## ```capitalize```\n",
        "Pone en mayúscula solo el primer caracter de la cadena."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "MHU4MSADMZoo",
        "outputId": "4a9b67d8-5d94-4b9a-97ee-bec3e71198d8"
      },
      "source": [
        "cadena.capitalize()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Vivo en los ángeles pero en navidad regreso a madrid.'"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "fBiqaf0_Mk05",
        "outputId": "40926a93-1cb6-4153-dba8-3d21bd905916"
      },
      "source": [
        "ciudad = \"roma\"\n",
        "ciudad.capitalize()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Roma'"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zkfmd69XNTwj"
      },
      "source": [
        "## ```title```\n",
        "Pone en mayúscula el primer caracter de cada palabra de la cadena."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "z08CMnyHNY1s",
        "outputId": "85dd7633-d982-43f3-b0ab-71a153102529"
      },
      "source": [
        "destino = \"new york\"\n",
        "destino.title()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'New York'"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A83Pw8aRORPB"
      },
      "source": [
        "### Responder s/n en mayúsculas o minúsculas\n",
        "Procedimiento que acepta que respondamos a una pregunta con mayúsculas o minúsculas las letras s o n, para contestar si o no."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Nt87i07hOkXX",
        "outputId": "31b26db0-96cd-4a57-dec4-e024d980d839"
      },
      "source": [
        "respuesta = input(\"Quiere salir del juego (s/n): \")\n",
        "if respuesta.lower()==\"s\":                              # tanto si pulsamos s como S, el juego finaliza\n",
        "  print(\"Juego finalizado.\")\n",
        "else:\n",
        "  print(\"Volvamos a jugar.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Quiere salir del juego (s/n): S\n",
            "Juego finalizado.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vZDiCj8IQShJ"
      },
      "source": [
        "## Ayuda sobre los métodos de un objeto\n",
        "* Podemos solicitar ayuda sobre todos los métodos de un tipo de objeto, por ejemplo sobre str:\n",
        " - ```help(str)```\n",
        "* Podemos solicitar ayuda sobre un método concreto:\n",
        " - ```help(str.title)```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dCdNwZ9kQ0Q0",
        "outputId": "48617fb8-ec19-41d8-d627-eb833c9ca653"
      },
      "source": [
        "help(str.title)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Help on method_descriptor:\n",
            "\n",
            "title(self, /)\n",
            "    Return a version of the string where each word is titlecased.\n",
            "    \n",
            "    More specifically, words start with uppercased characters and all remaining\n",
            "    cased characters have lower case.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IXWEGJYaRDdc"
      },
      "source": [
        "## ```strip```\n",
        "* Elimina espacios al inicio y al final del string.\n",
        "* También puede eliminar otro tipo de caracteres que indiquemos, al inicio y al final."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "_19wL_bqRNHc",
        "outputId": "b7bf2938-157f-4cdd-ca22-151be14b5220"
      },
      "source": [
        "frase = \"  informe de resultados     \"         # queremos eliminar los espacios en blanco al inicio y al final de la frase\n",
        "frase.strip()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'informe de resultados'"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "EYgLeQouR6Fu",
        "outputId": "93eaf489-3aee-414d-9159-687bf3ef063e"
      },
      "source": [
        "frase = \"::::Salida por pantalla: terminal:::::\"\n",
        "frase_limpia = frase.strip(':')                    # elimina el caracter ':' del inicio y del final, pero no del centro\n",
        "frase_limpia                                       # nueva variable, la variable original no se altera"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Salida por pantalla: terminal'"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "TfA8FMtjSjhH",
        "outputId": "70c0f978-1cc8-423d-9a71-3262580aaab0"
      },
      "source": [
        "resultado = \"1,2,3,4,5,\"\n",
        "resultado.strip(',')                               # muy útil para quitar la última coma de un listado"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'1,2,3,4,5'"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "alfxJvv-TPz5"
      },
      "source": [
        "## ```split```\n",
        "Separa una los elementos de una cadena.\n",
        "* Si no se pone argumento, separa por los espacios\n",
        "* Si el argumento es un caracter, separa por ese caracter"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pdUoeQs2TfzS",
        "outputId": "c20b2a93-015b-4798-af17-b6124f346ce1"
      },
      "source": [
        "frase = \"La probabilidad nunca es cero. Tiende a cero.\"\n",
        "frase.split()                                                 # devuelve una lista"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['La', 'probabilidad', 'nunca', 'es', 'cero.', 'Tiende', 'a', 'cero.']"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_8GYx4S7UIo6",
        "outputId": "c2c07877-adeb-4858-cb2c-f630e1cbe4ee"
      },
      "source": [
        "frase.split('.')                                              # separa por el punto, eliminando el punto"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['La probabilidad nunca es cero', ' Tiende a cero', '']"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IDUpn7VvUTWE",
        "outputId": "1fa995a4-193a-4d63-9efe-8a99868a2e81"
      },
      "source": [
        "frase.split(\" \")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['La', 'probabilidad', 'nunca', 'es', 'cero.', 'Tiende', 'a', 'cero.']"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "38gV0nRiVfI5"
      },
      "source": [
        "### Programa que separa todas las palabras de un texto\n",
        "Devuelve las palabras sin:\n",
        "* sin espacios\n",
        "* sin comas\n",
        "* sin puntos "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZHOuCzfz2e-m",
        "outputId": "db21c261-3125-4934-bc10-67754b87b747"
      },
      "source": [
        "# Blas de Otero\n",
        "poema = '''Por los puentes de Zamora,\n",
        "sola y lenta, iba mi alma.\n",
        "\n",
        "No por el puente de hierro,\n",
        "el de piedra es el que amaba.\n",
        "\n",
        "A ratos miraba al cielo,\n",
        "a ratos miraba al agua.\n",
        "\n",
        "Por los puentes de Zamora,\n",
        "sola y lenta, iba mi alma.'''\n",
        "\n",
        "palabras = poema.split()\n",
        "for palabra in palabras:\n",
        "  palabra = palabra.strip('.')\n",
        "  palabra = palabra.strip(',')\n",
        "  print(palabra)\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Por\n",
            "los\n",
            "puentes\n",
            "de\n",
            "Zamora\n",
            "sola\n",
            "y\n",
            "lenta\n",
            "iba\n",
            "mi\n",
            "alma\n",
            "No\n",
            "por\n",
            "el\n",
            "puente\n",
            "de\n",
            "hierro\n",
            "el\n",
            "de\n",
            "piedra\n",
            "es\n",
            "el\n",
            "que\n",
            "amaba\n",
            "A\n",
            "ratos\n",
            "miraba\n",
            "al\n",
            "cielo\n",
            "a\n",
            "ratos\n",
            "miraba\n",
            "al\n",
            "agua\n",
            "Por\n",
            "los\n",
            "puentes\n",
            "de\n",
            "Zamora\n",
            "sola\n",
            "y\n",
            "lenta\n",
            "iba\n",
            "mi\n",
            "alma\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2mjnnn-C5hVi"
      },
      "source": [
        "### Formatear una carta\n",
        "Se pregunta al usuario por tres argumentos:\n",
        "* tratamiento: Sr/Sra  según se trate de señor o señora. Admite mayúsculas o minúsculas, pero luego lo imprime correctamente.\n",
        "* Nombre. Admite mayúsculas o minúsculas, pero luego lo imprime correctamente.\n",
        "* Apellido. Admite mayúsculas o minúsculas, pero luego lo imprime correctamente.\n",
        "* Si es señor pone la palabra 'elegido' si es señora pone la palabra 'elegida'.\n",
        "* El texto es el siguiente con estos datos:\n",
        " - sr\n",
        " - alberto josé\n",
        " - gil\n",
        "\n",
        " Sr. Alberto José Gil.\n",
        " Le comunico que ha sido elegido\n",
        " para formar parte del jurado que cocederá\n",
        " el premio de poesía anual que otorga nuestra\n",
        " asociación de escritores."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gD1BQr-F8OvA",
        "outputId": "462180f5-328d-4d25-90bc-d5fb9613ae89"
      },
      "source": [
        "print(\"MODELO DE CARTA\")\n",
        "while True:\n",
        "  tratamiento = input(\"Indique el tratamiento Sr/Sra: \")\n",
        "  nombre = input(\"Indique el nombre: \")\n",
        "  apellido = input(\"Indique el apellido: \")\n",
        "  tratamiento = tratamiento.strip()\n",
        "  tratamiento = tratamiento.strip('.')\n",
        "  tratamiento = tratamiento.capitalize()\n",
        "  nombre = nombre.title()\n",
        "  apellido = apellido.title()\n",
        "\n",
        "  if tratamiento==\"Sr\":\n",
        "    oa=\"o\"\n",
        "  else:\n",
        "    oa=\"a\"\n",
        "\n",
        "  print(f\"\\n{tratamiento}. {nombre} {apellido}. \\nLe comunico que ha sido elegid{oa} \\npara formar parte del jurado \\nque cocederá el premio de poesía \\nanual que otorga nuestra \\nasociación de escritores.\")\n",
        "  print()\n",
        "  seguir = input(\"Desea imprimir otra carta (s/n): \")\n",
        "  if seguir.lower()=='n':\n",
        "    break"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "MODELO DE CARTA\n",
            "Indique el tratamiento Sr/Sra: sr\n",
            "Indique el nombre: alberto miguel\n",
            "Indique el apellido: olmo poza\n",
            "\n",
            "Sr. Alberto Miguel Olmo Poza. \n",
            "Le comunico que ha sido elegido \n",
            "para formar parte del jurado \n",
            "que cocederá el premio de poesía \n",
            "anual que otorga nuestra \n",
            "asociación de escritores.\n",
            "\n",
            "Desea imprimir otra carta (s/n): s\n",
            "Indique el tratamiento Sr/Sra: sra.\n",
            "Indique el nombre: maría josé\n",
            "Indique el apellido: gil susilla\n",
            "\n",
            "Sra. María José Gil Susilla. \n",
            "Le comunico que ha sido elegida \n",
            "para formar parte del jurado \n",
            "que cocederá el premio de poesía \n",
            "anual que otorga nuestra \n",
            "asociación de escritores.\n",
            "\n",
            "Desea imprimir otra carta (s/n): n\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DIKYqxUDFukV"
      },
      "source": [
        "### Formateando texto\n",
        "Disponemos de una matriz (lista de listas) con los datos de un presupuesto:\n",
        "* producto\n",
        "* unidades\n",
        "* precio unitario\n",
        "\n",
        "Queremos imprimirlo con formato."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HW1QNMk3HfiF"
      },
      "source": [
        "#### Versión 1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lTnEznO-F3uO",
        "outputId": "46de3add-0ef8-436d-9fa4-670cc4d32a17"
      },
      "source": [
        "print()\n",
        "print(\"PRESUPUESTO\")\n",
        "print()\n",
        "\n",
        "compras = [[\"Tornillos\",800,11.05],\n",
        "           [\"Tuercas\",900,5,1],\n",
        "           [\"Arandelas\",1200,.98],\n",
        "           [\"Puntas\",10500,2]]\n",
        "\n",
        "for c in compras:\n",
        "  print(f\"{c[0]}: {c[1]} * {c[2]} = {c[1]*c[2]}\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "PRESUPUESTO\n",
            "\n",
            "Tornillos: 800 * 11.05 = 8840.0\n",
            "Tuercas: 900 * 5 = 4500\n",
            "Arandelas: 1200 * 0.98 = 1176.0\n",
            "Puntas: 10500 * 2 = 21000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2p_RFtsbHkxH"
      },
      "source": [
        "#### Versión 2\n",
        "Usando separadores y formateando las cantidades."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pvr3kysQHuqG",
        "outputId": "988f5654-c5ed-46d7-b119-3769d2f6f247"
      },
      "source": [
        "print()\n",
        "print(\"PRESUPUESTO\".center(51))            # centra 20+11+20  (20 espacios en blanco por cada lado y 11 de la palabra 'presupuesto')\n",
        "print()\n",
        "\n",
        "compras = [[\"Tornillos\",800,11.05],\n",
        "           [\"Tuercas\",900,5,1],\n",
        "           [\"Arandelas\",1200,.98],\n",
        "           [\"Puntas\",10500,2]]\n",
        "\n",
        "for c in compras:\n",
        "  print(f\"{c[0]:12}: {c[1]:8d} * {c[2]:8.2f} = {c[1]*c[2]:12.2f}\")\n",
        "  # :12 usa 12 caracteres de espacio para poner el producto\n",
        "  # :8d usa 8 caracteres y lo formate como número entero\n",
        "  # :8.2f usa 8 caracteres y lo formatea como número de coma flotante a 2 decimales\n",
        "  # :12.2f usa 12 caracteres y lo formatea como número de coma flotante a 2 decimales "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "                   PRESUPUESTO                    \n",
            "\n",
            "Tornillos   :      800 *    11.05 =      8840.00\n",
            "Tuercas     :      900 *     5.00 =      4500.00\n",
            "Arandelas   :     1200 *     0.98 =      1176.00\n",
            "Puntas      :    10500 *     2.00 =     21000.00\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZUjBWanDITb4",
        "outputId": "3526d372-54c8-403f-f5b1-96b710289f3a"
      },
      "source": [
        "len(\"PRESUPUESTO\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "11"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B6OMMdlhJiHO"
      },
      "source": [
        "# Las listas son un tipo de dato mutable\n",
        "## Método ```append```\n",
        "* Podemos añadir un elemento al final de una lista con ```append```\n",
        "  - El método append admite un argumento, solo uno\n",
        "* También podemos concatenar un nuevo elemento a una lista"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yrU6shIl0Uaw",
        "outputId": "4e9a8681-1520-410f-931e-35ea7c20e461"
      },
      "source": [
        "lista = [1,2,3]\n",
        "lista.append(4)        # append añade la final un elemento.\n",
        "lista"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7ssJnhba0kAE",
        "outputId": "3c936717-b321-4c1d-df9a-9232933e6d36"
      },
      "source": [
        "lista = lista + [5]    # concatenando\n",
        "lista"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5]"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qwMZMi-N0t8T",
        "outputId": "15b64d22-1974-4f49-b94d-b8b162270dd4"
      },
      "source": [
        "lista += [6,7]         # concatenamos listas\n",
        "lista"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5, 6, 7]"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HynYgio01Hgp"
      },
      "source": [
        "### Crear una lista con los números del 1 al 10\n",
        "Partiendo de una lista vacía y añadiendo elemento a elemento."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1tAlitfJ1Ysx"
      },
      "source": [
        "#### Método 1. Con ```append```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pmpURfkt1hhd",
        "outputId": "b1e9037e-e64f-4e57-9890-7ee907ec62f7"
      },
      "source": [
        "l = []\n",
        "for i in range(10):\n",
        "  l.append(i+1)\n",
        "  print(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1]\n",
            "[1, 2]\n",
            "[1, 2, 3]\n",
            "[1, 2, 3, 4]\n",
            "[1, 2, 3, 4, 5]\n",
            "[1, 2, 3, 4, 5, 6]\n",
            "[1, 2, 3, 4, 5, 6, 7]\n",
            "[1, 2, 3, 4, 5, 6, 7, 8]\n",
            "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
            "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kKpvR71M14pA"
      },
      "source": [
        "#### Método 2. Concatenando"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8veMz17j19W7",
        "outputId": "7710cd99-5d3f-4b4f-f620-4c5a97bf62d0"
      },
      "source": [
        "l = []\n",
        "for i in range(10):\n",
        "  l += [i+1]\n",
        "  print(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1]\n",
            "[1, 2]\n",
            "[1, 2, 3]\n",
            "[1, 2, 3, 4]\n",
            "[1, 2, 3, 4, 5]\n",
            "[1, 2, 3, 4, 5, 6]\n",
            "[1, 2, 3, 4, 5, 6, 7]\n",
            "[1, 2, 3, 4, 5, 6, 7, 8]\n",
            "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
            "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1ViGQ6ok3BTN"
      },
      "source": [
        "## Separar pares e impares\n",
        "* Generar una lista de 30 números aleatorios enteros, sin repetición, entre 10 y 99\n",
        "* Separar la lista anterior en dos listas, una de números pares y otra de impares\n",
        "* Mostrar en pantalla las tres listas ordenadas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7ONCXLhl57Ct"
      },
      "source": [
        "#### Método 1\n",
        "Usando randint, sort, +="
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B2etHE3D3ghH",
        "outputId": "bc86e498-855d-43f7-f623-b5fffd9640d0"
      },
      "source": [
        "from random import randint, seed\n",
        "seed()\n",
        "lista = []\n",
        "contador = 0\n",
        "while contador<30:\n",
        "  n = randint(10,99)\n",
        "  if n not in lista:\n",
        "    lista.append(n)\n",
        "    contador += 1\n",
        "lista.sort()\n",
        "print(lista)\n",
        "par = []\n",
        "impar =[]\n",
        "for i in range(30):\n",
        "  if lista[i]%2==0:       # si es igual a cero nos da los pares \n",
        "    par += [lista[i]]\n",
        "  else:\n",
        "    impar += [lista[i]]\n",
        "print(par)\n",
        "print(impar)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[14, 16, 18, 19, 20, 21, 23, 27, 29, 31, 32, 39, 41, 47, 51, 55, 56, 58, 62, 67, 68, 70, 74, 77, 79, 80, 87, 88, 97, 98]\n",
            "[14, 16, 18, 20, 32, 56, 58, 62, 68, 70, 74, 80, 88, 98]\n",
            "[19, 21, 23, 27, 29, 31, 39, 41, 47, 51, 55, 67, 77, 79, 87, 97]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EYnJQUeR6CFh"
      },
      "source": [
        "#### Método 2\n",
        "Usando sample, sorted, append"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XJUo8E3N6Fot",
        "outputId": "e0b89c2a-4e19-489c-f28e-807a8b4328f0"
      },
      "source": [
        "from random import sample, seed\n",
        "seed()\n",
        "l = sample(range(10,100),30)\n",
        "print(sorted(l))\n",
        "par, impar = [], []\n",
        "for n in l:\n",
        "  if n%2:             # no igualamos a nada, si el módulo es cero equivale a False, si el módulo es 1 equivale a True\n",
        "    impar.append(n)\n",
        "  else:\n",
        "    par.append(n)\n",
        "print(sorted(par))\n",
        "print(sorted(impar))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[13, 16, 17, 18, 20, 26, 28, 30, 32, 33, 36, 37, 38, 40, 41, 47, 59, 61, 62, 63, 64, 68, 71, 77, 82, 87, 88, 93, 95, 99]\n",
            "[16, 18, 20, 26, 28, 30, 32, 36, 38, 40, 62, 64, 68, 82, 88]\n",
            "[13, 17, 33, 37, 41, 47, 59, 61, 63, 71, 77, 87, 93, 95, 99]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2MBnwawrV_CU"
      },
      "source": [
        "### Reto 10.1. Separar positivos y negativos\n",
        "* Generar 30 números aleatorios enteros entre -100 y +100\n",
        "* Separarlos en dos listas\n",
        "* Si sale el cero, se avisa por pantalla,se invalidan las listas y se comienza de nuevo"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FkRLHiE7KCt5"
      },
      "source": [
        "## ```None```\n",
        "* Podemos tener una variable sin ningún valor.\n",
        "* ```None``` representa la asuncia de valor en una variable\n",
        "* Esto se puede conseguir si asociamos un método que no devuelve nada a una variable\n",
        "* Esa variable será None"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AKIkrd85LpOy"
      },
      "source": [
        "#### Ejemplo con ```append```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r93i-qzAKY1H",
        "outputId": "7051d74c-2d34-41c5-d20b-45ae8ff9a81f"
      },
      "source": [
        "lista = [1,2,3]\n",
        "ampliada = lista.append(4)     # esto no deberíamos hacerlo ya que append no devuelve nada y no hace nada si se asigna a una variable\n",
        "lista                          # la variable lista si tiene un elemento añadido al final"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UXKd7_0bLDzw"
      },
      "source": [
        "ampliada                       # no devuelve nada"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Dx7AmzWlK52K",
        "outputId": "6453b45b-a309-4c93-d4fa-ca8c13a19038"
      },
      "source": [
        "print(ampliada)                # si imprimimos la variable vemos que es de tipo None"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lduPU-gHLNn-",
        "outputId": "592f5aa6-ebde-43cb-fb31-9e433dbd8f95"
      },
      "source": [
        "type(ampliada)                 # el tipo de la variable es None"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "NoneType"
            ]
          },
          "metadata": {},
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CbE1FTPfLw6e"
      },
      "source": [
        "#### Ejemplo con ```sort```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pRYayzRILU2A",
        "outputId": "946e3efd-35ff-4bb8-f149-7e56c2b43bf7"
      },
      "source": [
        "lista = [4,2,1,3]\n",
        "lista_ordenada = lista.sort() # esto no deberíamos hacerlo ya que sort no devuelve nada y no hace nada si se asigna a una variable\n",
        "lista                         # la lista queda ordenada"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UoECzlHGLi4S"
      },
      "source": [
        "lista_ordenada                # no devuelve nada"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U8TcJ-3jL0sn",
        "outputId": "c7aabdea-e3dd-431e-a0c7-5a6efe883995"
      },
      "source": [
        "type(lista_ordenada)          # la variable es de tipo None"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "NoneType"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "afe9GYI-Hmew"
      },
      "source": [
        "## Añadir productos a la lista de la compra\n",
        "* Crear una lista de la compra e ir añadiendo productos a la lista de la compra\n",
        "* Se finaliza cuando se pulsa ENTER sin añadir nada"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P4lNg9KiH8nO",
        "outputId": "6f11b005-2238-4d34-9866-1f9a4dd1a77b"
      },
      "source": [
        "print(\"LISTA DE LA COMPRA\")\n",
        "lista = []\n",
        "while True:\n",
        "  producto = input(\"Añada un producto a la lista de la compra: \")\n",
        "  if producto==\"\":\n",
        "    print(\"Lista terminada.\")\n",
        "    break\n",
        "  lista.append(producto)\n",
        "\n",
        "print(\"Lista de la compra:\")\n",
        "print(lista)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LISTA DE LA COMPRA\n",
            "Añada un producto a la lista de la compra: pan\n",
            "Añada un producto a la lista de la compra: leche\n",
            "Añada un producto a la lista de la compra: fruta\n",
            "Añada un producto a la lista de la compra: pasta\n",
            "Añada un producto a la lista de la compra: \n",
            "Lista terminada.\n",
            "Lista de la compra:\n",
            "['pan', 'leche', 'fruta', 'pasta']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RkBUw7TfN6-_"
      },
      "source": [
        "## Extender una lista con ```extend```\n",
        "* El método ```append``` añade de uno en uno los elementos a una lista.\n",
        "* Con ```extend``` podemos añadir varios elementos\n",
        "* Equivale a concatenar dos listas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HbFaERO3OTTO",
        "outputId": "0ebe99c4-3c51-4833-ac3d-615d67c63c4c"
      },
      "source": [
        "numeros = [1,2,3]\n",
        "otros = [4,5]\n",
        "numeros.append(otros)        # append requiere solo un argumento, si añadimos la lista 'otros' lo añade como un solo elemento de tipo lista\n",
        "numeros                      # [1, 2, 3, [4, 5]]  vemos que el resultado no es lo que queríamos"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, [4, 5]]"
            ]
          },
          "metadata": {},
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "98axpMODOusE",
        "outputId": "97043417-38bd-4e25-9fda-dac079af65aa"
      },
      "source": [
        "numeros = [1,2,3]\n",
        "otros = [4,5]\n",
        "numeros += otros             # concatenando listas\n",
        "numeros"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5]"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CPqeqtIrO7tW",
        "outputId": "0b13955a-cb31-42d1-8b1a-28d4cf84b559"
      },
      "source": [
        "numeros = [1,2,3]\n",
        "otros = [4,5]\n",
        "numeros.extend(otros)        # con 'extend' conseguimos el mismo objetivo, extender la lista\n",
        "numeros"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5]"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3AmIw5XuQGUn"
      },
      "source": [
        "### Uso de ```extend``` con un strign"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nt6uEnnQPZSX",
        "outputId": "1f5c1bbb-38e8-4a70-a4ef-4f4034c5aa70"
      },
      "source": [
        "letras = ['H','o','l','a']\n",
        "letras.extend(\"Edu\")         # extend actúa sobre una palabra que es un iterable\n",
        "letras"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['H', 'o', 'l', 'a', 'E', 'd', 'u']"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uMYOJuYeQ-O_"
      },
      "source": [
        "### Dadas dos listas construir otra lista\n",
        "* Caso 1\n",
        " - Nos dan la lista a = [1,2,3]\n",
        " - Nos dan la lista b = [4,5]\n",
        " - La lista que se tiene que construir es [1,2,3,4,5]\n",
        "* Caso 2\n",
        " - Nos dan la lista p = [1,2,3,4]\n",
        " - Nos dan la lista q = [5]\n",
        " - La lista que se tiene que construir es [1,2,3,4,5]\n",
        "\n",
        " ¿Con qué método lo ha resuelto, con ```append``` o con ```extend```?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5cvtoaZxSPiO"
      },
      "source": [
        "#### Solución. Caso 1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9VuNV_7PSEvV",
        "outputId": "9dd0708b-45f3-42f9-9725-d821ef77de2f"
      },
      "source": [
        "a = [1,2,3]\n",
        "b = [4,5]\n",
        "a.extend(b)        # [1, 2, 3, 4, 5] resuelto con extend\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5]"
            ]
          },
          "metadata": {},
          "execution_count": 75
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ykSUopuKStbl",
        "outputId": "335bb05a-ebfb-4d94-bc03-a59c0f288b00"
      },
      "source": [
        "a = [1,2,3]\n",
        "b = [4,5]\n",
        "a.append(b)        # [1, 2, 3, [4, 5]] con append no quedaría bien resuelto\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, [4, 5]]"
            ]
          },
          "metadata": {},
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y2DsFH_jSMnD"
      },
      "source": [
        "#### Solución. Caso 2"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FrtNAT_tSMO-",
        "outputId": "1c717b75-97db-40ed-b959-4a8739a6007c"
      },
      "source": [
        "p = [1,2,3,4]\n",
        "q = [5]\n",
        "p.extend(q)        # [1, 2, 3, 4, 5] resuelto con extend\n",
        "p"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5]"
            ]
          },
          "metadata": {},
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I6CDxRBFTN0K",
        "outputId": "ea2738a3-0dad-45b1-b47d-87d247878e4d"
      },
      "source": [
        "p = [1,2,3,4]\n",
        "q = [5]\n",
        "p.append(q)        # [1, 2, 3, 4, [5]] con append no quedaría bien resuelto, el cinco se incorpora como lista no como número\n",
        "p"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, [5]]"
            ]
          },
          "metadata": {},
          "execution_count": 78
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3UPiswGWTka6"
      },
      "source": [
        "## Método ```insert```\n",
        "* Permite insertar elementos dentro de una lista en el lugar especificado.\n",
        "* el método ```append``` siempre añade al final de la lista"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e8JytQFvT4ME",
        "outputId": "c1d5043b-2f9c-4c71-f385-f29453b0d997"
      },
      "source": [
        "lista = [1,2,4,5]\n",
        "num = 3               # num es un número entero\n",
        "lista.insert(2,num)   # el primer argumento es el index donde queremos colocarlo\n",
        "lista"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5]"
            ]
          },
          "metadata": {},
          "execution_count": 81
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mDbGeQU4UlWP",
        "outputId": "4bd6e52d-872a-40a1-abd6-9cd5521fe0b7"
      },
      "source": [
        "lista = [1,2,4,5]\n",
        "l = [3]                 # l es una lista\n",
        "lista.insert(2, l[0])   # de la lista l obtenemos el primer elemento\n",
        "lista"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5]"
            ]
          },
          "metadata": {},
          "execution_count": 82
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R7zbekwtU7rp"
      },
      "source": [
        "### Crear una lista en base a otras listas y valores\n",
        "* a = 1\n",
        "* b = [2,3]\n",
        "* c = [4]\n",
        "* d = 5\n",
        "* Deseamos crear la lista [1,2,3,4,5]\n",
        "\n",
        "¿Ha usado los métodos ```append```, ```extend```, ```insert```?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O15TGAa0Vn1i",
        "outputId": "c903f29a-77d0-44f6-f9dd-bf24b9804dc7"
      },
      "source": [
        "a = 1\n",
        "b = [2,3]\n",
        "c = [4]\n",
        "d = 5\n",
        "[a]+b+c+[d]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5]"
            ]
          },
          "metadata": {},
          "execution_count": 83
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ijh3O_lqV1lT",
        "outputId": "06dae09f-2280-4c38-9baf-57534ab2cec0"
      },
      "source": [
        "a = 1\n",
        "b = [2,3]  # partimos de la lista b que ya es una lista y nos ahorramos crear otra\n",
        "c = [4]\n",
        "d = 5\n",
        "b.insert(0,a)\n",
        "b.extend(c)\n",
        "b.append(d)\n",
        "b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5]"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x6Sy7GuhTmhy"
      },
      "source": [
        "### Reto 10.2. Solucionar una equivocación\n",
        "En la siguiente lista nos hemos equivocado.\n",
        "* lista = [1,2,3,[4],5,6,]\n",
        "* El número 4 lo hemos añadido como lista cuando lo que deseamos realmente es añadirlo como número.\n",
        "* ¿Podrías solucionarlo?"
      ]
    }
  ]
}