02.- Listas.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "2.- Listas.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyOygP6qtmWYOIvMM4p7HKTY",
      "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/JulioCesarMS/Python_course/blob/main/02.-%20Listas.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Colecciones en Python**\n",
        "\n",
        "Hay cuatro tipos de datos de colección en el lenguaje de programación Python:\n",
        "\n",
        "1.- Lista es una colección que está ordenada y es modificable. Permite duplicar\n",
        "miembros.\n",
        "\n",
        "2.- Tupla es una colección que está ordenada y es inmodificable. Permite miembros duplicados.\n",
        "\n",
        "3.- Conjunto es una colección que no está ordenada ni indexada. No admite miembros duplicados. miembros duplicados.\n",
        "\n",
        "4.- Diccionario es una colección que está ordenada* y es modificable. No hay miembros duplicados."
      ],
      "metadata": {
        "id": "fMUCEJc-sxrR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Listas**"
      ],
      "metadata": {
        "id": "arFozlGlN7QI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Las listas se utilizan para almacenar múltiples elementos en una sola variable.\n",
        "Las listas son uno de los $4$ tipos de datos incorporados en Python que se utilizan para almacenar colecciones de datos, los otros $3$ son Tuplas, Conjuntos y Diccionario, todos con diferentes cualidades y uso.\n",
        "\n",
        "Las listas se crean utilizando corchetes:\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Crear una lista:\n",
        "\n",
        "mylist = [\"manzana\", \"plátano\", \"cereza\"]\n",
        "\n",
        "**Elementos de la lista**\n",
        "\n",
        "Los elementos de la lista están ordenados, son modificables y permiten valores duplicados. Los elementos de la lista están indexados, el primer elemento tiene índice $[0]$, el segundo elemento tiene índice $[1]$, etc.\n",
        "\n",
        "**Ordenado**\n",
        "\n",
        "Cuando decimos que las listas están ordenadas, significa que los elementos tienen un orden definido, y ese orden no cambiará. Si añades nuevos elementos a una lista, los nuevos elementos se colocarán al final de la lista.\n",
        "Nota: Hay algunos métodos de lista que cambiarán el orden, pero en general: el orden de los elementos no cambiará.\n",
        "\n",
        "**Modificable**\n",
        "\n",
        "La lista es modificable, lo que significa que podemos cambiar, añadir y eliminar elementos en una lista después de haberla creado.\n",
        "\n",
        "**Permitir duplicados**\n",
        "\n",
        "Como las listas están indexadas, las listas pueden tener elementos con el mismo valor:\n",
        "\n",
        "Ejemplo:\n",
        "\n",
        "Las listas permiten valores duplicados:\n"
      ],
      "metadata": {
        "id": "wBV0SEg_fYG_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"manzana\", \"plátano\", \"cereza\", \"manzana\", \"cereza\"]\n",
        "print(mylist)"
      ],
      "metadata": {
        "id": "NQyV2sjhf8MZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Longitud de la lista**\n",
        "\n",
        "Para determinar cuántos elementos tiene una lista, utilice la función len():\n",
        "\n",
        "Ejemplo\n"
      ],
      "metadata": {
        "id": "sxoP5gdjhWp1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Imprime el número de elementos de la lista:\n",
        "mylist = [\"manzana\", \"plátano\", \"cereza\"]\n",
        "print(len(mylist))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U_3fK9HHhV17",
        "outputId": "7a0a1856-543d-405e-efa7-1ee2b2a91b30"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Elementos de la lista - Tipos de datos**\n",
        "\n",
        "Los elementos de la lista pueden ser de cualquier tipo de datos:\n",
        "\n",
        "Ejemplo:"
      ],
      "metadata": {
        "id": "UJxbUpRDhs1O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Tipos de datos string, int y boolean:\n",
        "list1 = [\"manzana\", \"plátano\", \"cereza\"]\n",
        "list2 = [1, 5, 7, 9, 3]\n",
        "list3 = [True, False, False]"
      ],
      "metadata": {
        "id": "ZwaF2uVGh4qK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **type()**\n",
        "\n",
        "Desde la perspectiva de Python, las listas se definen como objetos con el tipo de datos 'list':"
      ],
      "metadata": {
        "id": "EMnhnVcFiEuu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "print(type(mylist))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lJC6NgkHh_Kb",
        "outputId": "339e9f5b-5a80-4088-943c-3445fb519eca"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'list'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **El constructor list()**\n",
        "\n",
        "También es posible utilizar el constructor list() al crear una nueva lista."
      ],
      "metadata": {
        "id": "z3-uvaofiTEo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = list((\"apple\", \"banana\", \"cherry\"))\n",
        "mylist"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "akd5aURZifcK",
        "outputId": "94042fa9-a73f-4806-ee01-13ecb11180f8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['apple', 'banana', 'cherry']"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Acceso a elementos de la lista**\n",
        "\n",
        "Los elementos de la lista están indexados y se puede acceder a ellos haciendo referencia al índice número de índice:\n",
        "\n",
        "Ejemplo:"
      ],
      "metadata": {
        "id": "OaL6fuZBz-KR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# imprime el segundo elemento de la lista\n",
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "print(mylist[1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q9PwDoDYilgT",
        "outputId": "846396a4-19b2-4d6b-bd85-e1d164a7a343"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "banana\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Nota**: El primer elemento tiene índice 0."
      ],
      "metadata": {
        "id": "NhRROOdX0Q4B"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Indexación negativa**\n",
        "\n",
        "La indexación negativa significa empezar por el final.\n",
        "\n",
        "-1 se refiere al último elemento, -2 se refiere al penúltimo elemento, etc.\n",
        "\n",
        "Ejemplo:\n",
        "\n",
        "Imprimir el último elemento de la lista:"
      ],
      "metadata": {
        "id": "eOyymbjW0aZS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "print(mylist[-1])"
      ],
      "metadata": {
        "id": "5oHOj0xM0w3g",
        "outputId": "ef4eeea8-2f07-41d9-82d4-dc9b332dfdc9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Rango de índices**\n",
        "\n",
        "Puede especificar un rango de índices especificando dónde empezar y dónde el rango.\n",
        "\n",
        "Cuando se especifica un rango, el valor de retorno será una nueva lista con los especificados.\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Devuelve el tercer, cuarto y quinto elemento:"
      ],
      "metadata": {
        "id": "6-Hf0Jsi1Hes"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"melon\", \"mango\"]\n",
        "print(mylist[2:5])"
      ],
      "metadata": {
        "id": "81DNWqKj0Njv",
        "outputId": "52d0e147-3904-400f-9d46-ab5697c0edb6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['cherry', 'orange', 'kiwi']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Nota**: La búsqueda comenzará en el índice 2 (incluido) y terminará en el índice 5 (no incluido).\n",
        "\n",
        "Recuerde que el primer elemento tiene el índice 0.\n",
        "\n",
        "Al omitir el valor de inicio, el rango comenzará en el primer elemento:\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Este ejemplo devuelve los elementos desde el principio hasta \"kiwi\", pero sin incluirlo:"
      ],
      "metadata": {
        "id": "p9eSP-dy5Vmx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"melon\",\n",
        "\"mango\"]\n",
        "print(mylist[:4])"
      ],
      "metadata": {
        "id": "4Hc5VTsL1RQ_",
        "outputId": "b199d0b5-0f45-4330-c5ae-c197941f7de6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry', 'orange']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Al omitir el valor final, el rango llegará hasta el final de la lista:\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Este ejemplo devuelve los elementos desde \"cherry\" hasta el final:"
      ],
      "metadata": {
        "id": "TPQ0qMXs51S5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"melon\",\n",
        "\"mango\"]\n",
        "print(mylist[2:])"
      ],
      "metadata": {
        "id": "S5U9z5yu5vg6",
        "outputId": "8119dd4e-c90f-4596-cb23-a5d3ce6d1c81",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['cherry', 'orange', 'kiwi', 'melon', 'mango']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Rango de índices negativos**\n",
        "\n",
        "Especifique los índices negativos si desea iniciar la búsqueda desde el final de la lista:\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Este ejemplo devuelve los elementos desde \"naranja\" (-4) hasta, pero sin incluir \"mango\" (-1):"
      ],
      "metadata": {
        "id": "a7QDzD716BuW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"melon\", \"mango\"]\n",
        "print(mylist[-4:-1])"
      ],
      "metadata": {
        "id": "j9t2en_Y59iD",
        "outputId": "6ae6937b-a97e-4d00-b6b8-215a633ea5f7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['orange', 'kiwi', 'melon']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Comprobar si un elemento existe**\n",
        "\n",
        "Para determinar si un elemento especificado está presente en una lista, utilice la palabra clave in:\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Comprobar si \"manzana\" está presente en la lista:"
      ],
      "metadata": {
        "id": "YBxaQr7W62Vj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "\n",
        "if \"apple\" in mylist:\n",
        "  print(\"Yes, 'apple' is in the fruits list\")"
      ],
      "metadata": {
        "id": "LLFzuTWr6_Ei",
        "outputId": "d83b2ec9-2703-44fa-d96b-9ff1a6f0f33c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Yes, 'apple' is in the fruits list\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Cambiar elementos de la lista**\n",
        "\n",
        "\n",
        "Para cambiar el valor de un elemento específico, consulte el número de índice:\n",
        "\n",
        "**Ejemplo**\n",
        "\n",
        "Cambie el segundo elemento:"
      ],
      "metadata": {
        "id": "CmVaJQLv-Oc9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist[1] = \"strawberry\"\n",
        "print(mylist)"
      ],
      "metadata": {
        "id": "SgAJqaHI7Nzb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "52b26115-d851-4388-df7d-fe221b6a0a95"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'strawberry', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Cambiar un rango de valores de elementos**\n",
        "\n",
        "Para cambiar el valor de los elementos dentro de un rango específico, defina una lista con los nuevos valores, y refiérase al rango de números de índice donde quiere insertar los nuevos valores:\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Cambie los valores \"plátano\" y \"cereza\" por los valores \"grosella negra\" y \"sandía\":"
      ],
      "metadata": {
        "id": "H3PZDj8E-0Iy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"mango\"]\n",
        "mylist[1:3] = [\"blackcurrant\", \"watermelon\"]\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rHs9KX5d-uAm",
        "outputId": "77e6c610-4c69-4385-de54-b022afe07d85"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'blackcurrant', 'watermelon', 'orange', 'kiwi', 'mango']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Observación:**\n",
        "\n",
        "Si inserta más elementos de los que reemplaza, los nuevos elementos se insertarán en el lugar especificado, y los elementos restantes se desplazarán en consecuencia:\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Cambiar el segundo valor sustituyéndolo por dos nuevos valores:"
      ],
      "metadata": {
        "id": "SU4KR-di_Tbo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist[1:2] = [\"blackcurrant\", \"watermelon\"]\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5VeUdqpB_MU-",
        "outputId": "f0b5f37e-5127-4194-eb89-2c08920eb6cb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'blackcurrant', 'watermelon', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Observación:**\n",
        "Si inserta menos elementos de los que reemplaza, los nuevos elementos se insertarán donde que haya especificado, y los elementos restantes se desplazarán en consecuencia:\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Cambiar el segundo y tercer valor sustituyéndolo por un valor:"
      ],
      "metadata": {
        "id": "GrXqIW9p_yo0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist[1:3] = [\"watermelon\"]\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i12h4rHI_6j4",
        "outputId": "df11e56e-ecc1-447d-ed8f-9caa8231d1bc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'watermelon']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Insertar elementos: método .insert()**\n",
        "\n",
        "Para insertar un nuevo elemento de la lista, sin reemplazar ninguno de los valores existentes, podemos utilizar el método insert(). El método insert() inserta un elemento en el índice especificado:\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Insertar \"watermelon\" como tercer elemento:"
      ],
      "metadata": {
        "id": "lftJ3KqJARjZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist.insert(2, \"watermelon\")\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "__GDpJ5wBVB2",
        "outputId": "b72edbbe-e068-41af-a125-18cb45ff025e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'watermelon', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Añadir elementos al final de la lista: método .append()**\n",
        "\n",
        "Para añadir un elemento al final de la lista, utilice el método append():\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Utilizar el método append() para añadir un elemento:"
      ],
      "metadata": {
        "id": "svUUjfz3BwC5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist.append(\"orange\")"
      ],
      "metadata": {
        "id": "JF7xtQ9ABirN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Insertar elementos en una posición específica: método .insert()**\n",
        "\n",
        "Para insertar un elemento de la lista en un índice especificado, utilice el método insert(). El método insert() inserta un elemento en el índice especificado:\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Insertar un elemento en la segunda posición:"
      ],
      "metadata": {
        "id": "1pX-klGvCQXT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist.insert(1, \"orange\")\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YxiognMOBd6X",
        "outputId": "fe44053a-08ad-46cf-e154-63779a81a2c8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'orange', 'banana', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Extender la lista: método .extend()**\n",
        "\n",
        "Para añadir elementos de otra lista a la lista actual utilice el método extend().\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Añade los elementos de tropical a esta lista:"
      ],
      "metadata": {
        "id": "QP8lfu0nCsNV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist1 = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist2 = [\"mango\", \"pineapple\", \"papaya\"]\n",
        "mylist1.extend(mylist2)\n",
        "print(mylist1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ml01c41sC7Zx",
        "outputId": "be17f27a-6864-48b9-850c-bd29d99ec552"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry', 'mango', 'pineapple', 'papaya']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Añadir cualquier iterable**\n",
        "\n",
        "El método extend() no sólo añade listas, puede también añadir cualquier objeto iterable (tuplas, conjuntos, diccionarios, etc.).\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Añadir elementos de una tupla a una lista:"
      ],
      "metadata": {
        "id": "CyGm_KaRDVcA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mytuple = (\"kiwi\", \"orange\")\n",
        "mylist.extend(mytuple)\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PqUGyNsbDmok",
        "outputId": "d1a57161-664e-4995-f9c1-1e02bda2ee2c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry', 'kiwi', 'orange']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Eliminar elementos de la lista**\n",
        "\n",
        "Para eliminar un elemento específico de una lista usamos el método  remove().\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Eliminar \"banana\":"
      ],
      "metadata": {
        "id": "End0RW3tIe6V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist.remove(\"banana\")\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TAIJkD8GIzZX",
        "outputId": "f69b05bb-f8d8-4a1b-f79c-14095c418178"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Eliminar un índice específico**\n",
        "\n",
        "El método pop() elimina el índice especificado.\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Elimina el segundo elemento:"
      ],
      "metadata": {
        "id": "ssEPsf_XJQqI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist.pop(1)\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bZay8deyJcBs",
        "outputId": "33e0b5a0-80a7-4696-a8b4-9cab428cf888"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Si no se especifica el índice, el método pop() elimina el último elemento.\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Elimina el último elemento:"
      ],
      "metadata": {
        "id": "2tjpEannJwWd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist.pop()\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T3fqpveCJh6v",
        "outputId": "5e9fd0c1-e2a1-4dbb-aee4-c302d80c5077"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Método del**\n",
        "\n",
        "La palabra clave **del** también elimina el índice especificado:\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Eliminar el primer elemento:"
      ],
      "metadata": {
        "id": "AmlfwLYIKEoc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "del mylist[0]\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_k_ETE0vJ4FY",
        "outputId": "6dee6cf4-a8f8-459a-dc26-7d91f775d8de"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['banana', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "La palabra clave **del** también puede eliminar la lista por completo.\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Borrar toda la lista:"
      ],
      "metadata": {
        "id": "QYbyWgD4KaoF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "del mylist\n"
      ],
      "metadata": {
        "id": "w_iaKp71KloI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Vaciar la lista**\n",
        "\n",
        "Adiferencia del método anterior que elimina por completo la lista, el objeto como tal deja de existir, sin embargo, el método **clear()** vacía la lista. La lista aún permanece, pero no tiene contenido.\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Limpiar el contenido de la siguiente lista."
      ],
      "metadata": {
        "id": "lRRtRvAkK8MW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist.clear()\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "goARz_bQLExL",
        "outputId": "e756b999-6790-47b1-e5f9-59c690802365"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##**Recorrer una lista en ciclo**\n"
      ],
      "metadata": {
        "id": "9_m-XKmbLpAc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Puede recorrer los elementos de la lista mediante un ciclo for:\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Imprimir todos los elementos de la lista, uno por uno:"
      ],
      "metadata": {
        "id": "bfiujJUCplQ-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "for element in mylist:\n",
        "  print(element)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-klqS8oOLsyI",
        "outputId": "6cb05435-09bc-4495-84a9-851ac28f43ce"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Recorrer los números de índice**\n",
        "\n",
        "También puede recorrer los elementos de la lista consultando su número de índice. Utilice las funciones **range()** y **len()** para crear un iterable adecuado.\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Imprime todos los elementos haciendo referencia a su número de índice:"
      ],
      "metadata": {
        "id": "Nj82ZzzVqHMY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "for i in range(len(mylist)):\n",
        "  print(mylist[i])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4Ca0o-gdp6i2",
        "outputId": "bd8dbfe1-86c2-438c-faaf-a36551e09e02"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Uso del ciclo while**\n",
        "\n",
        "Puede recorrer los elementos de la lista utilizando un bucle while.\n",
        "Utilice la función len() para determinar la longitud de la lista, luego comience en 0 y recorra los elementos de la lista consultando sus índices.\n",
        "\n",
        "Recuerde aumentar el índice en 1 después de cada iteración.\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Imprimir todos los elementos, utilizando un bucle while para recorrer todos los números de índice"
      ],
      "metadata": {
        "id": "pMf_yTNLqpsS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "i = 0\n",
        "while i < len(mylist):\n",
        "  print(mylist[i])\n",
        "  i = i + 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l10bQiMYq2J7",
        "outputId": "a81aa531-d27a-444d-fd70-b552096c3329"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Bucle utilizando la comprensión de la lista**\n",
        "\n",
        "List Comprehension ofrece la sintaxis más corta para hacer bucles en las listas:\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "Un bucle for abreviado que imprimirá todos los elementos de una lista:"
      ],
      "metadata": {
        "id": "Co-ZrApPrKAI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "\n",
        "[print(x) for x in mylist]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O7UfuMw_rCu7",
        "outputId": "a598625a-3f5b-41e1-b7fb-421ffd59b8a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[None, None, None]"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **List Comprehension**"
      ],
      "metadata": {
        "id": "a5zVOfZcrqZ9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "La list comprehension ofrece una sintaxis más corta cuando se quiere crear una nueva lista basada en los valores de una lista existente.\n",
        "\n",
        "**Ejemplo:**\n",
        "\n",
        "A partir de una lista de frutas, se quiere crear una nueva lista que contenga sólo las frutas con la letra \"a\" en el nombre. Sin la comprensión de la lista tendrá que escribir una sentencia for con un prueba condicional en su interior:"
      ],
      "metadata": {
        "id": "WabOkCVDrpmt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Ejemplo utilizando el ciclo for\n",
        "fruits = [\"apple\", \"banana\", \"cherry\", \"kiwi\", \"mango\"]\n",
        "newlist = []\n",
        "for fruit in fruits:\n",
        "  if fruit[0] == 'a':\n",
        "    newlist.append(fruit)\n",
        "\n",
        "print(newlist)  "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pw7ikD40siI3",
        "outputId": "4f676464-62e2-4158-d531-48306e4c8c29"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Con la comprensión de listas puedes hacer todo eso con una sola línea de código:"
      ],
      "metadata": {
        "id": "T0HIvDZ7tg5i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Ejemplo mediante list comprehension\n",
        "newlist = [fruit for fruit in fruits if fruit[0]=='a']\n",
        "print(newlist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pQr5_FYCtCD3",
        "outputId": "cd206f49-7f74-4455-ec52-0cfa1c26828b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Veámos otro ejemplo, supongamos que deseamos obtener la suma total de cada elementom de \"mylist\"."
      ],
      "metadata": {
        "id": "3Tf3lfs8t-Dl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# ejemplo 2\n",
        "mylist2 = [[90, 92, 65, 71],\n",
        "           [25, 20, 15, 90],\n",
        "           [65, 130, 60, 75]]\n"
      ],
      "metadata": {
        "id": "3eXWDsDbtLYx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# empleando ciclo FOR\n",
        "total = []\n",
        "for row in mylist2:\n",
        "  total.append(sum(row))\n",
        "\n",
        "print(total)"
      ],
      "metadata": {
        "id": "K4GrJvfJtocW",
        "outputId": "05eb6772-f3b4-4fce-fba9-bae5419710fe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[318, 150, 330]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# empleando list comprehension\n",
        "total_comp = [sum(row) for row in mylist2]\n",
        "print(total_comp)"
      ],
      "metadata": {
        "id": "xmTpaHIBuVxm",
        "outputId": "dcf67010-57d8-4d15-b4b9-0f6f49bf502a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[318, 150, 330]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# empleando la función map\n",
        "total_map = [*map(sum, mylist2)]\n",
        "print(total_map)"
      ],
      "metadata": {
        "id": "1Qa8OxZsuufe",
        "outputId": "8f0ad1bb-c6f1-4452-dbf1-b82883dfc4d3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[318, 150, 330]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ejemplo:\n",
        "\n",
        "La siguiente expresión retorna una lista con números inferiores a 5:\n"
      ],
      "metadata": {
        "id": "6XX8yETu-WV9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "newlist = [x for x in range(10) if x < 5]\n",
        "newlist"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hs0myhg89N6B",
        "outputId": "f4758b00-2960-4c7e-c50c-316d193bfad8"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 2, 3, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Ordenar una lista**\n",
        "\n",
        "\n",
        "Los objetos lista tienen un método $sort()$ que ordenará la lista alfanuméricamente de forma ascendente por defecto:"
      ],
      "metadata": {
        "id": "GNnZdkfw_FSn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"orange\", \"mango\", \"kiwi\", \"pineapple\", \"banana\"]\n",
        "mylist.sort()\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8LMnGR5I_JGm",
        "outputId": "77de684e-ea06-47cc-877b-22871a88e636"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['banana', 'kiwi', 'mango', 'orange', 'pineapple']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para el caso numérico"
      ],
      "metadata": {
        "id": "Y15c0fnY_muM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list = [100, 50, 65, 82, 23]\n",
        "my_list.sort()\n",
        "print(my_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J5WD7n19_jdI",
        "outputId": "9e006bce-7159-402c-8e4e-283932a49d6f"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[23, 50, 65, 82, 100]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Ordenación descendente**\n",
        "\n",
        "Para ordenar de forma descendente hay que utilizar  la palabra clave $reverse = True$"
      ],
      "metadata": {
        "id": "M7-_oWsJFE6e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"orange\", \"mango\", \"kiwi\", \"pineapple\", \"banana\"]\n",
        "mylist.sort(reverse=True)\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xDgI2Xu-FTkL",
        "outputId": "ae472dfb-119c-4590-f0e1-0df97ea7944a"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['pineapple', 'orange', 'mango', 'kiwi', 'banana']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para el caso numérico"
      ],
      "metadata": {
        "id": "L7ZYv91vFdEp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list = [100, 50, 65, 82, 23]\n",
        "my_list.sort(reverse=True)\n",
        "print(my_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SO-vH8RqFfIP",
        "outputId": "9d9c403d-4d38-4c61-9be3-e282e3722909"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[100, 82, 65, 50, 23]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Personalizar la función de ordenación**\n",
        "\n",
        "También puede personalizar su propia función utilizando el argumento de la palabra clave $key = función$.\n",
        "\n",
        "La función devolverá un número que se utilizará para ordenar la lista (el número más bajo primero):"
      ],
      "metadata": {
        "id": "WeOhXc6KF7zu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ejemplo:\n",
        "\n",
        "Ordena la lista en función de lo cerca que esté el número del 50."
      ],
      "metadata": {
        "id": "Dc9FIG5mGSAr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# función\n",
        "def myfunc(n):\n",
        "  return abs(n - 50)"
      ],
      "metadata": {
        "id": "JZLLjzZOGrY5"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [100, 50, 65, 82, 23]\n",
        "mylist.sort(key = myfunc)\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0VRb1_zqGwob",
        "outputId": "6d52abeb-f7ab-4295-b902-76afa4098aec"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[50, 65, 23, 82, 100]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Ordenación sin distinción de mayúsculas y minúsculas**\n",
        "\n",
        "Por defecto, el método *sort()* distingue entre mayúsculas y minúsculas, por lo que todas las letras mayúsculas se ordenan antes que las minúsculas:"
      ],
      "metadata": {
        "id": "j56YpWeTIyYW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ejemplo:\n",
        "\n",
        "La ordenación con mayúsculas y minúsculas puede dar un resultado inesperado:"
      ],
      "metadata": {
        "id": "rMpBiyegJDXm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"banana\", \"Orange\", \"Kiwi\", \"cherry\"]\n",
        "mylist.sort()\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ySWvyBT3HKbe",
        "outputId": "11ba7f30-20a2-40c9-c4aa-7e069e20c966"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Kiwi', 'Orange', 'banana', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Por suerte, podemos utilizar funciones personalizadas para ordenar una lista.\n",
        "\n",
        "Para ordenar una lista que no distinga entre mayúsculas y minúsculas, se debe utilizar *str.lower* como funión personalizada.\n",
        "\n",
        "Ejemplo"
      ],
      "metadata": {
        "id": "4fpn1t7IJVkA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"banana\", \"Orange\", \"Kiwi\", \"cherry\"]\n",
        "mylist.sort(key = str.lower)\n",
        "print(mylist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tJN3uqbMJOtj",
        "outputId": "d915d9f3-3ec4-4ee8-99bd-b28d39374e2b"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['banana', 'cherry', 'Kiwi', 'Orange']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Copia de listas**\n",
        "\n",
        "En python no se puede copiar una lista simplemente escribiendo *list2* = *list1*, porque: *list2* sólo será será una referencia a la *lista1*, y los cambios hechos en la *lista1* se harán automáticamente también en la *lista2*.\n",
        "\n",
        "Hay formas de hacer una copia, una de ellas es utilizar el método  $list.copy()$."
      ],
      "metadata": {
        "id": "v-9YeR3RKAmV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ejemplo:\n",
        "\n",
        "Hacer una copia de una lista con el método .$.copy()$"
      ],
      "metadata": {
        "id": "JI2CzOQSKsG3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist2 = mylist.copy()\n",
        "print(mylist2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Gkt06ZXRKqVO",
        "outputId": "a6573fb7-13d0-412b-89b9-5c1d5878c0d8"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "mylist2.append('orange')\n",
        "print(mylist)\n",
        "print(mylist2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0ckaI_dKLAWW",
        "outputId": "ed9daf4a-9b43-4a1f-a7ff-625d6d07a276"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry']\n",
            "['apple', 'banana', 'cherry', 'orange']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Podemos apreciar que los cambios en $mylist2$ no se vieron reflejados en $mylist1$.\n",
        "\n",
        "Otra forma de hacer una copia es utilizar el método incorporado list()."
      ],
      "metadata": {
        "id": "wnA-8kctKoPo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ejemplo:"
      ],
      "metadata": {
        "id": "fcW8VO_VLm0X"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = [\"apple\", \"banana\", \"cherry\"]\n",
        "mylist2 = list(mylist)\n",
        "print(mylist2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HT7gmWLPLXEF",
        "outputId": "7141a529-7dd0-42aa-9490-9eb0dfdb1125"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "mylist2.append('orange')\n",
        "print(mylist)\n",
        "print(mylist2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q4CegLkxLxPb",
        "outputId": "6978b158-58bc-464b-b7f5-2c500828609d"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry']\n",
            "['apple', 'banana', 'cherry', 'orange']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Unir dos listas**\n",
        "\n",
        "Hay varias formas de unir, o concatenar, dos o más listas en Python. Una de las formas más sencillas es utilizando el operador $+$."
      ],
      "metadata": {
        "id": "DaZdE-OoSir1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Example:"
      ],
      "metadata": {
        "id": "bGOmv697SrbL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list1 = [\"a\", \"b\", \"c\"]\n",
        "list2 = [1, 2, 3]\n",
        "list3 = list1 + list2\n",
        "print(list3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qkNSdEyPSsvY",
        "outputId": "45e72247-f7ad-498a-804f-c00be4895030"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['a', 'b', 'c', 1, 2, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Otra forma de unir dos listas es añadiendo todos los elementos de la *lista2* en *lista1*, uno por uno.\n",
        "\n",
        "Ejemplo:"
      ],
      "metadata": {
        "id": "VJKXj0UuS2-k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list1 = [\"a\", \"b\" , \"c\"]\n",
        "list2 = [1, 2, 3]\n",
        "for x in list2:\n",
        "  list1.append(x)\n",
        "\n",
        "print(list1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IUP8KBRHS6fs",
        "outputId": "e21b895f-ecf0-47cc-c3d1-c1cdf5a9263c"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['a', 'b', 'c', 1, 2, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "O puede utilizarse el método *extend()*, cuyo propósito es añadir elementos de una lista a otra lista.\n",
        "\n",
        "Ejemplo:"
      ],
      "metadata": {
        "id": "FOMpSZSsTLEh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list1 = [\"a\", \"b\" , \"c\"]\n",
        "list2 = [1, 2, 3]\n",
        "list1.extend(list2)\n",
        "print(list1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VhQe4ujzTRvO",
        "outputId": "71cc3299-f56d-4add-8454-a264262e398f"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['a', 'b', 'c', 1, 2, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Métodos de listas**\n",
        "\n",
        "| Método | Descripción |\n",
        "|--|--|\n",
        "| append() |  Añade un elemento al final de la lista |\n",
        "| clear()  | Elimina todos los elementos de la lista |\n",
        "| copy()   | Devuelve una copia de la lista          |\n",
        "| count()  | Devuelve el número de elementos con el valor especificado |\n",
        "| extend() | Añade los elementos de una lista (o cualquier iterable), al final  de la lista actual |\n",
        "| index()  | Devuelve el índice del primer elemento con el valor especificado |\n",
        "| insert() | Añade un elemento en la posición especificada |\n",
        "| pop()    | Elimina el elemento en la posición especificada |\n",
        "| remove() | Elimina el elemento con el valor especificado |\n",
        "| reverse()| Invierte el orden de la lista |\n",
        "| sort()   | Ordena la lista |\n",
        "\n"
      ],
      "metadata": {
        "id": "ZkDU1pzvTZ7Z"
      }
    }
  ]
}