Introduccion_Python_20212.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Introduccion.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/GustavoElizarraras/DSC-Python/blob/master/Introduccion_Python_20212.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WWq7hwQUfyy1"
      },
      "source": [
        "# Python 1\n",
        "## Introducción a Python con Google Colaboratory"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vvJMgJ0N3wa4"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KcKiC7grZZu_"
      },
      "source": [
        "<img src='https://upload.wikimedia.org/wikipedia/commons/thumb/0/0a/Python.svg/1200px-Python.svg.png' alt='python-logo' height='200' width='200'></img>\n",
        "<p style='text-align: justify'>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DvSHq_-TfyzC"
      },
      "source": [
        "Instalación de los programas, y algunas recomendaciones\n",
        "https://www.anaconda.com/products/individual"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b1Bb9X96fyzD"
      },
      "source": [
        "¿Por qué Pyhton?\n",
        "Python es un lenguaje de programación de propósito general muy poderoso y flexible, a la vez que sencillo y fácil de aprender. Es un lenguaje de alto nivel, que permite procesar fácilmente todo tipo de estructuras de datos, tanto numéricos como de texto."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RYe7aUXlfyzE"
      },
      "source": [
        "## 1.Variables\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jqzpns8fpIpY"
      },
      "source": [
        "### 1.1 Tipo de datos"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uCwUt_MAfyzF"
      },
      "source": [
        "#Escribamos algunos datos\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zCFTYIn2fyzG"
      },
      "source": [
        "#Mostremos los datos"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yJ4U1dixfyzI"
      },
      "source": [
        "#¿Qué tipo de dato es?"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bHCqiXptfyzI"
      },
      "source": [
        "#Todos escriban Hola mundo y su nombre y guardenlo en una variable\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NBn1-GoT9BMF"
      },
      "source": [
        "### 1.2 Operaciones"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eMCW6Y8H_Fcp"
      },
      "source": [
        "Las cuatro operaciones aritméticas básicas son la suma (+), la resta (-), la multiplicación (*) y la división (/)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OJksTNm-DcGq"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lgK3XPUkDcVr"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yzHAP7fEDciR"
      },
      "source": [
        "División entera (//)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ftKictCyDgNv"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZExRvGovZ4eg"
      },
      "source": [
        "<h3>Exponente</h3>\n",
        "    <p>Dependiendo de que tipo de dato estemos ocupando el operador exponente se comportara diferente forma\n",
        "    <br>Ejemplo: \n",
        "    <br>- 2 enteros\n",
        "    <br>- 2 float\n",
        "    <br>- 2 booleano\n",
        "    <br>- 2 cadenas de caracteres\n",
        "    <br>- Multiplicar cadenas por un entero\n",
        "    <br>- Notación científica\n",
        "</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wQ6tv5G0Z7ld"
      },
      "source": [
        "#Con 2 enteros \n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yr473i0gaErD"
      },
      "source": [
        "#Con 2 float \n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1J_7iUxqaE58"
      },
      "source": [
        "#También podemos tener expresiones como 40X10^4 para ahorrarnos escriir los ceros\n",
        "#Esto se puede hacer poniendo la letra E/e seguida de un numero que representa el exponente.\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3ri0cCyEaFE9"
      },
      "source": [
        "#Con 2 Booleanos, observemos que pasa\n",
        "\n",
        "#Recordemos que 0 a la 0 es 1, pero 0 a la 1, es 0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qub9z-NeBRV7"
      },
      "source": [
        "#raices"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oWFFUy7sD3tm"
      },
      "source": [
        "#Raiz cuadrada "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iMxToG2lxSse"
      },
      "source": [
        "<h3>Modulo</h3>\n",
        "<p>Cuando hacemos la division exacta no tenemos en cuenta el residuo ,la operacion mudulo lo unico que no regresa es ese residuo por ejemplo en la division 10 / 3 el '3' cabe '3' en el 10 y sobra '1' , la operacion division entera nos regresara el '3' y el modulo nos regresara el '1'</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EhNqa0umyCQ8"
      },
      "source": [
        "10 % 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vY2cdWyh0nEL"
      },
      "source": [
        "<h3>Operadores logicos </h3>\n",
        "<p>Son los distintos tipos de operadores con los que puede trabajar con valores booleanos, sigue las reglas del algebra de Boole</p>\n",
        "<ul>\n",
        "<li>Operador AND: Se puede declarar de dos maneras, escribiendo 'and' o '&&'</li>\n",
        "<li>Operador OR: Se puede declarar de dos maneras, escribiendo 'or' o '|'</li>\n",
        "<li>Operador NOT: Se declara escribiendo \"not\"</li>\n",
        "</ul>\n",
        "<p>Nota: No incluir las comillas, estarias trabajando con una cadena, no con el operador</p>\n",
        "<center>\n",
        "<img src = 'https://image.slidesharecdn.com/circuitoscombinatoriosyalgebrabooleanaa-140217091808-phpapp01/95/circuitos-combinatorios-y-algebra-booleana-11-638.jpg?cb=1392628712'\n",
        "alt = 'DSC' height = '350' width = '550'>\n",
        "</center>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GFHD8Bpn0mdc"
      },
      "source": [
        "#Con expresiones booleanas, se cumple la compuerta AND\n",
        "\n",
        "#Notosé que no imprime 1's y 0's como en la multiplicación"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lJaC7r8g0YCK"
      },
      "source": [
        "#Compuerta OR\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5mmQEhJZfyzM"
      },
      "source": [
        "a=12\n",
        "b=5\n",
        "a>b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KNaQkhiKfyzN"
      },
      "source": [
        "#¡Que pasa si sumamos dos valor de tipo cadena"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w2m6CZZOfyzO"
      },
      "source": [
        "#Cómo podemos ver un dato específuco de una cadena"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vv3nAPDXfyzQ"
      },
      "source": [
        "#Vamos a definir una variable de tipo string "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ImdvSuhafyzQ"
      },
      "source": [
        "#Como ver varios datos de una cadena\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cTP_Oj8qfyzS"
      },
      "source": [
        "### 1.3 Palabras reservadas\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DkWFxE8MfyzS"
      },
      "source": [
        "Existen ciertas palabras que tienen significado especial para el intérprete de Python. Estas no pueden utilizarse para ningún otro fin"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UPYAt-MKfyzS"
      },
      "source": [
        "Algunas de ellas son: \n",
        "\n",
        "and\n",
        "as\n",
        "assert\n",
        "break\n",
        "class\n",
        "continue\n",
        "if\n",
        "elif\n",
        "else\n",
        "except"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8gUejMwHfyzT"
      },
      "source": [
        "Para verificar si una palabra esta reservada utilizando el módulo integrado keyword"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1uM4HSL6fyzT"
      },
      "source": [
        "import keyword\n",
        "keyword.iskeyword('as')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4DlFFHT6fyzT"
      },
      "source": [
        "Para obtener una lista de todas las palabras reservadas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gcp5aS2RfyzT"
      },
      "source": [
        "#keyword.kwlist"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XdfzsMIkfyzT"
      },
      "source": [
        "Python tiene varios tipos de datos "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B4I2Nq-zfyzU"
      },
      "source": [
        "int\t        entero\n",
        "long\t    entero long\n",
        "float\t    flotante\n",
        "complex  \tcomplejo\n",
        "bool\t    booleano\n",
        "str\t        cadena de caracteres\n",
        "unicode\t    cadena de caracteres Unicode\n",
        "tuple\t    tupla\n",
        "xrange\t    rango inmutable\n",
        "list\t    lista\n",
        "range\t    rango mutable\n",
        "dict\t    diccionario\n",
        "set\t        conjunto mutable\n",
        "frozenset\tconjunto inmutable"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rI53UzlWfyzg"
      },
      "source": [
        "palabra=\"python\"\n",
        "palabra[1:3]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rrgfm_QWfyzg"
      },
      "source": [
        "#Vaer datos al revés\n",
        "palabra=\"python\"\n",
        "palabra[-1::-1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wPJz2V_7fyzg"
      },
      "source": [
        "palabra=\"N\"+palabra[1:]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AUWDmGaWfyzh"
      },
      "source": [
        "print(palabra)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rxvVL9-PBCrl"
      },
      "source": [
        "## 2.Estructura de datos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6gZNAE6sBstT"
      },
      "source": [
        "### 2.1 Tuplas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G2cNFtXyBxTA"
      },
      "source": [
        " Una tupla es un conjunto ordenado e inmutable de elementos del mismo o diferente tipo.\n",
        "\n",
        "Las tuplas se representan escribiendo los elementos entre paréntesis y separados por comas."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r21f9FxcDFqn"
      },
      "source": [
        "#Definimos una tupla de n numeros"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TZ4DlbOklkmA"
      },
      "source": [
        "#Definimos una tupla sin parentesis"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yjV29bmkHw3d"
      },
      "source": [
        "#Mostramos un dato especifico especifico de una tupla"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2UbM-be-IDF3"
      },
      "source": [
        "Todas las secuencias en Python comienzan a numerarse desde 0"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5oWYIhV6pTPa"
      },
      "source": [
        "len(T)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vopcKXNFKPLj"
      },
      "source": [
        "#Todos escriban una tupla de 4 elementos!"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y07Izk_YCHU-"
      },
      "source": [
        "Puede haber una tupla con elementos vacios, pero debe separarse con comas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oguRuihrFMux"
      },
      "source": [
        "numeros = (5,4,3,2,1,6,45,3,6,6,6,6,6)\n",
        " \n",
        "numero = int(input(\"Dame un numero: \"))\n",
        " \n",
        "contador= 0\n",
        "for i in numeros:\n",
        "    if numero == i:\n",
        "        contador += 1\n",
        " \n",
        "print (\"Hay \",contador,\" repeticion/es\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NnrvsC4HIZsj"
      },
      "source": [
        "### 2.2 Listas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fqw9N5OlJmi5"
      },
      "source": [
        "Una lista es un arreglo de elementos donde podemos ingresar cualquier tipo de dato,Una lista es un arreglo de elementos donde podemos ingresar cualquier tipo de dato."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CYwp3MjaIiDy"
      },
      "source": [
        "#Creamos una nueva lista con diversos tipos de datos.\n",
        "lista = [1, 2.5, 'UPIITA', [5,6], 4]\n",
        "lista"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MnmJzwxBRIcj"
      },
      "source": [
        "# Utilizamos el método extend para concatenar dos listas.\n",
        "lista.extend([4, 7, \"x\"])\n",
        "lista"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AM4BRVzZP609"
      },
      "source": [
        "# Utilizamos el método remove para eliminar de la lista el elemento numero 7\n",
        "lista.remove(7)\n",
        "lista"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "37pA_OlRRlcY"
      },
      "source": [
        "# Utilizaremos el mismo método para remover el string upiita\n",
        "# Es importante señalar que se hacen dos cosas se busca el elemento y se elimina\n",
        "lista.remove(\"UPIITA\")\n",
        "lista"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "43b-COl1T8LT"
      },
      "source": [
        "# El método index busca el elemento y te retorna su posicion\n",
        "lista.index(\"x\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "55b5W237UyP6"
      },
      "source": [
        "# Cuenta \n",
        "lista.count(4)\n",
        "lista"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "yx8R-Nt_x6L4"
      },
      "source": [
        "a = 'abc'\n",
        "a[0:2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fg9MFQJ1ooQd"
      },
      "source": [
        "# [] hace refererencia a una lista vacia que es un objeto que agregamos a la lista\n",
        "num2=[6, 6, 17]\n",
        "num2[1]=[]  #Lista vacia\n",
        "num2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eTDFOKfbpvp4"
      },
      "source": [
        "len(num2) # len obtiene el  tamaño del axis 0 de un array"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mTN7zEa9p3-v"
      },
      "source": [
        "a=[1,2,3]\n",
        "b=[4,5,6]\n",
        "c=[7,8,9]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6MSObTLEp9jw"
      },
      "source": [
        "# Generamos listas de listas\n",
        "r=[a,b,c]\n",
        "r"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3PuIHyIAp-Qb"
      },
      "source": [
        "r[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3sOhCOE5IfRA"
      },
      "source": [
        "### 2.3 Diccionarios"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gz8o7ho4Vou0"
      },
      "source": [
        "El diccionario, define una relación uno a uno entre claves y valores."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K6wty2YAIncd"
      },
      "source": [
        "{'python': 27, 'plone': 51}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kq0a3H_uVxfk"
      },
      "source": [
        "Diccionario={\n",
        "    \"k1\":4,\n",
        "    \"k2\":True,\n",
        "    \"k3\":\"Valor 1\",\n",
        "    \"k4\":[1,2,3,4]\n",
        "    }"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "538CJARmWQDG"
      },
      "source": [
        "Diccionario['k3']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J2o1Dw7UW6zP"
      },
      "source": [
        "Un diccionario puede almacenar los diversos tipos de datos integrados en Python"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CeTkSUf0WnzW"
      },
      "source": [
        "type(Diccionario['k2'])\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Miynctk2X04a"
      },
      "source": [
        "dict(Etiqueta1=2.7, Etiqueta2=2.13, Etiqueta3=5.1, Etiqueta4=2.1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nVxWK58dYAaS"
      },
      "source": [
        "Dic=dict(Etiqueta1=2.7, Etiqueta2=2.13, Etiqueta3=5.1, Etiqueta4=2.1)\n",
        "\"Etiqueta1\" in Dic"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BxwsBHEHYU27"
      },
      "source": [
        "'Etiqueta4' in Dic"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VLmwm6HDY8tD"
      },
      "source": [
        "Dic.get('Etiqueta3')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J-z-v56nZMHe"
      },
      "source": [
        "Dic.items()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m9yK-ZR6pHgL"
      },
      "source": [
        "## 3 Funciones"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4zsaxRKvr3-M"
      },
      "source": [
        "###  3.1 Indentación\n",
        "\n",
        "Primero hablemos un poco de la indentación de código, este es\n",
        "el hecho de utilizar sangrado (mover ligeramente hacia la derecha) en las líneas de código para facilitar la lectura, e indicar visualmente si nos encontramos en el interior de una función, bucle, condicional, etc. Por ejemplo, ¿cuál de las siguientes dos celdas de código se ve más entendible?\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fPX9NAZIyYVF"
      },
      "source": [
        "\"\"\"\n",
        "function bucle() { for (i = 0; i < 10; i++) {\n",
        "  console.log(\"Iteración #\", i);\n",
        "  if (i == 9) console.log(\"Estoy en la última iteración\"); }\n",
        "}\n",
        "\"\"\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "47O-Q3-syyHG"
      },
      "source": [
        "\"\"\"\n",
        "function bucle() {\n",
        "  for (i = 0; i < 10; i++) {\n",
        "    console.log(\"Iteración #\", i);\n",
        "\n",
        "    if (i == 9) {\n",
        "      console.log(\"Estoy en la última iteración\");\n",
        "    } // if\n",
        "  } // for\n",
        "} // function\n",
        "\"\"\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9gkBUxUZOKCQ"
      },
      "source": [
        "¿Notaron la indentación? Bueno, Python obliga a indentar el código, es parte de su sintaxis."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LmgOF4JjF9LG"
      },
      "source": [
        "for i in range(10):\n",
        "  print(\"Todavía no\")\n",
        "  if i == 9:\n",
        "    print(\"Estoy en la última iteración\")\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K0JtR7h-ykSL"
      },
      "source": [
        "<h2>4.Funciones</h2>\n",
        "<p>\n",
        "Es un bloque de codigo reutilizable el cual puede recibir variables de entrada y devuelve algún valor procesado o realiza alguna operación (por ejemplo, puede imprimir un valor, pero no regresar un valor)<br>\n",
        "Su sintaxis es la siguiente:<br><br>\n",
        "def nombre_funcion(argumentos de entrada):<br>\n",
        "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;....<br>\n",
        "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;....<br>\n",
        "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;....<br>\n",
        "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return valor/es_procesados #Opcional\n",
        "</p>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "68FAOVj4r3lY"
      },
      "source": [
        "# Declaramos las funciones de suma y multiplicación\n",
        "def suma(a,b):\n",
        "    return a + b\n",
        "def multiplicación(a,b):\n",
        "    return a * b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0NDyC7qjvZbW"
      },
      "source": [
        "<h3>Poniendo en práctica variables y funciones</h3>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sZAPc425zzwc"
      },
      "source": [
        "# Guardemos el resultado de una función en una variable.\n",
        "resultado1 = suma(1, 2)\n",
        "resultado2 = multiplicación(3, 4)\n",
        "print(resultado1)\n",
        "print(resultado2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eqlnzBhg0qGU"
      },
      "source": [
        "### 3.2 \"Funciones\" útiles\n",
        "Conforme vamos adquiriendo más experiencia programando, nos vamos a dar cuenta que hay funciones ya implementadas que utilizamos más que otras. Vamos a dar unos ejemplos:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "icrQtufT1TQL"
      },
      "source": [
        "#Creamos una nueva lista\n",
        "l = [3,40,22,-2]\n",
        "# Encontrar el valor máximo de una estructura iterable\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oCYss_dQ1leO"
      },
      "source": [
        "# Encontrar el valor mínimo de una estructura iterable\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZImeMvG41mLy"
      },
      "source": [
        "# Las función find() sirve para encontrar alguna subcadena dentro de una cadena.\n",
        "# Devuelve el índice de la cadena en donde se encuentre por primera vez, si no se encuentra, devuelve -1.\n",
        "s = 'Hola, estudio en UPIITA'\n",
        "s.find('UPIITA')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YXCFIYBlKIRv"
      },
      "source": [
        "#La función sort() ordena los valores del ascendentemente\n",
        "#En este caso ordena los numeros de menor a mayor\n",
        "numeros = [16, 4, 9, 1, 3, 20, 8]\n",
        "numeros.sort()\n",
        "numeros\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IoYigzErKaSf"
      },
      "source": [
        "#La función sort() ordena los valores del ascendentemente\n",
        "#En este caso ordena las cadenas en orden alfabético\n",
        "palabras = [\"hola\", \"coche\", \"avión\", \"manzana\", \"perro\", \"gato\"]\n",
        "palabras.sort()\n",
        "palabras"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7KWPtXB3LKTo"
      },
      "source": [
        "#Se declara un dato tipo range\n",
        "x = range(10)\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PfBZa2R5LNkc"
      },
      "source": [
        "#Tomando x, se hace una lista con los valores del dato range\n",
        "list(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CO-BFcBGLUVp"
      },
      "source": [
        "#Se hace una lista con el intervalo 1-11\n",
        "list(range(1, 11))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ygQrpz3CL_z9"
      },
      "source": [
        "#Toma dos listas con datos iterables, las itera a la par, y las guarda en una nueva lista\n",
        "#En cada uno de los elementos, se almacenarán los dos datos de cada lista correspondiente a la iteración\n",
        "Carreras = [\"Biónica\", \"Telemática\", \"Mecatrónica\", \"Energía\"]\n",
        "numeros= [11, 13, 7, 4]\n",
        "list(zip(Carreras , numeros))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i26PFcWXOsQn"
      },
      "source": [
        "#Toma tres listascon datos iterables, las itera a la par, y las guarda en una nueva lista\n",
        "#En cada uno de los elementos, se almacenarán los tres datos de cada lista correspondiente a la iteración\n",
        "a = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
        "b = [1, 2, 3, 4, 5]\n",
        "c = ['x', 'u', 't', 4, 5]\n",
        "list(zip(a, b,c))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GuI1h_SK3cdH"
      },
      "source": [
        "map(function, iterable, ...)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iCwXfUpuOVOs"
      },
      "source": [
        "def duplicar(numero):\n",
        "    return numero*2\n",
        "\n",
        "numeros = [2, 5, 10, 23, 50, 33]\n",
        "\n",
        "list(map(duplicar, numeros))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1EBcmc0LY2id"
      },
      "source": [
        "## 4.Ciclos de control\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PstOIIgWZH-z"
      },
      "source": [
        "### 4.1 If - elif - else\n",
        "La sentencia condicional if se usa para tomar decisiones, este evaluá básicamente una operación lógica"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KlzY4WEcZcKT"
      },
      "source": [
        "#Comparamos la suma de 2+2 con el valor de 4. Si se cumple, se imprime el mensaje, caso contrario no.\n",
        "a = 2 + 2\n",
        "if a == 4: #condicion si a es igual a cuatro, entonces\n",
        "    print (\"A es igual a cuatro\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gcY1ugmGD9B-"
      },
      "source": [
        "#Se solicita a un usuario un string, se compara con la cadena \"manzana\" . \n",
        "#Se compara la cade con el if, si se cumple la condición se desplega el mensaje 'Iniciando sesión', si no se cumpla, pasa al caso else imprimiendo el mensaje correspondiente.\n",
        "pwd = str(input('Contraseña: '))\n",
        "if pwd == 'manzana':\n",
        "    print('Iniciando sesión ...')\n",
        "else:\n",
        "    print('Contraseña incorrecta.')\n",
        "\n",
        "print('¡Todo terminado!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SG8ihy9Ga4q6"
      },
      "source": [
        "#Comparamos el valor de a con el entero 4. Si ambos son cuatro, se imprime \"a es igual a cuatro\", de lo contrario \"a es diferente\"\n",
        "a=1\n",
        "if a == 4: #condicion si a es igual a cuatro, entonces\n",
        "    print (\"a es igual a cuatro\")\n",
        "else:\n",
        "    print (\"a es diferente\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PF5XtjTZqeuJ"
      },
      "source": [
        "#Se pregunta la edad al usuario, dependiendo del rango en el que esté, se anuncia el tipo de tarifa\n",
        "edad = int(input('¿Qué edad tiene usted? '))\n",
        "if edad <= 2:\n",
        "    print(' gratis')\n",
        "elif 2 < edad < 13:\n",
        "    print(' tarifa de niño')\n",
        "else:\n",
        "    print('tarifa para adultos')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zHNgkQoZbdXk"
      },
      "source": [
        "#Se compara la suma a, con los enteros del 4 al 7. Si la suma es igual a alguno de estos valores o no, se imprime el mensaje correspondiente. \n",
        "a = 4 + 3\n",
        "if a == 4: #condicion si a es exactamente cuatro, entonces(:)\n",
        "    print (\"a es igual a cuatro\") # Imprimir\n",
        "elif a == 5:\n",
        "    print (\"a es igual a cinco\")\n",
        "elif a == 6:\n",
        "    print (\"a es igual a seis\")\n",
        "elif a == 7:\n",
        "    print (\"a es igual a siete\")\n",
        "else:\n",
        "    print (\"No se cumple la condición\")\n",
        "(shift + atl + flecha)\n",
        "elif a = =5\n",
        "elif a == 8\n",
        "elif a = 6"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rds4WLlIZPJC"
      },
      "source": [
        "### 4.2 For"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LAgNrQo5deNF"
      },
      "source": [
        "#Se crea un ciclo con 10 iteraciones, en cada iteración se le sumará 1, y se imprimirá el valor.\n",
        "a = 0\n",
        "for i in range(10):\n",
        "  a += 1\n",
        "  print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "24f0AntgxqvX"
      },
      "source": [
        "'a'*3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AJlnJ83Wc_T_"
      },
      "source": [
        "#Con un ciclo for, se recorre toda la lista, buscando el valor de 3. Se desplega el mensaje correspondiente si está el valor o no.\n",
        "numeros = [1, 2, 4, 3, 5, 8, 6]\n",
        "for n in numeros:\n",
        "    if n == 3:\n",
        "      print('tiene un 3')\n",
        "      break   \n",
        "else:\n",
        "    print('No se encontró el número 3')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1vy2CmM2q0rF"
      },
      "source": [
        "#Se declara un diccionario, para desplegar la llave y su valor con ayuda de un ciclo for. \n",
        "otro_diccionario = {\n",
        "    'Nombre' : 'Axel',\n",
        "    'Edad' : 22,\n",
        "    'Escuela' : 'UPIITA'\n",
        "}\n",
        "for llave in otro_diccionario:\n",
        "  print(f'{llave} : {otro_diccionario[llave]}')\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uEXXmtqLZVXe"
      },
      "source": [
        "### 4.3 While"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WJM5nbIblfgM"
      },
      "source": [
        "Un bucle while permite repetir la ejecución de un grupo de instrucciones mientras se cumpla una condición (es decir, mientras la condición tenga el valor True)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LRGvSGYklgu4"
      },
      "source": [
        "#Con un ciclo while, se imprimen todos los enteros entre el uno y el tres\n",
        "i = 1\n",
        "while i <= 3:\n",
        "    print(i)\n",
        "    i += 1\n",
        "print(\"Programa terminado\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qnpiBX3nmL5R"
      },
      "source": [
        "\n",
        "i = 1\n",
        "while i <= 50:\n",
        "    print(i)\n",
        "    i = 3 * i + 1\n",
        "print(\"Programa terminado\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "noOKvcJeflbT"
      },
      "source": [
        "## 5.Ejercicios"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3UFKf54Cgd5m"
      },
      "source": [
        "Un algoritmo resuelve cualquier problema a través de unas instrucciones y reglas concisas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WZfpzHtNe6Cb"
      },
      "source": [
        "import math\n",
        "print(\"Ingrese el radio\")\n",
        "r=float(input())\n",
        "a=math.pi*r**2\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Gn8__tXcfuC"
      },
      "source": [
        "# coleccion = [2, 4, 5, 7, 8, 9, 3, 4]\n",
        "# for e in coleccion:\n",
        "#     if e % 2 != 0:\n",
        "#         continue\n",
        "#     print(e)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gjOBz5AbPKb3"
      },
      "source": [
        "# 6 Pasos a seguir"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ijn4w5KZGkfz"
      },
      "source": [
        "Documentación: https://docs.python.org/3/ \\\n",
        "\n",
        "Para profundizar Python:  https://www.py4e.com/\n",
        "\n",
        "Sí te interesa Backend, puedes visitar esta página:\n",
        "https://www.dj4e.com/\n",
        "\n",
        "\n",
        "Sí te interesa ML puedes ver la siguiente lista de reproducción: \\\n",
        "https://www.youtube.com/watch?v=jGwO_UgTS7I&list=PLoROMvodv4rMiGQp3WXShtMGgzqpfVfbU"
      ]
    }
  ]
}