2 - Conceptos basicos de programacion en Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conceptos básicos de programacion en Python\n",
    "Para hacer programacion primero tenemos que entender una serie de conceptos basicos.\n",
    "\n",
    "![](util/conceptos_basicos.png)\n",
    "\n",
    "## 1. Valores\n",
    "\n",
    "![](util/tipos_valores.png)\n",
    "\n",
    "### 1.1. Numericos (integer & float)\n",
    "Los valores numericos pueden ser numeros enteros (integer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "como numeros decimales (float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1000.95"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2. Cadenas de caracteres\n",
    "Cadenas de caracteres entre comillas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'hola'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"¿hola que tal?\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las cadenas de caracteres pueden contener tanto letras, como numeros o simbolos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"100\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Realiza la siguiente operacion: 2 * 3\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3. Booleanos\n",
    "Representan un valor de verdad y solo existen dos valores posibles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Variables / estructuras de valores\n",
    "\n",
    "![](util/tipos_variables.png)\n",
    "\n",
    "### 2.1 Variables de un solo valor\n",
    "Son como cajas donde guardamos informacion. Esta informacion puede ser numeros (integer o float) o texto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3 + 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La variable *a* se queda almacenada en la meroria del ordenador y podemos utilizar esta variable cuando queramos a partir de ahora. Nota: debemos asegurarnos de crear la variable antes de utilizarla."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como hemos dicho la variable queda almacenada y mantiene el valor que le hemos asignado, pero podemos cambiarlo en cualquier momento si queremos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 120"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos darle cualquier nombre a las variables pero... cuidado con utilizar mayusculas y minusculas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... el nombre de una variable no puede empezar con un numero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1A = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A1 = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... tampoco pueden contener espacios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombre apellido = 'Juan Lopez'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombre_apellido = 'Juan Lopez'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...y tampoco podemos usar ciertos nombres ya asignados en Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nombres que no podemos asignar a variables porque son palabras claves (keywords) en Python:\n",
    "\n",
    "![](util/list_keywords.png)\n",
    "\n",
    "### 2.2 Listas de valores\n",
    "Puede ser una lista de valores numericos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[1,2,3,4,5,100]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puede ser una lista de cadenas de caracteres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[\"hola\",\"hello\",\"salut\",\"ciao\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O una lista de valores booleanos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[True, False, False]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O una mezcla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[1,2,\"hola\",4,5,True]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las lista de valores se pueden almacenar en una variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,\"hola\",4,5,True]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una vez almacenada podemos extraer sus valores de esta manera"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nota**: los Array y Dataframes los veremos más adelante en el curso cuando veamos las librerias Numpy y Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Operaciones\n",
    "\n",
    "![](util/tipos_operaciones.png)\n",
    "\n",
    "### 3.1 Operaciones matematicas\n",
    "Suma y resta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 + 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 - 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiplicacion y division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "8 * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "8 / 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Resto de una division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "8 % 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exponenciacion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos combinar varias operaciones en una misma expresion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 * 4 + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2 * 4 + 3 = 8 + 3 = 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 + 4 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(3 + 4) * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O hacer operaciones con cadenas de caracteres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Ho\" + \"la\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Ho\" + \"la\" * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "⚡Antes de ejecutar las celdas de abajo, ¿podrias adivinar el resultado de cada una de las celdas?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"2\" + \"3\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"2\" * \"3\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"2\" * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Operaciones de asignación\n",
    "Con el signo = podemos asignar un determinado valor (o estructura de valores) a una variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable = 125"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A una variable podemos asignarle tambien una lista de valores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1 = [2,3,5,6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y tambien podemos actualizar o cambiar el valor de la variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = a + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Operaciones racionales o de comparación\n",
    "Con los signos >,<, ==, !=, >=, <= podemos comparar valores.\n",
    "\n",
    "Mayor que"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 > 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Menor que"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 < 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Igual a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos combinarlas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 <= 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero cuidado con utilizar el = para comparar..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 = 2 # es correcta esta expresion? por que?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Distinto a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 != 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tambien podemos comparar cadenas de caracteres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'perro' == 'gato'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'perro' == 'perro'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O listas de valores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[1,2,3,4] != [1,2,3,4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5\n",
    "b = 6\n",
    "a < b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nota**: como puedes ver dentro de una celda puedes escribir varias lineas de código.\n",
    "\n",
    "### 3.4 Operaciones lógicas (o booleanas)\n",
    "Tenemos tres operadores logicos principales: `not`, `and`, `or`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "False or True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La evaluación de una expresión al utilizar los operadores and u or sigue las siguientes reglas:\n",
    "\n",
    "- `and` y `or` evalúan una expresión de izquierda a derecha.\n",
    "- La operación `and`, si todos los valores son **True**, retorna el último en ser evaluado. Si algún valor es **False**, retorna el primero.\n",
    "- `or` retorna el primer valor que sea **True**. Si todos son **False**, retorna el último.\n",
    "\n",
    "`and`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and 3 > 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 == 1 and 3 > 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`or`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True or 3 > 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 == 1 or 3 > 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5 Operaciones condicionales\n",
    "Las operaciones condicionales se utilizan para ejecutar una expresion en caso de que una o más condiciones se cumplan. Representa el momento en que se debe tomar una decisión y dependiendo la decisión que se tome ocurrirá una cosa u otra, o ninguna.\n",
    "\n",
    "![](util/operaciones_condicionales.png)\n",
    "\n",
    "`if`: puede traducirse a “si (se cumple una condición), entonces:”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "if x > 0: # si x es mayor que 0 (condicion), entonces:\n",
    "    print(\"la variable x tiene un valor positivo\") # muestra en pantalla el mensaje entre parentesis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`else`: puede traducirse como “sino (se cumple la condicion), entonces:” y normalmente se encuentra como escape a un `if`. **Aclaracion:** `else` siempre va acompañando a `if` y debajo de éste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -5\n",
    "if x > 0:\n",
    "    print(\"la variable x tiene un valor positivo\")\n",
    "else:\n",
    "    print(\"la variable x no tiene un valor positivo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`elif`: es la abreviacion de \"else if\" y se utiliza para enlazar varias condiciones, vendría a ser como un “si es”:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -5\n",
    "if x > 0:\n",
    "    print(\"la variable x tiene un valor positivo\")\n",
    "elif x == 0:\n",
    "    print(\"la variable x tiene valor 0\")\n",
    "elif x < 0:\n",
    "    print(\"la variable x tiene un valor negativo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tambien podemos hacer el mismo ejemplo usando `else`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -5\n",
    "if x > 0:\n",
    "    print(\"la variable x tiene un valor positivo\")\n",
    "elif x == 0:\n",
    "    print(\"la variable x tiene valor 0\")\n",
    "else:\n",
    "    print(\"la variable x tiene un valor negativo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otro ejemplo, usando operaciones condicionales vamos a escribir un codigo para obtener el valor absoluto de un número:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -5\n",
    "\n",
    "if x >= 0:\n",
    "    valor_absoluto = x\n",
    "elif x < 0:\n",
    "    valor_absoluto = -x\n",
    "\n",
    "print(valor_absoluto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "🚨 **Importante**: despues de la condicion debemos poner siempre dos puntos ( : ) de esta manera al darle al enter para ir a la siguiente linea verás que la linea empezará un poco mas adelante (4 espacios), es como cuando en word aplicamos una sangria. En Python a esto lo llamamos **indentación** y es algo muy importante para darle estructura al código y para que el codigo se más facil de leer y entender.\n",
    "\n",
    "⚡**Ejercicio**: Ahora intentalo tú, escribe el mismo codigo que en la celda de arriba y verás que después de poner los dos puntos, cuando pulses la tecla Enter (o Intro) para ir a la siguiente linea verás que se aplica automaticamente la indentancion (o sangrado)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indentación\n",
    "\n",
    "![](util/indentacion.png)\n",
    "\n",
    "Python utiliza la indentación para delimitar la estructura permitiendo establecer bloques de código. No existen comandos para finalizar las líneas ni llaves con las que delimitar el código. Los **únicos delimitadores** existentes son los **dos puntos** ( **:** ) y la **indentación** del código. Normalmente se suelen dejar como indentación o sangrado **4 espacios en blanco** con lo que se indicaría el inicio del bloque, si en las posteriores líneas no introdujéramos el sangrado, significaría el final de dicho bloque de código, con lo cual para finalizar un bloque de código, solo tenemos que dejar de introducir el sangrado, no tenemos que usar ninguna llave ni símbolo.\n",
    "\n",
    "Tenemos que ser muy conscientes del sangrado que realizamos ya que de ello dependerá la lógica de nuestro código. \n",
    "\n",
    "Veamos este codigo que nos dice si el valor que damos a `numero` es un valor igual a 0, o par o impar positivo o si es negativo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numero = 10\n",
    "\n",
    "if numero >= 0: # si el numero es mayor o igual a 0\n",
    "    \n",
    "    if numero > 0: # si el numero es positivo\n",
    "        \n",
    "        if numero % 2 ==0: # si el numero es par (al dividirlo entre 2 el resto de la division es 0)\n",
    "            print('es un numero par y positivo')\n",
    "        \n",
    "        else: # sino el numero tiene que ser impar\n",
    "            print('es un numero impar y positivo')\n",
    "            \n",
    "    else:\n",
    "        print('es igual a 0')\n",
    "        \n",
    "else:\n",
    "    print('es un numero negativo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](util/indentacion_ejemplo.png)\n",
    "\n",
    "### 3.6 Bucles (loops)\n",
    "Un bucle es una operacion que repite un bloque de instrucciones. Hay dos tipos principales de operacion de tipo bucle: `for` y `while` \n",
    "\n",
    "**Bucle `for`**\n",
    "\n",
    "Un bucle `for` es un bucle que repite un bloque de codigo un número prederminado de veces. El bloque de codigo que se repite se suele llamar cuerpo del bucle y cada repetición se suele llamar iteración.\n",
    "\n",
    "La sintaxis de un bucle for es la siguiente:\n",
    "```python\n",
    "for variable in elemento_iterable:\n",
    "    cuerpo\n",
    "```\n",
    "El elemento iterable puede ser por una lista de valores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "elemento_iterable = [1,2,3,4,5]\n",
    "\n",
    "for x in elemento_iterable: # para cada valor de la lista ejecutar la siguiente operacion\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in elemento_iterable: # para cada valor de la lista ejecutar la siguiente operacion\n",
    "    print(x * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [1,3,5,-2]\n",
    "\n",
    "for i in lista:\n",
    "    j = i ** 2\n",
    "    print(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como puedes ver, aqui tambien se aplica la indentacion al cuerpo del bucle que se repite en cada iteracion.\n",
    "\n",
    "Podemos ver que si cambiamos la indentacion de alguna linea de codigo el resultado es diferente: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [1,3,5,-2]\n",
    "\n",
    "for i in lista:\n",
    "    j = i ** 2\n",
    "print(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "😕 ¿por qué el resultado que aparece en pantalla no es el mismo?\n",
    "\n",
    "⚡**Ejercicio**: Ahora intentalo tú, escribe el mismo codigo que en la celda de arriba y verás que después de poner los dos puntos, cuando pulses la tecla Enter (o Intro) para ir a la siguiente linea verás que se aplica automaticamente la indentancion (o sangrado). Intenta tambien cambiar los valores de la lista y la operacion que se realiza en cada iteracion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El elemento iterable puede ser tambien una sucesion de valores creada con `range`. Esto puede ser util en determinados casos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [1,3,5,-2]\n",
    "num_elem = len(lista) # numero de elementos de la lista (en este caso 4)\n",
    "sucesion = range(num_elem) # Creamos una sucesion de 4 valores: 0, 1, 2, 3\n",
    "\n",
    "for i in sucesion:\n",
    "    j = lista[i] ** 2 # El primero calculo seria j = lista[0] ** 2, el siguiente j = lista[1] ** 2,...\n",
    "    print(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Bucle `while`**\n",
    "\n",
    "El bucle `while` nos permite ejecutar un bloque de código (cuerpo) continuamente mientras la condición sea verdadera."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0 # Asignamos el valor inicial de la variable \"i\"\n",
    "\n",
    "while i <= 9: # Creamos el bucle con la condición de ejecutarse mientras \"i\" sea menor o igual a \"9\"\n",
    "    i = i + 1     # Cuerpo = sumamos uno a i (en cada iteracion)\n",
    "    print (i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo que hace el codigo es primero combrobar la condicion con el valor inicial que hemos asignado i = 0:\n",
    "```python\n",
    "i <= 9\n",
    "``` \n",
    "Para i = 0 la condicion es 0 <= 9 que es True, entonces hace la operacion que hemos escrito en el cuerpo del bucle, despues con el nuevo valor de i hace de nuevo la comprobacion de si se cumple i <= 9 (es decir si la condicion es True) y asi hasta que la condicion no se cumpla (False), en este caso hasta que i = 10.\n",
    "\n",
    "Vamos a ver otro ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0 \n",
    "\n",
    "while x <= 20:\n",
    "    x + 2     \n",
    "    print (x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "⚡**Ejercicio**: El codigo de la celda de arriba produce un bucle infinito. ¿Por qué? ¿Puedes arreglarlo? \n",
    "\n",
    "❗ Para detener el calculo del bucle infinito debes pulsar en el boton para interrumpir el kernel (cuadrado negro) o ir al menu desplegable Kernel y hacer clic en Interrupt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}