Introduccion_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "T0hkIiNQAY92"
   },
   "source": [
    "# Introducción a Python 🐍 💻\n",
    "Temas a Tratar:\n",
    "\n",
    "✅ Variables y tipos de datos\n",
    "\n",
    "✅ Operadores basicos\n",
    "\n",
    "✅ Condicionales\n",
    "\n",
    "✅ Ciclos o Bucles\n",
    "\n",
    "✅ Listas y diccionarios\n",
    "\n",
    "✅ Funciones\n",
    "\n",
    "✅ Clases y objetos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hola mundo 😊"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola mundo!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hola mundo!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bfCE_EoZXXwU"
   },
   "source": [
    "# Variables y tipos de datos\n",
    "Las variables son elementos en los cuales guardamos información. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "dGSLVRKjZPNR"
   },
   "outputs": [],
   "source": [
    "mi_nombre = 'Ana'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "e-3QCNS1ZRY9"
   },
   "outputs": [],
   "source": [
    "saludo = 'Hola!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IbNjcYdwZY4C"
   },
   "source": [
    "Para mostrar el valor que se encuentra dentro de las variables podemos llamar la funcion **print()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana\n"
     ]
    }
   ],
   "source": [
    "print(mi_nombre)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "DFNUHgWFZgCl",
    "outputId": "9ab74cab-9766-4f9c-ddd8-83b35622d0e1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola!\n"
     ]
    }
   ],
   "source": [
    "print(saludo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "P8jzRtGDZjoA"
   },
   "source": [
    "En Python se manejan diferentes tipos de datos, entre ellos los siguientes:\n",
    "\n",
    "* **Int:** Representación de los números enteros.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "Ce_k0As8ZhJH",
    "outputId": "697193c1-2aed-4209-da95-471bbff39349"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "entero = 9\n",
    "print(entero, type(entero))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HUBA5hcqaA5V"
   },
   "source": [
    "\n",
    "*   **Float:** Representación de los números decimales.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "x7ad8m5XZ9-_",
    "outputId": "d6dc510c-9547-4872-8b7d-08e89a23f48a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "flotante = 1.5\n",
    "print(flotante, type(flotante))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MySWRJh4aS_z"
   },
   "source": [
    "* **String**: Representación de las cadenas.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "4TSrdstHabRZ",
    "outputId": "29fa45a5-a60c-4e02-90db-d35b5513a41d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola Mundo! <class 'str'>\n",
      "Ejemplo Cadena <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "cadena = 'Hola Mundo!'\n",
    "cadena1 = \"Ejemplo Cadena\"\n",
    "print(cadena, type(cadena))\n",
    "print(cadena1, type(cadena1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GTbzaKEGbF0P"
   },
   "source": [
    "* **Bool:** Representación de valores booleanos (True, False). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "bFZ-h_wZao97",
    "outputId": "149db580-fa24-49ae-ed04-c9f74dd7f769",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "booleano = True\n",
    "print(booleano, type(booleano))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dsvWa0K4b3xb"
   },
   "source": [
    "# Operadores Básicos\n",
    "Un operador es un símbolo del lenguaje de programación, el cual es capaz de realizar operaciones con los valores. Python tiene operaciones básicas como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "9PxwBSkpbXds",
    "outputId": "9b1c4dd6-3cff-4b87-e373-dd45ca32c8f7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# Suma\n",
    "a = 2 + 3\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "iKFGMzFlckIy",
    "outputId": "4ce3633a-d0c1-41e6-e65f-22dee8ea347c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# Resta\n",
    "b = 5 - 3\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "uQNmrkbCcu0I",
    "outputId": "1d5dd6cb-8891-4a3f-bb29-6c43d53a21d6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n"
     ]
    }
   ],
   "source": [
    "# Multiplicación\n",
    "c = 6 * 3\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "N3e-agPuc0nu",
    "outputId": "4db7d47f-4917-4023-e895-1e4c578d1cdb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n"
     ]
    }
   ],
   "source": [
    "# División\n",
    "d = 12 / 4\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "w6ED_kJDc6Yd",
    "outputId": "79b722d9-8dcf-4b22-b112-3dd04e85a255"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# División entera\n",
    "e = 12 // 4\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "Wq6Y7P2NdA5B",
    "outputId": "4bc3ccf7-8596-44fb-f84a-b6df6fd88981"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "# Potencia\n",
    "f = 2 ** 3\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "2UTGPou3dK_I",
    "outputId": "70bb6028-62c1-4b1b-981e-5cfba0237bdc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "# Módulo (Lo que queda de la división entera)\n",
    "g = 10 % 3\n",
    "print(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PU2vuJqUeDm2"
   },
   "source": [
    "**Operadores Abreviados**: Cuando se quiere utilizar una misma variable al lado derecho e izquierdo de un operador, podemos reducir el codigo de la siguiente manera:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "nnHxPZtWdQI1",
    "outputId": "ec363a63-afc4-418d-c6ad-1d4f42e8fcf9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "a = a + 1\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "WQkPQbAdeaQU",
    "outputId": "dd8a937d-6e58-4dd5-aff5-586d735d687c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "# De una manera mas corta\n",
    "a = 5\n",
    "a += 1\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BkTpz3MCgRXE"
   },
   "source": [
    "# Operadores Relacionales\n",
    "* **Igualdad:** Compara si dos elementos son iguales ( == ).\n",
    "* **Desigualdad:** Comprar si un valor es diferente a otro (!= ).\n",
    "* **Mayor que:** Compara si un valor es mayor que otro ( > ).\n",
    "* **Menor que:** Compara si un valor es menor que otro ( < ).\n",
    "* **Mayor o igual que:** Compara si un valor es mayor o igual a otro ( >= ).\n",
    "* **Menor o igual que:** Comprara si un valor es menor o igual que otro ( <= ).\n",
    "\n",
    "**Ejemplos:**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "jRNSKV26f4Ep",
    "outputId": "7b91b1eb-ac48-4382-9b27-2b6bbe57ccee"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 20,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 == 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "gBAsuALOBqVC",
    "outputId": "17f6b4e3-9a7f-4cbf-d06e-a4f2b5112ee9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "49H13CGGBufe",
    "outputId": "0b218e5b-c130-400b-9fea-ec984a53425b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 >= 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 < 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 != 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "o3o3MEh7Bwph",
    "outputId": "29bae3bd-94f2-4fef-acf5-25a94895565e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 != '4'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operadores Lógicos\n",
    "\n",
    "✅ **and:** Todas las comparaciones son verdaderas\n",
    "✅ **or:** Por lo menos una comparación es verdadera.\n",
    "✅ **not:** Intercambia el valor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 > 4 and 3 > 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 > 4 and 3 < 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 > 4 or 3 < 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 < 4 or 3 < 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not 4 > 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ⌨️ Entrada de datos por teclado\n",
    "Obtener los valores a partir de lo que ingresa el usuario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cuál es tu nombre?\n",
      "Ana\n",
      "Mi nombre es:  Ana\n"
     ]
    }
   ],
   "source": [
    "print(\"Cuál es tu nombre?\")\n",
    "nombre = input()\n",
    "print(\"Mi nombre es: \", nombre)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cuál es tu edad?\n",
      "23\n",
      "<class 'str'>\n",
      "Mi edad es:  23\n"
     ]
    }
   ],
   "source": [
    "print(\"Cuál es tu edad?\")\n",
    "edad = input()\n",
    "print(type(edad))\n",
    "print(\"Mi edad es: \", edad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cuál es tu edad?\n",
      "23\n",
      "<class 'int'>\n",
      "Mi edad es:  23\n"
     ]
    }
   ],
   "source": [
    "print(\"Cuál es tu edad?\")\n",
    "edad = int(input())\n",
    "print(type(edad))\n",
    "print(\"Mi edad es: \", edad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cuál es tu edad?23\n",
      "Mi edad es:  23\n"
     ]
    }
   ],
   "source": [
    "edad = int(input(\"Cuál es tu edad?\"))\n",
    "print(\"Mi edad es: \", edad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cuál es tu edad? \n",
      "23\n",
      "Mi edad es:  23\n"
     ]
    }
   ],
   "source": [
    "edad = int(input(\"Cuál es tu edad?\\n\"))\n",
    "print(\"Mi edad es: \", edad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "12H1dMc9CTxJ"
   },
   "source": [
    "# Condicionales\n",
    "Los condicionales nos permiten validar si una sentencia es verdadera o no, y deacuerdo al resultado realizar mas instrucciones. Tienen la siguiente estructura:\n",
    "\n",
    "```\n",
    "if sentencia:\n",
    "  # instrucciones a realizar si la sentencia es verdadera\n",
    "else:\n",
    "  # instrucciones a realizar si la sentencia es falsa\n",
    "```\n",
    "\n",
    "**Ejemplos:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "bwL4Tv-zB0QJ",
    "outputId": "4f084a61-e318-408a-dbc1-457b90b33b52"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cuál es tu edad?\n",
      "18\n",
      "Eres mayor de edad\n"
     ]
    }
   ],
   "source": [
    "edad = int(input(\"Cuál es tu edad?\\n\"))\n",
    "if edad >= 18:\n",
    "  print('Eres mayor de edad')\n",
    "else:\n",
    "  print('Eres menor de edad')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XAhRN6IxEFPL"
   },
   "source": [
    "Tambien se pueden enlazar diferentes sentencias por medio de los operadores lógicos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "2svFobTTDmPe",
    "outputId": "25563fe1-a223-44dd-996c-185e617acf54"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cuál es tu apellido?\n",
      "GOMEZ\n",
      "Hola prim@!\n"
     ]
    }
   ],
   "source": [
    "apellido = input(\"Cuál es tu apellido?\\n\")\n",
    "if apellido.lower() == 'gomez' or apellido.lower() == 'trejos':\n",
    "  print('Hola prim@!')\n",
    "else:\n",
    "  print('Hola!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cuál es tu edad?\n",
      "12\n",
      "Eres un niño\n"
     ]
    }
   ],
   "source": [
    "edad = int(input(\"Cuál es tu edad?\\n\"))\n",
    "\n",
    "if edad >= 18:\n",
    "    print(\"Eres mayor de edad\")\n",
    "elif edad >= 13 and edad < 18:\n",
    "    print(\"Eres un adolescente\")\n",
    "else:\n",
    "    print(\"Eres un niño\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Oo643n-2FoXG"
   },
   "source": [
    "# Ciclos o bucles\n",
    "Un ciclo es una instrucción que se ejecuta tantas veces como se cumpla una condición:\n",
    "## While\n",
    "El ciclo while tiene la siguiente estructura:\n",
    "```\n",
    "while expresión_condicional:\n",
    "  instrucción\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 72
    },
    "colab_type": "code",
    "id": "Sv5GJ1_oE2CV",
    "outputId": "8aee3dae-8edb-46ba-dcc0-54b22625dcc0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "while a > 0:\n",
    "  print(a)\n",
    "  a -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Emry1hMIHedB"
   },
   "source": [
    "## For\n",
    "El ciclo for tiene la siguiente estructura:\n",
    "```\n",
    "for expresión_condicional:\n",
    "  instrucción\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 201
    },
    "colab_type": "code",
    "id": "nlhf_CwuGjVI",
    "outputId": "da051457-0a0e-43bd-f28e-d3a7649b5dea"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Aky7RMGoJYT0"
   },
   "source": [
    "## Las declaraciones break y continue\n",
    "\n",
    "**Break:** Sale del ciclo inmediatamente, e incondicionalmente termina la operación del ciclo.\n",
    "\n",
    "**Continue:** Pasa a la siguiente iteración del ciclo.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 219
    },
    "colab_type": "code",
    "id": "fiPfzxuKH8wC",
    "outputId": "f2c76e34-b563-4bcf-be01-0fa4fae3bdd0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La instrucción de ruptura:\n",
      "Dentro del ciclo. 0\n",
      "Dentro del ciclo. 1\n",
      "Fuera del ciclo.\n",
      "\n",
      "La instrucción continue:\n",
      "Dentro del ciclo. 0\n",
      "Dentro del ciclo. 1\n",
      "Dentro del ciclo. 3\n",
      "Dentro del ciclo. 4\n",
      "Fuera del ciclo.\n"
     ]
    }
   ],
   "source": [
    "#Ejemplo break\n",
    "print(\"La instrucción de ruptura:\")\n",
    "for i in range(5):\n",
    "    if i == 2:\n",
    "        break\n",
    "    print(\"Dentro del ciclo.\", i)\n",
    "print(\"Fuera del ciclo.\")\n",
    "\n",
    "# Ejemplo continue\n",
    "\n",
    "print(\"\\nLa instrucción continue:\")\n",
    "for i in range(5):\n",
    "    if i == 2:\n",
    "        continue\n",
    "    print(\"Dentro del ciclo.\", i)\n",
    "print(\"Fuera del ciclo.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UIpN8wB4L7Si"
   },
   "source": [
    "# Listas\n",
    "Las listas son muy parecidas a lo que se llama en otros lenguajes arreglos o arrays. Pueden contener cualquier tipo de variable y se pueden iterar de una manera muy simple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "qVKd4mc7Kj7a",
    "outputId": "7bc793dd-c294-4f7b-d7ec-defcf6f4c9d3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c']\n"
     ]
    }
   ],
   "source": [
    "mi_lista = []\n",
    "mi_lista.append('a')\n",
    "mi_lista.append('b')\n",
    "mi_lista.append('c')\n",
    "print(mi_lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "XlFICzxsMY4H",
    "outputId": "c226b807-2093-4299-9384-0f07f8874410"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n"
     ]
    }
   ],
   "source": [
    "print(mi_lista[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0RB43t-AM2-P"
   },
   "source": [
    "Hay varias funciones que tienen las listas por defecto como por ejemplo:\n",
    "* **len()**: Nos muestra el tamaño de la lista\n",
    "* **sort()**: Ordena una lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "BQGJetFjMaPc",
    "outputId": "c2047899-cada-4c99-b15f-826e0b0ca819"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3, 4]\n",
    "print(len(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 90
    },
    "colab_type": "code",
    "id": "Br0NfjCaNMGS",
    "outputId": "e9184758-bb8e-4929-96c9-64e81ec2a4a5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elemento: 1\n",
      "Elemento: 2\n",
      "Elemento: 3\n",
      "Elemento: 4\n"
     ]
    }
   ],
   "source": [
    "for i in a:\n",
    "  print(f'Elemento: {i}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "vxc_VzbkNSkG",
    "outputId": "f6138af2-be1c-4ce9-be5f-2ed4890bd097"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "b = [2, 5, 4, 1, 3]\n",
    "b.sort()\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GuQgrKFsNoHf"
   },
   "source": [
    "Para eliminar un elemento de una lista usamos la instruccion del:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "N0tk4-g2NXhl",
    "outputId": "4dd49cf5-8bae-4dcc-d335-f17630d622a8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "del b[4]\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wCb_o6JcOZ7u"
   },
   "source": [
    "# Diccionarios\n",
    "Los diccionarios son tipos de datos parecidos a las listas pero en vez de indices tienen atributos de llave y valor, de la siguiente manera:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "fp9W3YclNX6B",
    "outputId": "a15e956e-4225-4439-d828-391385028d94"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre': 'Carolina', 'apellido': 'Gomez'}\n"
     ]
    }
   ],
   "source": [
    "a = {'nombre': 'Carolina', 'apellido': 'Gomez'}\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "_huqi5oMOnhm",
    "outputId": "65db45f3-c798-4f0f-8d76-1afa4280766b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Carolina\n"
     ]
    }
   ],
   "source": [
    "print(a['nombre'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "-TJ3LFrgOrjw",
    "outputId": "c2f5a91a-1a39-461d-80af-7bd3a4be8f8b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre': 'Carolina', 'apellido': 'Gomez', 'edad': 24}\n"
     ]
    }
   ],
   "source": [
    "# Para agregar un nuevo valor\n",
    "a['edad'] = 24\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 72
    },
    "colab_type": "code",
    "id": "wik_l_qYO0IY",
    "outputId": "fe0db02f-0fd4-4f0d-a829-aa3b1736340e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nombre: Carolina\n",
      "apellido: Gomez\n",
      "edad: 24\n"
     ]
    }
   ],
   "source": [
    "# Iterando sobre diccionarios\n",
    "for llave, valor in a.items():\n",
    "  print(f'{llave}: {valor}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ivz9qQAlRMot"
   },
   "source": [
    "# Funciones\n",
    "cuando estamos escribiendo instrucciones en muchas ocaciones estas se repiten varias veces, por lo que las funciones nos ayudan a dividir nuestro código en porciones que nos ayudan a ordenar nuestro código y hacerlo mas entendible, ademas de que nos evita repetir porciones de código. Las funciones tienen la siguiente estructura:\n",
    "```\n",
    "def nombre_funcion(parametros):\n",
    "  instrucciones\n",
    "```\n",
    "\n",
    "**Ejemplo:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1Xzayu-CRAz_"
   },
   "outputs": [],
   "source": [
    "def suma(a, b):\n",
    "  return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "cv8U-e68TrXy",
    "outputId": "b290e687-debe-41b7-cf21-c6b269233484"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 40,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "suma(5, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "c3KRTwSjTtTS"
   },
   "outputs": [],
   "source": [
    "# Sumar los valores de una lista\n",
    "def suma_lista(lista):\n",
    "  suma_total = 0\n",
    "  for elem in lista:\n",
    "    suma_total += elem\n",
    "  return suma_total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "PdJ0iBTXUTW-",
    "outputId": "f704cf60-6dba-430d-a420-03132ee7ab4a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 42,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [1, 2, 3, 4, 5]\n",
    "suma_lista(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JkSXYvrxdzOL"
   },
   "source": [
    "# Clases y Objetos\n",
    "Un objeto es un encapsulamiento de variables y funciones. Los objetos obtienen sus variables y funciones por medio de clases. Las clases son basicamente el esqueleto de los objetos. Tienen la siguiente estructura:\n",
    "\n",
    "```\n",
    "class NombreClase:\n",
    "  variables\n",
    "\n",
    "  def nombre_funciones(self):\n",
    "    instrucciones\n",
    "```\n",
    "\n",
    "**self** es un parámetro especial que siempre se utilizará como una referencia al objeto mismo. Debe ser siempre el primer parámetro formal; no obstante, nunca se le dará un valor de parámetro real en la invocación.\n",
    "\n",
    "**Ejemplo:** Clase de Fracciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "uDbwo641Ua6x"
   },
   "outputs": [],
   "source": [
    "class Fraccion():\n",
    "  def __init__(self, numerador, denominador):\n",
    "    self.numerador = numerador\n",
    "    self.denominador = denominador\n",
    "\n",
    "  def imprimir(self):\n",
    "    print(f'{self.numerador} / {self.denominador}')\n",
    "\n",
    "  def suma(self, fraccion):\n",
    "    numerador = (self.numerador * fraccion.denominador) + (self.denominador * fraccion.numerador)\n",
    "    denominador = self.denominador * fraccion.denominador\n",
    "    return Fraccion(numerador, denominador)\n",
    "\n",
    "  def resta(self, fraccion):\n",
    "    numerador = (self.numerador * fraccion.denominador) - (self.denominador * fraccion.numerador)\n",
    "    denominador = self.denominador * fraccion.denominador\n",
    "    return Fraccion(numerador, denominador)\n",
    "\n",
    "  def multiplicacion(self, fraccion):\n",
    "    numerador = self.numerador * fraccion.numerador\n",
    "    denominador = self.denominador * fraccion.denominador\n",
    "    return Fraccion(numerador, denominador)\n",
    "  \n",
    "  def division(self, fraccion):\n",
    "    numerador = self.numerador * fraccion.denominador\n",
    "    denominador = self.denominador * fraccion.numerador\n",
    "    return Fraccion(numerador, denominador)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "nxMuTe9rjbDF",
    "outputId": "0f6435c8-4ee9-476b-b85f-4a16c63230bf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 / 2\n"
     ]
    }
   ],
   "source": [
    "fraccion1 = Fraccion(1, 2)\n",
    "fraccion1.imprimir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "Y7Z88Okkji4y",
    "outputId": "8ab0d75d-daf3-4141-a09a-b5d108b9fb3f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 / 3\n"
     ]
    }
   ],
   "source": [
    "fraccion2 = Fraccion(2, 3)\n",
    "fraccion2.imprimir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "9A-c54qQjo_W",
    "outputId": "5cfb527f-ec6e-4679-f07f-7e9b2291ce0e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Fraccion at 0x7f7d7bdc12e8>"
      ]
     },
     "execution_count": 46,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fraccion3 = fraccion1.suma(fraccion2)\n",
    "fraccion3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "UczaM-l3jt80",
    "outputId": "4acde0a5-4146-4280-cf09-291c7d8431e4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 / 6\n"
     ]
    }
   ],
   "source": [
    "fraccion3.imprimir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "3AzLZM6wj59b",
    "outputId": "9d1985b7-5eea-4250-ecf4-86c829ff75f3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 / 18\n"
     ]
    }
   ],
   "source": [
    "fraccion4 = fraccion3.resta(fraccion2)\n",
    "fraccion4.imprimir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "ROk8ZlNZj1OX",
    "outputId": "32e12448-51ba-4f20-c418-c72323c78da2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 / 3\n"
     ]
    }
   ],
   "source": [
    "fraccion5 = fraccion2.division(fraccion1)\n",
    "fraccion5.imprimir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kKQ5atN6kRqf"
   },
   "source": [
    "# Bibliografía\n",
    "\n",
    "\n",
    "*   [Interactive Python Tutorial](https://www.learnpython.org/en/Welcome)\n",
    "*   [PCAP: Programming Essentials in Python](https://www.netacad.com/es/courses/programming/pcap-programming-essentials-python)\n",
    "* [Programación orientada a objetos en Python](https://runestone.academy/runestone/static/pythoned/Introduction/ProgramacionOrientadaAObjetosEnPythonDefinicionDeClases.html)\n",
    "\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "TallerPython.ipynb",
   "provenance": []
  },
  "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.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}