{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qbpM8ot3vNIF"
   },
   "source": [
    "<table>\n",
    "<table border = 5  align = center bgcolor=\"white\" cellspacing=\"10px\">\n",
    "\n",
    "<tr>\n",
    "<td><a href=\"https://drive.google.com/file/d/14oQfOhwLDswvDw0uOIhQUNJZTmm6S0LE/view?usp=sharing\"> <img alt=\"Moncora\" width=\"150px\"  src=\"https://miro.medium.com/max/986/1*S2AyJcdw8EPcn7gwDVSBCA.png\" align=\"left\" hspace=\"10px\" vspace=\"0px\" /> </a> </td>\n",
    "   \n",
    "    \n",
    " \n",
    "<td></td>\n",
    "    \n",
    "<td><a href=\"https://mybinder.org/v2/git/https%3A%2F%2Fgitmilab.redclara.net%2FhalleyUIS%2Fmoncora.git/0936d792b8e87847f8624bb906f74cd24badf030?urlpath=lab%2Ftree%2FBook%2FJupyter_Notebooks%2FFundamentos.ipynb\"><img src=\"https://mybinder.org/static/images/logo_social.png\" alt=\"Alternative text\" width=\"150px\"  /></a>\n",
    "</td>\n",
    "\n",
    "</tr>\n",
    "\n",
    "</table>\n",
    "    \n",
    "<br>\n",
    "\n",
    "\n",
    "<!--[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/gitmilab/moncora/moncora/blob/main/Book/Jupyter_Notebooks/Fundamentos.ipynb)-->\n",
    "\n",
    "\n",
    "# <strong>Fundamentos</strong>\n",
    "\n",
    "## Programando sin barreras I\n",
    "\n",
    "\n",
    "\n",
    "<blockquote>\n",
    "No te pierdas el vídeo de <a href=\"https://www.youtube.com/watch?v=inN8seMm7UI\">Fundamentos de programación</a> y el siguiente video sobre algoritmos.\n",
    "</blockquote>\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/U3CGMyjzlvM\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import HTML\n",
    "import warnings\n",
    "\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "HTML('<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/U3CGMyjzlvM\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen></iframe>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VUWmLNQ_4UZZ"
   },
   "source": [
    "### <strong>Hola Mundo</strong> \n",
    "Para mostrar texto en python se usa el comando: \n",
    "\n",
    "```\n",
    " print()\n",
    "```\n",
    "Dentro de los corchetes ingresamos el texto que queremos mostrar entre comillas, no es relevante si son simples o dobles cualquiera funciona.\n",
    "\n",
    "A continuación un ejemplo, en el cual mostraremos el texto **Hola mundo** el cual ha sido historicamente el primer programa que se realiza cuando se esta iniciando en la programación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 233,
     "status": "ok",
     "timestamp": 1623471880981,
     "user": {
      "displayName": "Programando Barreras",
      "photoUrl": "",
      "userId": "14434479729996923763"
     },
     "user_tz": 300
    },
    "id": "1Ly6eFl6YG20",
    "outputId": "4c47b67e-ccdc-42da-a6a4-c6c51378411a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "¡Hola, mundo!\n"
     ]
    }
   ],
   "source": [
    "print(\"¡Hola, mundo!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wfylX433LdH8"
   },
   "source": [
    "Felicidades ya realizaste tu primer programa en python!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nfLIlZsIHvcy"
   },
   "source": [
    "<div class=\"alert alert-block alert-info\"> <b>Comentarios</b> Los comentarios en los lenguajes de programación son de suma importancia, ya que nos ayudan a dar una pequeña descripción de lo que hace nuestro programa o sirve como guía de este. En python los comentaciones se usan con el caracter `#`. El texto seguido del numeral nuestro programa de python no lo interpretará como parte del código. </div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "executionInfo": {
     "elapsed": 516,
     "status": "ok",
     "timestamp": 1620547962653,
     "user": {
      "displayName": "Programando Barreras",
      "photoUrl": "",
      "userId": "14434479729996923763"
     },
     "user_tz": 300
    },
    "id": "TWz6Ya3BLkpQ",
    "outputId": "f8e781d5-6a3b-4ac7-dd6a-ccd92cb6cbeb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "¡Hola, mundo!\n"
     ]
    }
   ],
   "source": [
    "# Esto es otro comentario: Código de Python para imprimir \"Hola, Mundo\"\n",
    "print(\"¡Hola, mundo!\")\n",
    "#Esto es otro comentario\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SqNhyvUZ5gkD"
   },
   "source": [
    "---\n",
    "\n",
    "### <strong>Calculadora</strong>\n",
    "Python se puede usar como operadora aritmetica instantanea, las operaciones más comunes son:\n",
    "\n",
    "Operador | Descripción | Ejemplo\n",
    "--- | --- | ---\n",
    "`+` | Realiza la adicción | `5+2`\n",
    "`-`| Realiza la substracción | `5-2`\n",
    "`*` | Realiza la multiplicación | `5*2`\n",
    "`/` | Realiza la división | `5/2`\n",
    "`%` | Realiza la operación modulo | `5%2`\n",
    "`**` | Realiza la operación potenciación | `5**2`\n",
    "`//` | Realiza la división número entero | `5//2`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 620,
     "status": "ok",
     "timestamp": 1620544636466,
     "user": {
      "displayName": "Programando Barreras",
      "photoUrl": "",
      "userId": "14434479729996923763"
     },
     "user_tz": 300
    },
    "id": "v3vlgrGM72th",
    "outputId": "823ee212-ed6a-434b-e940-cf6a9357c942"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 519,
     "status": "ok",
     "timestamp": 1620544679141,
     "user": {
      "displayName": "Programando Barreras",
      "photoUrl": "",
      "userId": "14434479729996923763"
     },
     "user_tz": 300
    },
    "id": "lsRSeRSK-WYa",
    "outputId": "7e7aaccf-e6a1-4c4e-9a3b-e106c15dde79"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#vamos no seas timido, cambia el operador y mira la diferencia, incluso puedes cambiar los números\n",
    "5//2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Utiliza también paréntisis\n",
    "4 * ( 2 + 3 ) / 4.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### <strong>Variables</strong> \n",
    "En programación se habla mucho de variables pero **¿Qué es una variable?**, como su nombre lo indica variable de variar, es decir puedo llamar a algo <strong>a</strong> y darle un valor, pero a medida que pasa el tiempo puedo variarla, puedo hacer que <strong>a</strong> tome otro valor esto convierte a <strong>a</strong> en una variable.\n",
    "\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\"> <b>Nota: </b> En python puedes asignar el nombre de las variables que desees, cumpliendo que no hallan caracteres especiales en el nombre exceptuando el guíon bajo `_`, empiece con una letra y <strong>recordar que es sensible a las mayúsculas</strong>, es decir \n",
    "`Altura=10` no es lo mismo que `altura=10`, son dos variables distintas. </div>\n",
    "\n",
    "\n",
    "<blockquote>La variables en python no deben ser declaradas, se definen al usarlas por primera vez.  </blockquote>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El objeto en la variable \"numero\" es  3\n",
      "Ahora el objeto en la variable \"numero\" es 12\n"
     ]
    }
   ],
   "source": [
    "# Crear una variable \n",
    "numero =  3 # \"=\" simbolo de asignación; \"numero\" es el identificador de la variable.\n",
    "\n",
    "# Se lee así : Dentro de la variable cuyo identificador es \"nombre\" se coloca el objeto 3, \n",
    "# que reside en la memoria.\n",
    "print('El objeto en la variable \"numero\" es ',numero)\n",
    "\n",
    "numero = 12 # Cambiar el objeto dentro de la variable \"numero\" , es una \"reasignación\" de la variable.\n",
    "print('Ahora el objeto en la variable \"numero\" es', numero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "16mIqTia-gd4"
   },
   "source": [
    "### <strong>Tipos de variables</strong> \n",
    "Existen diferentes tipos de variables en los lenguajes de programación en python encontraremos los siguientes:\n",
    "\n",
    "Ejemplo | Tipo de variable\n",
    "--- | --- \n",
    "`x = 10` | Entero `(int)`\n",
    "`x = 10.5`| Decimal `(float)`\n",
    "`x = \"Diez\"` | Texto `(str)`\n",
    "`x = 10j` | Complejo `(complex)`\n",
    "`x = [\"nueve\", \"diez\", \"once\"]` | Lista `(list)`\n",
    "`x = (\"nueve\", \"diez\", \"once\")` | Tupla  `(tuple)`\n",
    "`x = {\"nueve\":9, \"diez\":10, \"once\":11}` | Diccionario `(dict)`\n",
    "`x = True` | Booleano `(bool)`\n",
    "\n",
    "### <strong>Operaciones con variables</strong> \n",
    "\n",
    "Se puede realizar operaciones con el nombre de las variables, es decir si `altura=10` al realizar `altura*5` obtendremos `50`.\n",
    "\n",
    "Otro ejemplo es al imprimir datos. Si tengo una variable llamada:\n",
    "`usuario=\"Programando sin Barreras\"`\n",
    "Al usar el comando `print(usuario)` el texto que se desplegará será `Programando sin Barreras`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 531,
     "status": "ok",
     "timestamp": 1620547363350,
     "user": {
      "displayName": "Programando Barreras",
      "photoUrl": "",
      "userId": "14434479729996923763"
     },
     "user_tz": 300
    },
    "id": "zmqbC-zbFDda",
    "outputId": "bf07774e-7420-414a-ed69-ab80ce5fb9a2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El indice de masa corporal es: 26.122448979591837\n"
     ]
    }
   ],
   "source": [
    "#Un pequeño ejemplo \n",
    "#calculando el IMC\n",
    "estatura = 1.75 #(en metros)\n",
    "peso = 80\n",
    "IMC = peso/estatura**2\n",
    "print(\"El indice de masa corporal es:\", IMC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "<b>Nota:</b> Python infiere el tipo de variable cuando se declaran. Es decir, Python sabe que 175 es un entero y declara la variable estatura  como int.\n",
    "\n",
    "<blockquote>La función \n",
    "    `\n",
    "    type()\n",
    "    `\n",
    "    nos ayuda a indetificar que tipo de dato es nuestra variable </blockquote>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 1050,
     "status": "ok",
     "timestamp": 1620547366903,
     "user": {
      "displayName": "Programando Barreras",
      "photoUrl": "",
      "userId": "14434479729996923763"
     },
     "user_tz": 300
    },
    "id": "yuYTDp3qJlhU",
    "outputId": "7e46efa9-1b81-4c5a-e6d9-05d2f4a03ea0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#La siguiente linea de código mostrará el tipo de dato de la variable peso, o cualquier variable que pongas dentro los corchetes\n",
    "type(peso)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(IMC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entrada de texto\n",
    "\n",
    "Una buena manera de aprender a usar las herramientas de programación basicas es creando códigos interactivos. En un código interactivo, se le pide a un usuario que digite cierta información y posteriormente el código usa dicha información y devuelve un resultado.\n",
    "\n",
    "La estructura es muy sencilla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola\n",
      "a =  Hola\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo 1\n",
    "print('Escribe una letra o palabra.')\n",
    "a = input()\n",
    "print('a = ',a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este ejemplo, el programa le pide al usuario que escriba una letra o palabra. Luego, el comando `input()` da la instrucción al equipo de pedir y recibir información del usuario. La variable `a` almacena este valor. Y finalmente el comando `print('a = ',a)` imprime el valor almacenado en `a`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Escribe tu nombre\n",
      "Juan\n",
      "Tu nombre es:  Juan\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo 2\n",
    "print('Escribe tu nombre.')\n",
    "nombre = input()\n",
    "print('Tu nombre es: ',nombre)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este segundo ejemplo se pide al usuario que escriba su nombre y posteriormente se imprime en pantalla el nombre que se ha escrito. Este ejemplo no manipula la información que se le ha dado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dime en cuál año estamos\n",
      "2023\n",
      "Dime tu edad actual\n",
      "19\n",
      "Naciste en el año  2004 o en el 2003\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo 3\n",
    "print('Dime en cuál año estamos.')\n",
    "año = input()\n",
    "print('Dime tu edad actual.')\n",
    "edad = input()\n",
    "nacimiento = int(año) - int(edad)\n",
    "print('Naciste en el año ',nacimiento, 'o en el',nacimiento-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para este ejemplo usamos dos veces la función `input()`, le pedimos el año y la edad actual al usuario. Luego calculamos el año de nacimiento restando el año y la edad. Para poder hacer la resta hicimos conversión de texto a número entero usando la función `int()`. \n",
    "\n",
    "Por ejemplo, `int('15') = 15` es decir el valor ya no tiene las comas `''` que lo hacían ser un valor tipo texto. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dime un número\n",
      "10\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo 4\n",
    "print('Dime un número entero.')\n",
    "n = input()\n",
    "m = int(n)\n",
    "print(m**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el ejemplo anterior, el usuario digita un número que es guardado en la variable `n`. Luego el valor de `n` se convierte en número entero y se guarda este número en `m`. Finalmente, el programa devuelve el cuadrado de `m`. \n",
    "\n",
    "En palabras simples, este programa toma un número y lo eleva al cuadrado."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img width=\"150px\"  src=\"https://raw.githubusercontent.com/AndresGuarin/Images/main/moncora_ejercicios_cartel.png\" align=\"center\">\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1**. Escribe un programa que tome un número entero y lo divida entre 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2**. Escribe un programa que tome un número entero lo divida entre 10 y le reste 20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3**. Escribe un programa que tome un número entero lo divida entre 10, le reste 20 y luego lo eleve al cuadrado, en ese orden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4**. Escribe un programa que pida una cantidad de horas y devuelva la cantidad de minutos y segundos que hay en esa hora. Agrega comentarios que hace lo que explique tu código"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5**. ¿Cuál es la diferencia entre 6+5 * 10 y (6+5) * 10?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nota:** ¿Qué pasa si dividimos 1 entre 0? Veámos!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "1/0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nota 2:** Los programas interactivos son útiles para aprender y practicar a programar, pero en la vida cotidiana de un programador no los usamos. En lugar de usar la función `input()` simplemente declaramos la variable y le asignamos un valor. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.0\n"
     ]
    }
   ],
   "source": [
    "# Este programa toma dos números y cálcula su promedio\n",
    "a = 10\n",
    "b = 4\n",
    "\n",
    "c = (a+b)/2\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El `print(c)` se ha usado simplemente para mostrar el resultado del cálculo del promedio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JdaV6RsxKAZI"
   },
   "source": [
    "### <strong> Conversión de datos </strong>\n",
    "\n",
    "Python por ser un lenguaje de programación cientifico, es común el uso de decimales, enteros y estar cambiando el uno entre el otro, para poder hacer este paso, solo debemos escribir la variable que queremos cambiar dentro del tipo de dato."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 559,
     "status": "ok",
     "timestamp": 1620547698650,
     "user": {
      "displayName": "Programando Barreras",
      "photoUrl": "",
      "userId": "14434479729996923763"
     },
     "user_tz": 300
    },
    "id": "UolFqOH8KzsQ",
    "outputId": "a0f9e555-1112-4ead-88fc-5241947d456f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#ejemplo\n",
    "int(10.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1234"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#ejemplo 2\n",
    "float('0.1234')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definición del número pi\n",
    "pi_string = \"3.1415926\"\n",
    "\n",
    "# Convierta pi_string en float: pi_float"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Zhhphii4MAK5"
   },
   "source": [
    "### Cadenas de texto\n",
    "\n",
    "Al usar la función `print()` podemos imprimir texto combinado con variables y conversiones de datos delimitandolo por comas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 519,
     "status": "ok",
     "timestamp": 1620548197291,
     "user": {
      "displayName": "Programando Barreras",
      "photoUrl": "",
      "userId": "14434479729996923763"
     },
     "user_tz": 300
    },
    "id": "O8fu9HaOL_d5",
    "outputId": "1322b34b-6a7c-4e74-c18e-dcb86482d370"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Este es un ejemplo de un texto combinado\n"
     ]
    }
   ],
   "source": [
    "a=\"un texto combinado\"\n",
    "print(\"Este es un ejemplo de\",a )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yo empece con $ 100 pesos, y ahora tengo $ 194 pesos. Maravilloso!\n"
     ]
    }
   ],
   "source": [
    "# Definición de variables\n",
    "inicio = 100\n",
    "final = 100 * 1.10 ** 7\n",
    "\n",
    "# Fix the printout\n",
    "print(\"Yo empece con $\", inicio,  \"pesos, y ahora tengo $\", int(final), \"pesos. Maravilloso!\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img width=\"150px\"  src=\"https://raw.githubusercontent.com/AndresGuarin/Images/main/moncora_ejercicios_cartel.png\" align=\"center\">\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7hl8MP06M1Ev"
   },
   "source": [
    "**1**. Mediante el uso de operadores aritméticos, calcule el área de un triángulo isósceles. Las entradas deben ser los lados `a` y `b`, siendo `a` el lado que es igual en el triángulo isósceles y siendo `b` la base del triángulo. La salida o respueste debe ser el valor del área. Debe imprimir la respuesta en pantalla. La ecuación es:\n",
    "\n",
    "$$A=\\cfrac{bh}{2}$$\n",
    "\n",
    "Recuerda que en un triángulo isósceles:\n",
    "\n",
    "<img width= 300pt src=\"https://www.neurochispas.com/wp-content/uploads/2021/03/formula-de-la-altura-de-un-triangulo-isosceles.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "colab": {
   "authorship_tag": "ABX9TyMp2qPW8JWnrDVCHvDkwnJr",
   "name": "Fundamentos.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}