01_Vectores.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "01_Vectores.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyO6lnNx08pNtv9XmgMt5wG7",
      "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/unlu-edu-ar/prog1_notebooks/blob/main/01_Vectores.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g43C9WcptRS5"
      },
      "source": [
        "Para implementar vectores en la materia, vamos a usar el tipo de dato lista de Python. Las listas son estructuras de datos heterogéneas, y como los vectores son homogeneos, debemos recordar poner todos elementos del mismo tipo."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l-7wGX4ltd90"
      },
      "source": [
        "# Creando listas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9IVTb-CJtt4R",
        "outputId": "79c9370c-ad41-4c75-abca-986d471c9a8f"
      },
      "source": [
        "print(\"Dos formas standard de crear listas vacías:\")\n",
        "a = [ ]\n",
        "b = list()\n",
        "\n",
        "print(type(a), len(a), a)\n",
        "print(type(b), len(b), b)\n",
        "print(a == b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dos formas standard de crear listas vacías:\n",
            "<class 'list'> 0 []\n",
            "<class 'list'> 0 []\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hUvznFscoNBj"
      },
      "source": [
        "Listas de sólo 1 elemento"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lekslZMIt34A",
        "outputId": "39a71c7c-6f80-4b64-c2df-5d7ee4f84824"
      },
      "source": [
        "a = [ \"hello\" ]\n",
        "b = [ 42 ]\n",
        "\n",
        "print(type(a), len(a), a)\n",
        "print(type(b), len(b), b)\n",
        "print(a == b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'list'> 1 ['hello']\n",
            "<class 'list'> 1 [42]\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "acY3mJUmQVu7"
      },
      "source": [
        "Listas con varios elementos"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VcKa0lwZv7oI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2015d443-e9bd-4584-cdbe-cc3be85c8773"
      },
      "source": [
        "a = [2, 3, 5, 7]\n",
        "b = list(range(5))\n",
        "c = [\"mezclando tipos de datos\", True, 42]\n",
        "\n",
        "print(type(a), len(a), a)\n",
        "print(type(b), len(b), b)\n",
        "print(type(c), len(c), c)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'list'> 4 [2, 3, 5, 7]\n",
            "<class 'list'> 5 [0, 1, 2, 3, 4]\n",
            "<class 'list'> 3 ['mezclando tipos de datos', True, 42]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WQgLb1kxhQs2"
      },
      "source": [
        "Listas de longitud variable"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fkXi9SuPhbnD",
        "outputId": "539be112-7c53-4305-e68f-1e96fda0faf6"
      },
      "source": [
        "n = 10\n",
        "a = [0] * n # crea una lista con n 0s\n",
        "b = list(range(n))\n",
        "\n",
        "print(type(a), len(a), a)\n",
        "print(type(b), len(b), b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'list'> 10 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
            "<class 'list'> 10 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vlWi0n-Wh6Tx"
      },
      "source": [
        "## Listas: Funciones y Operaciones"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UMPaber0iC4A",
        "outputId": "30227fed-6e86-4cb7-c41d-9659bbfb3b43"
      },
      "source": [
        "a = [ 2, 3, 5, 2 ]\n",
        "print(\"a = \", a)\n",
        "# Obteniendo la longitud de la lista\n",
        "print(\"len =\", len(a))\n",
        "# Si bien las listas también tienen operadores para el máximo, mínimo, y la sumatoria, \n",
        "# no está permitido usar estos operadores si el ejercicio pidiese obtener el máximo, mínimo o la sumatoria.\n",
        "print(\"min =\", min(a))\n",
        "print(\"max =\", max(a))\n",
        "print(\"sum =\", sum(a))\n",
        "\n",
        "# Crea algunas listas\n",
        "a = [ 2, 3, 5, 3, 7 ]\n",
        "b = [ 2, 3, 5, 3, 7 ]   # la misma que a\n",
        "c = [ 2, 3, 5, 3, 8 ]   # difiere en el ultimo elemento\n",
        "d = [ 2, 3, 5 ]         # prefijo de a\n",
        "\n",
        "print(\"a =\", a)\n",
        "print(\"b =\", b)\n",
        "print(\"c =\", c)\n",
        "print(\"d =\", d)\n",
        "\n",
        "print(\"------------------\")\n",
        "print(\"a == b\", (a == b))\n",
        "print(\"a == c\", (a == c))\n",
        "print(\"a != b\", (a != b))\n",
        "print(\"a != c\", (a != c))\n",
        "\n",
        "print(\"------------------\")\n",
        "print(\"a < c\", (a < c))\n",
        "print(\"a < d\", (a < d))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a =  [2, 3, 5, 2]\n",
            "len = 4\n",
            "min = 2\n",
            "max = 5\n",
            "sum = 12\n",
            "a = [2, 3, 5, 3, 7]\n",
            "b = [2, 3, 5, 3, 7]\n",
            "c = [2, 3, 5, 3, 8]\n",
            "d = [2, 3, 5]\n",
            "------------------\n",
            "a == b True\n",
            "a == c False\n",
            "a != b False\n",
            "a != c True\n",
            "------------------\n",
            "a < c True\n",
            "a < d False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tA4j8ejmpaOU"
      },
      "source": [
        "# Accediendo a los Elementos (Indexing y Slicing)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "03T37EZapv0f"
      },
      "source": [
        "a = [2, 3, 5, 7, 11, 13]\n",
        "print(\"a        =\", a)\n",
        "\n",
        "# Accediendo a índices no negativos\n",
        "print(\"a[0]     =\", a[0])\n",
        "print(\"a[2]     =\", a[2])\n",
        "\n",
        "# Accediendo a índices negativos\n",
        "print(\"a[-1]    =\", a[-1])\n",
        "print(\"a[-3]    =\", a[-3])\n",
        "\n",
        "# Accediendo a subsecuencias a[inicio:fin:paso]\n",
        "print(\"a[0:2]   =\", a[0:2])\n",
        "print(\"a[1:4]   =\", a[1:4])\n",
        "print(\"a[1:6:2] =\", a[1:6:2])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-fb_yt_TQKsp"
      },
      "source": [
        "# Modificando Listas y Aliasing  \n",
        "A diferencia de los strings, las listas son modificables. Esto significa que pueden ser modificadas, sin necesidad de crear una lista nueva. Esto nos fuerza a comprender el aliasing, que es cuando dos variables se referencian al mismo valor."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UozTa17IuFcV"
      },
      "source": [
        "Ejemplo"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pcmxdmZ0tw1w",
        "outputId": "9bd26e10-9f1b-41d9-e84e-10d8e7fa6d49"
      },
      "source": [
        "# Creando una lista\n",
        "a = [ 2, 3, 5, 7 ]\n",
        "\n",
        "# Creando un alias a la lista\n",
        "b = a\n",
        "\n",
        "# Ahora tenemos dos referencias (alias) a la MISMA lista\n",
        "a[0] = 42\n",
        "b[1] = 99\n",
        "print(a)\n",
        "print(b)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[42, 99, 5, 7]\n",
            "[42, 99, 5, 7]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eVBDeN9wt_qc"
      },
      "source": [
        "Otro ejemplo"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Dxu4ULOFXUfu",
        "outputId": "6a6472ed-6644-418e-b692-d8f7c63ba8ce"
      },
      "source": [
        "# Creando una lista\n",
        "a = [ 2, 3, 5, 7 ]\n",
        "\n",
        "# Creando un alias a la lista\n",
        "b = a\n",
        "\n",
        "# Creando una lista diferente con los mismos elementos\n",
        "c = [ 2, 3, 5, 7 ]\n",
        "\n",
        "# a y b son alias de la MISMA lista\n",
        "# c es una referencia a otra lista que tiene los mismos elementos\n",
        "\n",
        "print(\"inicialmente:\")\n",
        "print(\"  a==b  :\", a==b)\n",
        "print(\"  a==c  :\", a==c)\n",
        "print(\"  a es b:\", a is b) # el operador \"is\" dice si dos variables son alias\n",
        "print(\"  a es c:\", a is c)\n",
        "\n",
        "# Cambiar a también cambia b (ya que es la MISMA lista), pero no c (que es otra lista)\n",
        "a[0] = 42\n",
        "print(\"Despues de cambiar a[0] a 42\")\n",
        "print(\"  a=\", a)\n",
        "print(\"  b=\", b)\n",
        "print(\"  c=\", c)\n",
        "print(\"  a==b  :\", a==b)\n",
        "print(\"  a==c  :\", a==c)\n",
        "print(\"  a es b:\", a is b)\n",
        "print(\"  a es c:\", a is c)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "inicialmente:\n",
            "  a==b  : True\n",
            "  a==c  : True\n",
            "  a es b: True\n",
            "  a es c: False\n",
            "Despues de cambiar a[0] a 42\n",
            "  a= [42, 3, 5, 7]\n",
            "  b= [42, 3, 5, 7]\n",
            "  c= [2, 3, 5, 7]\n",
            "  a==b  : True\n",
            "  a==c  : False\n",
            "  a es b: True\n",
            "  a es c: False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U4NS6ihKhY8b"
      },
      "source": [
        "## Recorriendo listas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BcHqIkTsvEHZ"
      },
      "source": [
        "Iterando con un ciclo for"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5XulJrFMvj3e",
        "outputId": "7769a682-8216-4fc2-f392-f8882878d177"
      },
      "source": [
        "a = [ 2, 3, 5, 7 ]\n",
        "print(\"Estos son los elementos en a con sus índices:\")\n",
        "for index in range(len(a)):\n",
        "    print(\"a[\", index, \"] =\", a[index])"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Estos son los items en a con sus índices:\n",
            "a[ 0 ] = 2\n",
            "a[ 1 ] = 3\n",
            "a[ 2 ] = 5\n",
            "a[ 3 ] = 7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-48AbV28vwH5"
      },
      "source": [
        "Iterando con un for cada ciclo"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Gd5UjYs3wJt5",
        "outputId": "1c4b9add-cb07-471c-dd8d-bac7a647afd2"
      },
      "source": [
        "# Las listas son tipos iterables.\n",
        "# Esto significa que podemos iterar sobre ellas directamente!\n",
        "a = [ 2, 3, 5, 7 ]\n",
        "print(\"Estos son los elementos en a:\")\n",
        "for item in a:\n",
        "    print(item)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Estos son los elementos en a:\n",
            "2\n",
            "3\n",
            "5\n",
            "7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QKzKtpMR3OlH"
      },
      "source": [
        "## Creando listas por comprensión"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1KFgUxwW_9wx",
        "outputId": "f74e29cc-8e4d-4cfd-c644-b19cee5d9ca0"
      },
      "source": [
        "# Creeando una lista por comprensión\n",
        "a = [i for i in range(10)]\n",
        "print(a)\n",
        "\n",
        "# Podemos también agregar condicionales al final\n",
        "a = [(i*100) for i in range(20) if i%5 == 0]\n",
        "print(a)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
            "[0, 500, 1000, 1500]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SZ3kklh3AVJl"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}