Fundamentos2_CyP_1157 18 NOV 21.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Fundamentos2 CyP 1157.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sRAC1t7fFeu1"
      },
      "source": [
        "# Tipos de datos estructurados de phyton\n",
        "\n",
        "\n",
        "1. Listas\n",
        "2. Tuplas\n",
        "3. Diccionarios\n",
        "4. Conjuntos (opcional)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8fVrsD5vFrJj"
      },
      "source": [
        "# Listas\n",
        "\n",
        "- Tipo de dato que agrupa variables o valores.\n",
        "- Estructura secuencial (indexados empezando por 0)\n",
        "- Se declara de dos formas\n",
        "  - Usando [ ]\n",
        "  - Usando list ( )\n",
        "  - Usando generador\n",
        "- Puede contener tipos de datos diversos (En otros lenguajes de prog. no es posible de forma directa)\n",
        "- Los elementos internos se seleccionan con [ ]\n",
        "- Soporta slicing\n",
        "- SON MUTABLES\n",
        "- GENERADORES [var for x in range( 10 )]\n",
        "- Al ser una clase contiene muchos metodos utiles"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SnbXjfEOGccz",
        "outputId": "68f9a8ab-8a7d-4e97-a650-9816af2b1296"
      },
      "source": [
        "numeros= [10, 5, 2, 3, 1]\n",
        "print(numeros)\n",
        "\n",
        "numeros2= list()\n",
        "numeros2.append(10)\n",
        "numeros2.append(5)\n",
        "numeros2.append(2)\n",
        "numeros2.append(3)\n",
        "numeros2.append(1)\n",
        "print(numeros2)\n",
        "#para cambiar un numero por otro se hace lo siguiente:\n",
        "numeros[2] = 20\n",
        "print(numeros)\n",
        "numeros[-1] = 33\n",
        "print(numeros)\n",
        "numeros.append(88)\n",
        "print(numeros)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[10, 5, 2, 3, 1]\n",
            "[10, 5, 2, 3, 1]\n",
            "[10, 5, 20, 3, 1]\n",
            "[10, 5, 20, 3, 33]\n",
            "[10, 5, 20, 3, 33, 88]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AWWz566FIe1S",
        "outputId": "2b29bb39-0eb6-4d59-e975-660932291a97"
      },
      "source": [
        "#Tipos diversos\n",
        "\n",
        "cosas = [12, 2 , True , \"Jose\" , 1.57 , [\"pera\" , \"kiwi\" , \"uva\"]]\n",
        "print(cosas)\n",
        "print(cosas[1] )\n",
        "print(cosas[ 4 ] )\n",
        "print(cosas[5][1] )\n",
        "print(cosas[3][1:3:] )\n",
        "cosas[3] = cosas[3].upper()\n",
        "print(cosas)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[12, 2, True, 'Jose', 1.57, ['pera', 'kiwi', 'uva']]\n",
            "2\n",
            "1.57\n",
            "kiwi\n",
            "os\n",
            "[12, 2, True, 'JOSE', 1.57, ['pera', 'kiwi', 'uva']]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hOpyS0QnL2-Z",
        "outputId": "e5a59f30-b2a0-4b49-f66d-3f3bb770a5c1"
      },
      "source": [
        "numeros = [1,2,3,4,5,6,7,8,9,10,11]\n",
        "print(numeros)\n",
        "# silcing\n",
        "# 1. 4 al 8????\n",
        "print(numeros[3:8] )\n",
        "# 2. [9,10]\n",
        "print(numeros[8:10])\n",
        "print(numeros[-3:-1:] )\n",
        "# 3. Imprimir la lista en orden inverso [11,10,9,etc.]\n",
        "print(numeros[::-1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]\n",
            "[4, 5, 6, 7, 8]\n",
            "[9, 10]\n",
            "[9, 10]\n",
            "[11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XpI_KmPMPngJ"
      },
      "source": [
        "#crear una lista con un generador\n",
        "numeros = [ x*3 for x in range (101)]#el numero final no se incluye por eso 101\n",
        "print(numeros)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cNbJzyJ0QZ-B"
      },
      "source": [
        "#funcion range ()\n",
        "\n",
        "Tiene los mismos componentes que slicing ini, stop, incremento\n",
        "\n",
        "range(1,101,1)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OPd--7I_QlCq",
        "outputId": "dad37161-e80f-4d6c-dc10-f85974940ea7"
      },
      "source": [
        "numeros = [ x for x in range(50,101)]\n",
        "print(numeros)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2RxPn5EpRNow"
      },
      "source": [
        "# METODOS DISPONIBLES DE LAS LISTAS"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NnvBPOOnRQZa"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mBms8VflSshA",
        "outputId": "3c5ddbf8-4866-41b3-b2e2-5170c296b9ce"
      },
      "source": [
        "numeros = [4,1,15,8,22,34,50]\n",
        "print(numeros)\n",
        "numeros.append(99)\n",
        "print(numeros)\n",
        "#numeros.clear()\n",
        "print(numeros)\n",
        "#alternativa numeros=[] pero de preferencia con clear\n",
        "\n",
        "frutas = [ \"uvas\" , \"kiwi\" , \"manzana\" ]\n",
        "copia = frutas\n",
        "print(frutas)\n",
        "print(copia)\n",
        "frutas.append(\"naranja\") \n",
        "print(frutas)\n",
        "print(copia)\n",
        "\n",
        "colores = [ \"rojo\" , \"azul\" , \"blanco\" ]\n",
        "copia2 = colores.copy()\n",
        "print(colores)\n",
        "print(copia2)\n",
        "colores.append(\"verde\")\n",
        "print(colores)\n",
        "print(copia2)\n",
        "\n",
        "print(\"numero de veces que aparece el 15=\", numeros.count(15))\n",
        "\n",
        "#extend\n",
        "\n",
        "nombres = [\"Jose\",\"Pedro\", \"karina\"]\n",
        "otrosNombres = [\"Josue\",\"diana\",\"dalia\"]\n",
        "print(nombres)\n",
        "print(otrosNombres)\n",
        "nombres= nombres + otrosNombres\n",
        "\n",
        "print(nombres)\n",
        "print(otrosNombres)\n",
        "\n",
        "#Lo mismo con el metodo extend\n",
        "otrosNombres.extend ( [\"Jesus\",\"maria\",\"jose\"])\n",
        "print(otrosNombres)\n",
        "print(\"Jesus esta en la posicion:\", otrosNombres.index(\"Jesus\")) \n",
        "#index es para buscar donde esta un valor\n",
        "otrosNombres.insert(4, \"Espiritu santo\")\n",
        "#insert para insertar un valor en una posicion \n",
        "print(otrosNombres)\n",
        "\n",
        "#pop\n",
        "resultado = otrosNombres.pop ()\n",
        "#pop saca el ultimo valor de la variable\n",
        "print(otrosNombres)\n",
        "print(resultado)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[4, 1, 15, 8, 22, 34, 50]\n",
            "[4, 1, 15, 8, 22, 34, 50, 99]\n",
            "[4, 1, 15, 8, 22, 34, 50, 99]\n",
            "['uvas', 'kiwi', 'manzana']\n",
            "['uvas', 'kiwi', 'manzana']\n",
            "['uvas', 'kiwi', 'manzana', 'naranja']\n",
            "['uvas', 'kiwi', 'manzana', 'naranja']\n",
            "['rojo', 'azul', 'blanco']\n",
            "['rojo', 'azul', 'blanco']\n",
            "['rojo', 'azul', 'blanco', 'verde']\n",
            "['rojo', 'azul', 'blanco']\n",
            "numero de veces que aparece el 15= 1\n",
            "['Jose', 'Pedro', 'karina']\n",
            "['Josue', 'diana', 'dalia']\n",
            "['Jose', 'Pedro', 'karina', 'Josue', 'diana', 'dalia']\n",
            "['Josue', 'diana', 'dalia']\n",
            "['Josue', 'diana', 'dalia', 'Jesus', 'maria', 'jose']\n",
            "Jesus esta en la posicion: 3\n",
            "['Josue', 'diana', 'dalia', 'Jesus', 'Espiritu santo', 'maria', 'jose']\n",
            "['Josue', 'diana', 'dalia', 'Jesus', 'Espiritu santo', 'maria']\n",
            "jose\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4qDnraYHwA7n"
      },
      "source": [
        "#Tuplas\n",
        "\n",
        "### Caracteristicas de las tuplas\n",
        "\n",
        "- Son datos agrupados\n",
        "- Se declara usando#\n",
        "  - ( )\n",
        "  - tuple ( )\n",
        "- Estructura secuencial, indexada a partir de 0\n",
        "- pueden tener de 0 a n elementos\n",
        "- NO SON MUTABLES (No se puede:Eliminar y/o cambiar)\n",
        "-Son buenas para almanecar informacion de consulta\n",
        "- Pueden alamacenar info. de diferente tipos de datos.\n",
        "- Pueden estar anidadas\n",
        "- Tienen metodos utiles"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kAz1-hgtw2ZP",
        "outputId": "96cb1efe-4ba6-422f-e3c8-6d55bb28c064"
      },
      "source": [
        "info = (\"juan23\" , \"dios1234\" , \"123.232.1.12\")\n",
        "print(info)\n",
        "print(info[1])\n",
        "#info[ 1 ] = \"patito23\" no se puede agregar ni eliminar elementos en tuplas\n",
        "\n",
        "numeros = (0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)\n",
        "print( numeros )\n",
        "print( numeros [5:11:])\n",
        "\n",
        "cosas = ( info , numeros)\n",
        "print( cosas )\n",
        "print( cosas[1][5:11:1] )\n",
        "print( cosas[0][2][4:7] )\n",
        "print( cosas[0][2][-8:-5] )"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('juan23', 'dios1234', '123.232.1.12')\n",
            "dios1234\n",
            "(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)\n",
            "(5, 6, 7, 8, 9, 10)\n",
            "(('juan23', 'dios1234', '123.232.1.12'), (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15))\n",
            "(5, 6, 7, 8, 9, 10)\n",
            "232\n",
            "232\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VshppgTp0qQY"
      },
      "source": [
        "# metodos de las tuplas\n",
        "\n",
        "son los mismos de las listas pero los que no involucren mutabilidad."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S3SQ8wmt2vAQ"
      },
      "source": [
        "# Diccionarios\n",
        "### Caracteristicas de los diccionarios\n",
        "\n",
        "- Agrupan datos pero de forma no lineal\n",
        "- Se declacan con: \n",
        "  - { }\n",
        "  -dic( )\n",
        "- Formado por pares del tipo llave:valor , donde:\n",
        "  - llave es de tipo de string (Siempre)\n",
        "  - valor puede ser de cualquier tipo de datos, incluyendo las diccionarios.\n",
        "- Se seleccionan con la llave de la forma: [\"id_llave\"]\n",
        "- Son mutables\n",
        "- Son anidables\n",
        "- Son equivalentes al tipo de dato JSON del lenguaje JavaScript (JS)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZifeEGX234fo",
        "outputId": "a73e10d3-7b4f-4622-cfc5-086c6e5ee662"
      },
      "source": [
        "alumno = { \"nombre\" : \"Jose\" }\n",
        "print(alumno)\n",
        "print(alumno[\"nombre\"])\n",
        "alumno = { \"nombre\" : \"Jose\" , \"nc\" : \"2129229292\" , \"edad\" : 18}\n",
        "print(\"Edad del alumno =\" , alumno[\"edad\"])\n",
        "print(alumno[\"nombre\"].upper ())\n",
        "print(alumno)\n",
        "\n",
        "print(\"alumno 2:\")\n",
        "alumno2 = dict() #{ }\n",
        "alumno2[\"nombre\"] = \"Jose\"\n",
        "print(alumno2)\n",
        "alumno2[\"nc\"] = \"2129229292\"\n",
        "alumno2[\"edad\"] = 18\n",
        "print(alumno2)\n",
        "alumno2[\"edad\"] = alumno2[\"edad\"] + 1\n",
        "print(alumno2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'nombre': 'Jose'}\n",
            "Jose\n",
            "Edad del alumno = 18\n",
            "JOSE\n",
            "{'nombre': 'Jose', 'nc': '2129229292', 'edad': 18}\n",
            "alumno 2:\n",
            "{'nombre': 'Jose'}\n",
            "{'nombre': 'Jose', 'nc': '2129229292', 'edad': 18}\n",
            "{'nombre': 'Jose', 'nc': '2129229292', 'edad': 19}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FEWQogGa8PKh",
        "outputId": "1ad21074-e62b-4d05-fa47-6faee47dc93f"
      },
      "source": [
        "cliente = { \"id\" : \"CT2121\" , \n",
        "           \"nombre\" : \"Jose Pedroza Rosales\" , \n",
        "           \"telefono\" : \"casa:5532456745 cel=5511453429\"}\n",
        "print(cliente)\n",
        "cliente = { \"id\" : \"CT2121\" , \n",
        "           \"nombre\" : {\n",
        "               \"nombre\" : [\"Jose\"],\n",
        "               \"paterno\" : [\"Pedroza\"],\n",
        "               \"materno\" : [\"Rosales\"]\n",
        "           } ,\n",
        "           \"telefonos\" : {\n",
        "               \"casa\" : \"55-3245-6745\", \n",
        "               \"trabajo\" : \"55-6439-2823\",\n",
        "               \"celular\" : \"55-1145-3429\" ,\n",
        "           } ,\n",
        "           \"productos\" : {\n",
        "                      \"ahorro\" : {\"numero_cuenta\" : \"7788\" , \"ahorro\": 2500.5 },\n",
        "                      \"tarjetas\" : [ \n",
        "                                     {\"tipo\":\"debito\"},\n",
        "                                     {\"tipo\":\"credito preferente\" , \"limite\": 250000.5},\n",
        "                                     {\"tipo\":\"lite\" , \"limite\" : 15000.5}\n",
        "                        ]\n",
        "            } ,\n",
        "            \"direccion\":{\n",
        "                    \"calle\":\"Av. central\",\n",
        "                    \"numero\" : 1245,\n",
        "                    \"colonia\" : \"Impulsora\",\n",
        "                    \"delegacion\" : \"neza\",\n",
        "                    \"estado\" : {\n",
        "                                \"clave\" : 15,\n",
        "                                \"nombre_corto\": \"EdoMex\",\n",
        "                                \"nombre\" : \"Estado de Mexico\"\n",
        "                               }\n",
        "                }\n",
        "                }\n",
        "print(cliente[\"telefonos\"][\"casa\"])\n",
        "print(cliente)\n",
        "print(cliente[\"productos\"][\"ahorro\"][\"ahorro\"])\n",
        "print(cliente[\"productos\"][\"tarjetas\"][2][\"limite\"])\n",
        "print(cliente[\"direccion\"][\"estado\"][\"nombre\"].upper())\n",
        "cliente[\"productos\"][\"ahorro\"][\"ahorro\"] -=1500.0\n",
        "print(cliente[\"productos\"])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'id': 'CT2121', 'nombre': 'Jose Pedroza Rosales', 'telefono': 'casa:5532456745 cel=5511453429'}\n",
            "55-3245-6745\n",
            "{'id': 'CT2121', 'nombre': {'nombre': ['Jose'], 'paterno': ['Pedroza'], 'materno': ['Rosales']}, 'telefonos': {'casa': '55-3245-6745', 'trabajo': '55-6439-2823', 'celular': '55-1145-3429'}, 'productos': {'ahorro': {'numero_cuenta': '7788', 'ahorro': 2500.5}, 'tarjetas': [{'tipo': 'debito'}, {'tipo': 'credito preferente', 'limite': 250000.5}, {'tipo': 'lite', 'limite': 15000.5}]}, 'direccion': {'calle': 'Av. central', 'numero': 1245, 'colonia': 'Impulsora', 'delegacion': 'neza', 'estado': {'clave': 15, 'nombre_corto': 'EdoMex', 'nombre': 'Estado de Mexico'}}}\n",
            "2500.5\n",
            "15000.5\n",
            "ESTADO DE MEXICO\n",
            "{'ahorro': {'numero_cuenta': '7788', 'ahorro': 1000.5}, 'tarjetas': [{'tipo': 'debito'}, {'tipo': 'credito preferente', 'limite': 250000.5}, {'tipo': 'lite', 'limite': 15000.5}]}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ca1fSzbeMxq6"
      },
      "source": [
        "# Estructura de control de programacion\n",
        "\n",
        "Se puede crear cualquier tipo de algoritmo empleado solamente a 3 estructuras de control:\n",
        "\n",
        "1. Secuencia:\n",
        "  - La representacion de la memoria de programa (Arquitectura Vonn Newman)\n",
        "2. Seleccion:\n",
        "  - Es la estructura de control que decide si un bloque de programas se ejecuta o no se ejecuta. Tambien permite seleccionar ejecutar un bloque entre un conjunto de opciones.\n",
        "  -En resumen tenemos: Seleccion simple, Seleccion con bifurcacion y seleccion multiple\n",
        "3. Repeticion:\n",
        "  - Este tipo de estructura nos permite automatizar la ejecucion repetitiva de codigo mientras ciertas condiciones se cumplan, tenemos 3 variantes de esta estructura en todos los lenguajes de programacion:\n",
        "    - Desde...hasta(estructura for)\n",
        "    - Haz mientras (estructura While)\n",
        "    - Haz y luego validas mientras(Do-While)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "20cBNrMUSCC5"
      },
      "source": [
        "# seleccion simple\n",
        "\n",
        "la estructura if\n",
        "\n",
        "        if <CONDICION>\n",
        "          <Cuerpo del if>\n",
        "\n",
        "**NOTA** Para establecer el cuerpo de una estructura de control en Python se usan los tabuladores\n",
        "\n",
        "En otros lenguajes de programacion como java, c y c++... se usan las llaves { }\n",
        "\n",
        "          int edad =0;\n",
        "          printf(\"dame tu edad\");\n",
        "          scanf(edad>= 18){\n",
        "            printf(\"eres mayor de edad\");\n",
        "          }\n",
        "          printf(\"fin del programa\");\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xUm2ub-lSFy6"
      },
      "source": [
        "edad = int( input(\"Dame tu edad\"))\n",
        "print(f\"Tecleaste {edad} años\")\n",
        "if edad >= 18 :\n",
        "  print(\"Eres mayor de edad\")\n",
        "  print(\"Algo\")\n",
        "print(\"Otra cosa\")\n",
        "print(\"Fin del programa\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aPVSDEvZWa57",
        "outputId": "c0c68139-c5e5-49de-9f22-ba17af6add50"
      },
      "source": [
        "cal = int( input(\"Calificacion del estudiante\"))\n",
        "print(f\"Calificacion {cal}\")\n",
        "if cal > 8 :\n",
        "  print(\"aprobaste\")\n",
        "print(\"Fin del programa\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Calificacion del estudiante9\n",
            "Calificacion 9\n",
            "aprobaste\n",
            "Fin del programa\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PE7QwibPXiqJ",
        "outputId": "04693fb3-9fd5-4fe8-d353-4c3eb3447cb3"
      },
      "source": [
        "SUE = float(input(\"Escribe el sueldo del trabajador: \"))\n",
        "AUM = 0\n",
        "NSUE = 0\n",
        "\n",
        "if SUE < 1000 :\n",
        "  AUM = SUE* 0.15\n",
        "  NSUE = SUE + AUM\n",
        "  print(NSUE)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Escribe el sueldo del trabajador: 875.50\n",
            "1006.825\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-Y7cfR5XGlVt"
      },
      "source": [
        "# estructura de seleccion con bifurcacion (if-else)\n",
        "\n",
        "Esta estructura, selecciona una de dos opciones de ejecucion,se ejecuta un bloque si la condicion se cumple o se ejecuta otro bloque si la condicion no se cumple (else).\n",
        "\n",
        "      if<condicion> :\n",
        "       <bloque de ejecucion>\n",
        "      else: \n",
        "        <bloque de ejecucion alterno>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VCljfPchHdKM",
        "outputId": "cdd95b38-509c-4b40-dbbf-b6472e6f00d1"
      },
      "source": [
        "edad = int(input(\"Dame tu edad: \"))\n",
        "print(f\"Tecleaste {edad} años\")\n",
        "if edad >=18:\n",
        "    print(\"Eres mayor de edad, ten tu cheve\")\n",
        "else:\n",
        "    print(\"Eres menor de edad, ten tu boing\")\n",
        "print(\"fin del programa\")"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dame tu edad: 19\n",
            "Tecleaste 19 años\n",
            "Eres mayor de edad, ten tu cheve\n",
            "fin del programa\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NrvT19plJLRD",
        "outputId": "01012560-aa8f-4ca9-e5ef-87af8134b536"
      },
      "source": [
        "edad = int(input(\"Dame tu edad: \"))\n",
        "dinero = float(input(\"cuanto dinero tienes: \"))\n",
        "print(f\"Tecleaste {edad} años\")\n",
        "print(f\"Tecleaste {dinero} pesos\")\n",
        "if edad >=18 and dinero >=36 :\n",
        "    print(\"Eres mayor de edad, ten tu cheve\")\n",
        "else:\n",
        "    print(\"Eres menor de edad, ten tu boing\")\n",
        "print(\"--FIN DEL PROGRAMA--\")"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dame tu edad: 19\n",
            "cuanto dinero tienes: 60\n",
            "Tecleaste 19 años\n",
            "Tecleaste 60.0 pesos\n",
            "Eres mayor de edad, ten tu cheve\n",
            "--FIN DEL PROGRAMA--\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3thRwSGkNzJS",
        "outputId": "65ea62fd-81f1-4edd-b03d-b3c03c040e69"
      },
      "source": [
        "edad = int(input(\"Dame tu edad:\"))\n",
        "if edad >= 18:\n",
        "    dinero = float(input(\"¿Cuánto dinero tienes?\"))\n",
        "    if dinero >=36:\n",
        "        print(\"Eres mayor de edad y tienes dinero, ten tu cheve\")\n",
        "    else:\n",
        "        print(\"No tienes suficiente dinero para tu cheve, pero tienes la edad\")\n",
        "else:\n",
        "    print(\"No tienes la edad\")\n",
        "print(\"--FIN DEL PROGRAMA--\")"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dame tu edad:20 \n",
            "¿Cuánto dinero tienes?32\n",
            "No tienes suficiente dinero para tu cheve, pero tienes la edad\n",
            "--FIN DEL PROGRAMA--\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tFIsM127MUBB",
        "outputId": "9b0bcc50-d85f-444c-902e-f290c60b75b5"
      },
      "source": [
        "edad = int(input(\"Dame tu edad:\"))\n",
        "dinero = float(input(\"¿Cuánto dinero tienes?\"))\n",
        "if edad >= 18:\n",
        "    if dinero >=36:\n",
        "        print(\"Eres mayor de edad y tienes dinero, ten tu cheve\")\n",
        "    else:\n",
        "        print(\"No tienes suficiente dinero para tu cheve, pero tienes la edad\")\n",
        "else:\n",
        "    if dinero >=36:\n",
        "        print(\"Eres menor de edad pero tienes el dinero\")\n",
        "    else:\n",
        "        print(\"No tienes ni la edad ni el dinero\")\n",
        "print(\"--FIN DEL PROGRAMA--\")"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dame tu edad:20\n",
            "¿Cuánto dinero tienes?20\n",
            "No tienes suficiente dinero para tu cheve, pero tienes la edad\n",
            "--FIN DEL PROGRAMA--\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "soXK-0vSM-la"
      },
      "source": [
        "El codigo anterior se puede simplificar usando:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pR-HQPhKND9o",
        "outputId": "e9b74ade-8793-46eb-8ec1-3eee904b9c70"
      },
      "source": [
        "edad = int(input(\"Dame tu edad: \"))\n",
        "dinero = float(input(\"Cuanto dinero tienes: \"))\n",
        "print(f\"Tecleaste {edad} años\")\n",
        "print(f\"Tecleaste {dinero} dinero\")\n",
        "if edad >= 18 :\n",
        "    if dinero >=36 :\n",
        "        print(\"Ten tu cheve\")\n",
        "    else:\n",
        "        print(\"tienes la edad pero no tienes dinero suficiente\")\n",
        "elif dinero >= 36 :\n",
        "    print(\"Tienes dinero suficiente pero no tienes la edad\")\n",
        "else:\n",
        "    print(\"No tienes la edad ni el dinero, ve a jugar roblox a tu casa\")"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dame tu edad: 12\n",
            "Cuanto dinero tienes: 40\n",
            "Tecleaste 12 años\n",
            "Tecleaste 40.0 dinero\n",
            "Tienes dinero suficiente pero no tienes la edad\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8HMRfNFaXean"
      },
      "source": [
        "###En el codigo anterior se puede simplificar usando la palabra reservada (elif: une if y else)\n",
        "\n",
        "En lugar de \n",
        "\n",
        "            if:\n",
        "                else:\n",
        "seria\n",
        "            \n",
        "            elif:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N9Aex3LzOcUJ"
      },
      "source": [
        "#EJEMPLO 2.3"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Dy2u2micOdBo",
        "outputId": "9b3b21c1-7ece-42c9-c60b-b2b85aea8386"
      },
      "source": [
        "CAL = float(input(\"Calificacion:\"))\n",
        "if CAL >= 8 :\n",
        "    print(\"Aprobado\")\n",
        "else: \n",
        "    print(\"Reprobado\")"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Calificacion:8.00\n",
            "Aprobado\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i4m_rlmPPD7Y"
      },
      "source": [
        "#EJEMPLO 2.4"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ssHN3rSmPIaB",
        "outputId": "e40b5691-d72c-4244-d537-484200b95550"
      },
      "source": [
        "SUE = float(input(\"Sueldo:\"))\n",
        "AUM = 0 \n",
        "NSUE = 0\n",
        "\n",
        "if SUE < 1000 :\n",
        "    AUM = SUE* 0.15\n",
        "    NSUE = SUE + AUM\n",
        "else:\n",
        "    AUM= SUE*0.12\n",
        "    NSUE = SUE + AUM\n",
        "print(NSUE)"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sueldo:900\n",
            "1035.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LXfUbj8GSNnT"
      },
      "source": [
        "#ejercicio if-else\n",
        "###Hacer un programa que solicite el dia de la semana en valor numerico entero del 1 al 7 (Avisarle al usuario si proporciono un valor fuera del rango\n",
        "\n",
        "### Posteriormente imprimira el dia de la semana correspondiente al numero capturado\n",
        "\n",
        "1. Lunes\n",
        "2. Martes\n",
        "...\n",
        "7. Domingo"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b4uk8aSFSZ_P",
        "outputId": "3684d8aa-f0b4-4c7a-b6b3-5d0eb3b7cc1a"
      },
      "source": [
        "numero = int(input(\"Dame un valor del 1 al 7\"))\n",
        "if numero == 1:\n",
        "    print(\"Es lunes\")\n",
        "elif numero == 2:\n",
        "    print(\"Es Martes\")\n",
        "elif numero == 3:\n",
        "    print(\"Es Miercoles\")\n",
        "elif numero == 4:\n",
        "    print(\"Es Jueves\")\n",
        "elif numero == 5:\n",
        "    print(\"Es viernes\")\n",
        "elif numero == 6:\n",
        "    print(\"Es Sabado\")\n",
        "elif numero == 7:\n",
        "    print(\"Es Domingo\")\n",
        "else:\n",
        "    print(\"el valor no es correcto debe de ser del 1 al 7\")"
      ],
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dame un valor del 1 al 71\n",
            "Es lunes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J3jhPy-hV8ZG",
        "outputId": "115115bf-eb41-43e5-bb1a-5d0acca5537a"
      },
      "source": [
        "dia = int(input(\"Ingersa un numero entre el 1 y 7\"))\n",
        "print(f\"Capturaste el numero {dia}\")\n",
        "\n",
        "if dia >=1 and dia <=7 :\n",
        "    if dia == 1:\n",
        "        print(\"Lunes\")\n",
        "    else:\n",
        "        if dia ==2:\n",
        "            print(\"Martes\")\n",
        "        else:\n",
        "            if dia ==3:\n",
        "                print(\"Miercoles\")\n",
        "            else:\n",
        "                if dia ==4:\n",
        "                    print(\"Jueves\")\n",
        "                else:\n",
        "                    if dia ==5:\n",
        "                        print(\"Viernes\")\n",
        "                    else:\n",
        "                        if dia ==6:\n",
        "                            print(\"Sabado\")\n",
        "                        else:\n",
        "                            print(\"Domingo\")                        \n",
        "else:\n",
        "    print(\"Ese numero no esta dentro del rango solicitado\")"
      ],
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingersa un numero entre el 1 y 78\n",
            "Capturaste el numero 8\n",
            "Ese numero no esta dentro del rango solicitado\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M_ludzFgZj-_"
      },
      "source": [
        "# Hacer un programa que pida dos numeros enteros y que imprima lo sig:\n",
        "\n",
        "1. Cual de ellos es el numero mayor\n",
        "2. Cual de ellos es el numero menor\n",
        " o en su defecto\n",
        "Imprimir que los valores son iguales\n",
        "\n",
        "''' Hacer un programa que solicite 3 numeros enteros diferentes entre si y \n",
        "que imprima cual de los 3 es el mayor'''\n",
        "\n",
        "''' Hacer un programa que solicite 3 numeros enteros diferentes entre si y \n",
        "que imprima cual de los 3 es el menor '''\n",
        "\n",
        "''' Hacer un programa que solicite 4 numeros enteros diferentes entre si e \n",
        "imprima a la salida cual de ellos es el menor y cual de ellos es el mayor'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LleX3Dkja-WE"
      },
      "source": [
        "# Seleccion multiple (switch)\n",
        "En Phyton no existe la estructura de seleccion switch, en su lugar se emplea la palabra reservada:\n",
        "\n",
        "## elif <condicion>\n",
        "\n",
        "Por ejemplo en el lenguaje c y Java seria de la forma:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PQHWQ7LYcve0",
        "outputId": "c2382e4a-4af8-4e36-d3a9-a0d149970f71"
      },
      "source": [
        "#EJEMPLO 2.7\n",
        "\n",
        "NUM = int(input(\"Dame un numero entre 1 y 3:\"))\n",
        "V = float(input(\"Dame un valor float:\"))\n",
        "VAL = 0\n",
        "\n",
        "if NUM == 1:\n",
        "    VAL = 100 * V\n",
        "elif NUM == 2:\n",
        "    VAL = 100 ** V\n",
        "elif NUM == 3:\n",
        "    VAL = 100/V\n",
        "else:\n",
        "    VAL = 0\n",
        "print(VAL)"
      ],
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dame un numero entre 1 y 3:1\n",
            "Dame un valor float:5\n",
            "500.0\n"
          ]
        }
      ]
    }
  ]
}