Repaso_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Sesion1.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Javcm/Intro-a-Deep-Learning-UNAM-FC/blob/main/Repaso_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2p_zx4Cd9fXu"
      },
      "source": [
        "# Programando en Python"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0pQinQDc87SV"
      },
      "source": [
        "#Tipo entero\n",
        "a = 4\n",
        "#Tipo cadena\n",
        "b = \"Hola\"\n",
        "#Tipo flotante \n",
        "c = 0.5  \n",
        "#Tipo booleano\n",
        "d = True \n"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1pB2Xd1dVWDF",
        "outputId": "cc2b6248-eaa4-49a6-da4f-1b390f45da61"
      },
      "source": [
        "#Función print: Imprime el objeto entre paréntesis (puede ser más de un objeto)\n",
        "print(a,b,c,d)\n",
        "\n",
        "#Función type: Nos dice el tipo de objeto \n",
        "print(type(a),type(b),type(c),type(d))\n",
        "print(type(\"5\"),type(5))"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4 Hola 0.5 True\n",
            "<class 'int'> <class 'str'> <class 'float'> <class 'bool'>\n",
            "<class 'str'> <class 'int'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2Nq1yA3b9enB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a1934dbe-311a-44f1-92be-1ff71e0a7491"
      },
      "source": [
        "#Operaciones entre elementos\n",
        "\n",
        "print(type(a*c),a*c)\n",
        "\n",
        "print(type(c*c),c*c)\n",
        "\n",
        "print(type(a*b),a*b)\n",
        "\n",
        "print(type(b*d),b*d)\n",
        "\n",
        "print(type(b*False),b*False)\n",
        "\n",
        "#print(b*0)\n",
        "\n",
        "print(type(a*d),a*d)\n",
        "\n",
        "print(type(a*False),a*False)\n",
        "\n",
        "print(type(c*d),c*d)\n",
        "\n",
        "print(type(c*False),c*False)\n",
        "\n",
        "print(type(d*d),d*d)\n",
        "\n",
        "print(type(False*False),False*False)\n",
        "\n",
        "# #Hacer True*False"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'float'> 2.0\n",
            "<class 'float'> 0.25\n",
            "<class 'str'> HolaHolaHolaHola\n",
            "<class 'str'> Hola\n",
            "<class 'str'> \n",
            "<class 'int'> 4\n",
            "<class 'int'> 0\n",
            "<class 'float'> 0.5\n",
            "<class 'float'> 0.0\n",
            "<class 'int'> 1\n",
            "<class 'int'> 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PL6Q_WA7rK3A",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1937f670-021f-4530-d7dc-b9baece10735"
      },
      "source": [
        "#Operaciones entre elementos\n",
        "print(type(a+c),a+c)\n",
        "\n",
        "print(type(c+c),c+c)\n",
        "\n",
        "#print(type(a+b),a+b)\n",
        "\n",
        "#print(type(b+d),b+d)\n",
        "\n",
        "print(type(a+d),a+d)\n",
        "\n",
        "print(type(c+d),c+d)\n",
        "\n",
        "print(type(d+d),d+d)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'float'> 4.5\n",
            "<class 'float'> 1.0\n",
            "<class 'int'> 5\n",
            "<class 'float'> 1.5\n",
            "<class 'int'> 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_9-UIdC-aPgy",
        "outputId": "d913d13d-4200-46a2-c9b3-b46c6c736973"
      },
      "source": [
        "#Función input: Imprime una cadena y lee un objeto dado por el usuario\n",
        "a = input(\"Escribe algo: \")\n",
        "print(a,type(a))"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Escribe algo: 5\n",
            "5 <class 'str'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zhOIp6L8Xy3U",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a468dcd5-b158-45c2-9533-2468624dff6d"
      },
      "source": [
        "#Sumadora\n",
        "\n",
        "num1 = input(\"Ingresa un número: \")\n",
        "num2 = input(\"Ingresa otro número: \")\n",
        "result = float(num1) + float(num2)\n",
        "\n",
        "print(\"Suma:\",result)"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingresa un número: 5.5\n",
            "Ingresa otro número: 6\n",
            "Suma: 11.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LG4nDYg1tmZb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9437b96e-f45d-43b0-d5cc-d8b16abdba9c"
      },
      "source": [
        "#Otras operaciones (condicionales)\n",
        "\n",
        "a = 4\n",
        "\n",
        "print(a>c,a<c)\n",
        "\n",
        "print(a==c,a==4,a==4.0)\n",
        "\n",
        "print(c>2*c,c<2*c)\n",
        "\n",
        "print(c==2*c,c==c)\n",
        "\n",
        "print(True<False,True>False)\n",
        "\n",
        "#Modulo\n",
        "print(a%3)\n",
        "\n",
        "print(0.5*15%3)"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True False\n",
            "False True True\n",
            "False True\n",
            "False True\n",
            "False True\n",
            "1\n",
            "1.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ujhRYXQar-ac"
      },
      "source": [
        "## Ejercicio \n",
        "\n",
        "Hacer una calculadora que pida dos números al usuario y devuelva la suma, la resta, la multiplicación, división y módulo."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BZlP9BE6ca2p"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1RUoJ3VIeL-S"
      },
      "source": [
        "# Listas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9tlz9m7w9ewP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c0c1f6b2-bb95-4e33-af63-8d2b5ded3542"
      },
      "source": [
        "lista = [a,b,c]\n",
        "print(lista)\n",
        "#En python los indices inician en 0 y se usa corchetes para acceder a estos\n",
        "print(lista[0])\n",
        "print(lista[-1],lista[-2],lista[-3])\n",
        "\n",
        "#Para medir una lista\n",
        "len(lista)"
      ],
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[4, 'Hola', 3]\n",
            "4\n",
            "3 Hola 4\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OxVjup1U-8Ho",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4bc8ff12-77fe-4e44-913a-9c4a2178cce6"
      },
      "source": [
        "lista1=[3,4,\"prueba\",6]\n",
        "lista2=[3,3,\"prueba2\",6]\n",
        "meta_lista = [lista1,lista2]\n",
        "\n",
        "print(meta_lista,len(meta_lista))"
      ],
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[3, 4, 'prueba', 6], [3, 3, 'prueba2', 6]] 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W5gBkp0FwleI",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "7ed7adea-cdcd-46eb-efa4-17a4ce4b81c2"
      },
      "source": [
        "meta_lista[1][2]"
      ],
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'prueba2'"
            ]
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IBWwrfa9AQgZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "be93bd43-f789-4fa3-caba-23d92cc9da7b"
      },
      "source": [
        "meta_meta_lista=[meta_lista,lista1,lista2]\n",
        "print(meta_meta_lista,len(meta_meta_lista))\n",
        "\n",
        "print(meta_meta_lista[0][1][2])"
      ],
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[[3, 4, 'prueba', 6], [3, 3, 'prueba2', 6]], [3, 4, 'prueba', 6], [3, 3, 'prueba2', 6]] 3\n",
            "prueba2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I0slc4D_x5kO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "44d162e6-bc07-4018-a730-9cd6c794d00d"
      },
      "source": [
        "#Operaciones con listas\n",
        "\n",
        "lista1*3\n",
        "\n",
        "lista1+lista2\n",
        "\n",
        "#lista1*lista2\n",
        "\n",
        "type(lista)"
      ],
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {},
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C1E38_K7yxYp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cc8860a1-3e42-4bda-ec16-891c5f9c747c"
      },
      "source": [
        "# Diccionarios\n",
        "\n",
        "dic = {\"d1\":3,\"d2\":4,\"d3\":\"Hey\"}\n",
        "\n",
        "dic[\"d1\"]\n",
        "\n",
        "dic2 = {4:\"JEJE\",2:4}\n",
        "\n",
        "dic2[4]\n",
        "\n",
        "dic3 = {4:lista1,3:meta_lista}\n",
        "\n",
        "dic3[4][2]\n",
        "\n",
        "type(dic3)"
      ],
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wpFnyKtFyxf8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9be7c391-273b-4056-e03d-2c5bac40593d"
      },
      "source": [
        "#Tuplas\n",
        "\n",
        "tupla1 = (a,b,c) + (3,2,4)\n",
        "\n",
        "print(tupla1,type(tupla1))\n",
        "\n",
        "print(a,b,c)\n",
        "\n",
        "type((a,b,c))"
      ],
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(3, 2, 4, 3, 2, 4) <class 'tuple'>\n",
            "3 2 4\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "metadata": {},
          "execution_count": 75
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jzX_LehJh45T",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a4675a54-6f3f-4c4c-f63c-2f1361478fb9"
      },
      "source": [
        "#Conjuntos\n",
        "\n",
        "A = set([2,2,3,3,3,4,\"Hola\"])\n",
        "\n",
        "print(A)\n",
        "\n",
        "B = set([3,4,\"Hola\",5])\n",
        "\n",
        "#Intersección\n",
        "B&A\n",
        "\n",
        "# #Diferencia\n",
        "B-A\n",
        "\n",
        "# #Unión \n",
        "A.union(B)\n",
        "A|B\n"
      ],
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Hola', 2, 3, 4}\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{2, 3, 4, 5, 'Hola'}"
            ]
          },
          "metadata": {},
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zq8POxKPBlBZ"
      },
      "source": [
        "# Estructuras de control"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3qiaI0TTEZ8w"
      },
      "source": [
        "## ciclos for"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BNCB9dR_A5hp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b6b5b22c-4a24-4d62-eda5-a55fdadf2215"
      },
      "source": [
        "print(lista1[0])\n",
        "print(lista1[1])\n",
        "print(lista1[2])\n",
        "print(lista1[3])"
      ],
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "4\n",
            "prueba\n",
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_h6xGYeMD1I7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "2faa27c9-3606-4794-974c-171a96ed214f"
      },
      "source": [
        "lista1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[3, 4, 'prueba', 6]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NHXUs3KHB0G4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f6bdec8c-9c3b-4b7b-d319-c9585f9f5b0c"
      },
      "source": [
        "for i in range(4):\n",
        "  print(i)\n",
        "  #print(lista1[i])\n",
        "\n",
        "print(\"Hola\")"
      ],
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "Hola\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jeq3mBarCTBj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7d5d0d91-34b6-4a2b-c18a-3c87ca48336a"
      },
      "source": [
        "for i in lista1:\n",
        "  print(i)"
      ],
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "4\n",
            "prueba\n",
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qmYxQH71DsWy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "85512b37-62e5-4d60-9088-8050c5181f4c"
      },
      "source": [
        "lista_extraña = [[[3, 4, 'prueba', 6], [3, 3, 'prueba2', 6]],\n",
        " [3, 4, 'prueba', 6],\n",
        " [3, 3, 'prueba2', 6]]\n",
        "\n",
        "lista_extraña"
      ],
      "execution_count": 100,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[[3, 4, 'prueba', 6], [3, 3, 'prueba2', 6]],\n",
              " [3, 4, 'prueba', 6],\n",
              " [3, 3, 'prueba2', 6]]"
            ]
          },
          "metadata": {},
          "execution_count": 100
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tTsW0i5CFqQu"
      },
      "source": [
        "Python es un lenguaje identado (que importa la tabulación)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UoyV5ogiDlDt",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 141
        },
        "outputId": "d757e19a-719e-49b3-85c1-824fa4854fa0"
      },
      "source": [
        "for i in lista_extraña:\n",
        "  print(i)\n",
        "  print(\"s\")\n",
        "\n",
        "print(\"Hola\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[3, 4, 'prueba', 6], [3, 3, 'prueba2', 6]]\n",
            "s\n",
            "[3, 4, 'prueba', 6]\n",
            "s\n",
            "[3, 3, 'prueba2', 6]\n",
            "s\n",
            "Hola\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P4doQli0Ihia",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 106
        },
        "outputId": "383469b1-0148-4dbd-e860-61e5943dc9e2"
      },
      "source": [
        "print(len(lista_extraña))\n",
        "print(len(lista_extraña[0]))\n",
        "print(len(lista_extraña[1]))\n",
        "print(len(lista_extraña[2]))\n",
        "(2+4+4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n",
            "2\n",
            "4\n",
            "4\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 74
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8o47SGnRFoTG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "012e91a6-381d-456a-d737-324f5ffc45a6"
      },
      "source": [
        "#For anidado \n",
        "for i in lista_extraña:\n",
        "  for j in i:\n",
        "    print(\"i:\",i)\n",
        "    print(\"j:\",j)\n",
        "    #print(\"Hola\")\n",
        "    \n",
        "  #print(\"Adios\")\n",
        "  \n"
      ],
      "execution_count": 107,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "i: [[3, 4, 'prueba', 6], [3, 3, 'prueba2', 6]]\n",
            "j: [3, 4, 'prueba', 6]\n",
            "i: [[3, 4, 'prueba', 6], [3, 3, 'prueba2', 6]]\n",
            "j: [3, 3, 'prueba2', 6]\n",
            "i: [3, 4, 'prueba', 6]\n",
            "j: 3\n",
            "i: [3, 4, 'prueba', 6]\n",
            "j: 4\n",
            "i: [3, 4, 'prueba', 6]\n",
            "j: prueba\n",
            "i: [3, 4, 'prueba', 6]\n",
            "j: 6\n",
            "i: [3, 3, 'prueba2', 6]\n",
            "j: 3\n",
            "i: [3, 3, 'prueba2', 6]\n",
            "j: 3\n",
            "i: [3, 3, 'prueba2', 6]\n",
            "j: prueba2\n",
            "i: [3, 3, 'prueba2', 6]\n",
            "j: 6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "85EXKZZPJxfQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d424fca3-9c8b-4b8a-e09d-beb3e246b3e8"
      },
      "source": [
        "lista_prueba = [lista1,lista2]\n",
        "\n",
        "#For anidado \n",
        "for i in lista_prueba:\n",
        "  for j in i:\n",
        "    print(j)\n",
        "    print(\"Hola\")\n",
        "    \n",
        "  print(\"Adios\")\n",
        "  \n"
      ],
      "execution_count": 108,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "Hola\n",
            "4\n",
            "Hola\n",
            "prueba\n",
            "Hola\n",
            "6\n",
            "Hola\n",
            "Adios\n",
            "3\n",
            "Hola\n",
            "3\n",
            "Hola\n",
            "prueba2\n",
            "Hola\n",
            "6\n",
            "Hola\n",
            "Adios\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ni6oLXUUNc36"
      },
      "source": [
        "## Booleanos, if, else "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6rVSPEY-LDld",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "03a45e87-a92d-4f42-9733-d9c2aca0a6ab"
      },
      "source": [
        "T = True\n",
        "F = False\n",
        "pregunta = T\n",
        "\n",
        "if pregunta == True:\n",
        "  print(\"Verdadero\")\n",
        "else:\n",
        "  print(\"Falso\")"
      ],
      "execution_count": 110,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Verdadero\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q083vjt4MDjh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "770c6403-0e0b-4fbb-85bf-b72388cb4d15"
      },
      "source": [
        "a=5\n",
        "if a == 5:\n",
        "  print(\"Verdadero\")\n",
        "else:\n",
        "  print(\"Falso\")"
      ],
      "execution_count": 115,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Verdadero\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GCYM7SKQM4AL",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "83dace11-2be5-47f2-f881-7acee085ed1b"
      },
      "source": [
        "# En python dos iguales significa preguntar si son iguales\n",
        "\n",
        "a == 5"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gjzjPHfzMOJg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c54fbb28-91db-43ff-9269-0b65e481af95"
      },
      "source": [
        "booleano = a == 5\n",
        "booleano"
      ],
      "execution_count": 114,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 114
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ATJBMIlKM27p",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "outputId": "02715a06-5783-40ee-b324-a1a57842763a"
      },
      "source": [
        "#También se puede con desigualdades\n",
        "\n",
        "print(a < 6)\n",
        "print(a <= 6)\n",
        "print(a > 4)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n",
            "True\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q79Rj2KsEc0v"
      },
      "source": [
        "# ciclos while\n",
        "\n",
        "Son útiles para cuando quieres evaluar condiciones o conjuntos que no están definidos a priori"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rmp5LIiwDtoq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "87892dff-406f-4f95-9469-0f26382064e9"
      },
      "source": [
        "i=0\n",
        "while i < len(lista1):\n",
        "  print(i,lista1[i])\n",
        "  i=i+1"
      ],
      "execution_count": 116,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 3\n",
            "1 4\n",
            "2 prueba\n",
            "3 6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OqUD3K7CNvP7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "00d5723f-ea0a-40c8-82cf-8d3c03265bbd"
      },
      "source": [
        "\n",
        "i=0\n",
        "while i < len(lista_prueba):\n",
        "  elemento = lista_prueba[i]\n",
        "  i=i+1\n",
        "  for j in elemento:\n",
        "    print(j)\n",
        "    print(\"Hola\")\n",
        "    \n",
        "  print(\"Adios\")"
      ],
      "execution_count": 117,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "Hola\n",
            "4\n",
            "Hola\n",
            "prueba\n",
            "Hola\n",
            "6\n",
            "Hola\n",
            "Adios\n",
            "3\n",
            "Hola\n",
            "3\n",
            "Hola\n",
            "prueba2\n",
            "Hola\n",
            "6\n",
            "Hola\n",
            "Adios\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0SzwgRZ8Pqpc"
      },
      "source": [
        "## Ejercicio \n",
        "\n",
        "- Crear una lista que contenga 4 elementos de los distintos tipos de variables que vimos\n",
        "\n",
        "- Hacer una lista de listas que contenga 3 listas con 5 elementos cada una (todos numéricos)\n",
        "\n",
        "- Usando for o while hacer que se sumen todos los valores de esta lista\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gZOU4gWi1muu"
      },
      "source": [
        "# Funciones"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9XJziNmHQrd6"
      },
      "source": [
        "def calculadora(num1,num2,operacion):\n",
        "  if operacion == \"suma\":\n",
        "    result = num1 + num2    \n",
        "  elif operacion == \"resta\":\n",
        "    result = num1 - num2\n",
        "  elif operacion == \"producto\":\n",
        "    result = num1*num2\n",
        "  elif operacion == \"cociente\":\n",
        "    result = num1/num2\n",
        "  else:\n",
        "    result = \"Operación desconocida, operaciones válidas: suma, resta, producto, cociente\"\n",
        "  return result\n",
        "\n"
      ],
      "execution_count": 118,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FGvL4jCOQrgu",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 37
        },
        "outputId": "3fa547d4-7b57-48e0-ed67-e8cede041bbc"
      },
      "source": [
        "calculadora(\"hola\",5,\"producto\")"
      ],
      "execution_count": 121,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'holaholaholaholahola'"
            ]
          },
          "metadata": {},
          "execution_count": 121
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z7AAWp3kQrjs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5744b825-86e8-48ab-ddf1-22c0f83bc95b"
      },
      "source": [
        "def calculadora():\n",
        "  num1 = float(input(\"Ingresa un número: \"))\n",
        "  num2 = float(input(\"Ingresa otro número: \"))\n",
        "  operacion = int(input(\"Ingrese el número de la operación que desea realizar: 1:suma, 2:resta, 3:producto, 4:cociente \"))\n",
        "\n",
        "  if operacion == 1:\n",
        "    result = num1 + num2    \n",
        "  elif operacion == 2:\n",
        "    result = num1 - num2\n",
        "  elif operacion == 3:\n",
        "    result = num1*num2\n",
        "  elif operacion == 4:\n",
        "    result = num1/num2\n",
        "  else:\n",
        "    result = \"Operación desconocida, operaciones válidas: suma, resta, producto, cociente\"\n",
        "\n",
        "  return float(result)\n",
        "\n",
        "calculadora()"
      ],
      "execution_count": 122,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Ingresa un número: 5\n",
            "Ingresa otro número: 9.2\n",
            "Ingrese el número de la operación que desea realizar: 1:suma, 2:resta, 3:producto, 4:cociente 2\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-4.199999999999999"
            ]
          },
          "metadata": {},
          "execution_count": 122
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S9_6J8RnRVVs"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IZYV57dtRVY4"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tr-AeNBXRVcN"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZJSkKGJyRVhq"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}