Clases/Clase_04_Funciones_Condicionales.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Clase_04_Funciones_Condicionales.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/bpoblete/CC1002/blob/master/Clases/Clase_04_Funciones_Condicionales.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "2IQ82S7DizP1"
      },
      "source": [
        "# Clase 4: Expresiones y Funciones Condicionales \n",
        "**(Leer Capítulo 5 del Apunte)**\n",
        "\n",
        "\n",
        "## Valores Booleanos\n",
        "Existen expresiones que al ser evaluadas retornan valores:\n",
        "- **`True`** (VERDADERO) o \n",
        "- **`False`** (FALSO), \n",
        "\n",
        "estos valores son de tipo **`bool`** (booleanos).\n",
        "\n",
        "Ya las conocemos de las matemáticas en donde hablamos de _proposiciones verdaderas o falsas_. Para un par de números **`x`** e **`y`** sólo existen 3 opciones posibles:\n",
        "\n",
        "```python\n",
        "x == y # x es igual a y\n",
        "x < y  # x es menor a y\n",
        "x > y  # x es mayor a y\n",
        "\n",
        "```\n",
        "\n",
        "A lo anterior también podemos agregar:\n",
        "```python\n",
        "x <= y  # x es menor igual a y\n",
        "x >= y  # x es mayor igual a y\n",
        "\n",
        "```\n",
        "\n",
        "\n",
        "Podemos probar cómo se comportan estas expresiones en python:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "qT7aFkH5izP3",
        "colab": {}
      },
      "source": [
        "6 < 5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "lYUJYbVUVc9r",
        "colab": {}
      },
      "source": [
        "5 < 6"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "rcMAKKqpizP6",
        "colab": {}
      },
      "source": [
        "4 == 5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "5rqNcHCnizP9"
      },
      "source": [
        "\n",
        "## Condiciones compuestas\n",
        "\n",
        "También existen condiciones compuestas que son conectores lógicos:\n",
        "\n",
        "- **`and`**, es True si las expresiones que conecta son ambas True\n",
        "- **`or`**, es True si al menos una de las expresiones que conecta son True\n",
        "- **`not`** niega el resultado de la expresión que viene inmediatamente a continuación\n",
        "\n",
        "\n",
        "\n",
        "```python\n",
        "\n",
        "x == y  and y < z  # es verdadero si x==y es True e y<z es True \n",
        "x == y or y < z  # es verdadero si x==y es True o y<z es True\n",
        "not x == y  # es verdadero si x==y es False (la negación de falso es verdadero)\n",
        "\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "gHOfY9W2izP-",
        "colab": {}
      },
      "source": [
        "x=5\n",
        "y=5\n",
        "z=6\n",
        "x==y and y<z"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "LaKhjr-YunnF"
      },
      "source": [
        "Ahora cambiamos sólo el valor de z:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "dljdvmwuufN3",
        "colab": {}
      },
      "source": [
        "z=4\n",
        "x==y and y<z"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "DzHNPOWwussE"
      },
      "source": [
        "Ahora probamos **`or`** con las mismas expresiones y sólo debería  bastar que una de las expresiones fuera **`True`**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "CDDfg6Gfu73h",
        "colab": {}
      },
      "source": [
        "x==y or y<z"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "dK1O5meKvG-J",
        "colab": {}
      },
      "source": [
        "True or False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "ZSa-aAFKvOPJ",
        "colab": {}
      },
      "source": [
        "True and False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "fo2lwXtRvWHL"
      },
      "source": [
        "## Funciones booleanas\n",
        "También es posible crear funciones cuyo resultado sea del tipo bool (**`True`** o **`False`**). Por ejemplo, creemos una función que dice si un valor **`n`** es igual a **5**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "Mh9nkDgaizQC",
        "colab": {}
      },
      "source": [
        "# esIgualA5: num -> bool\n",
        "# determina si n es igual a 5\n",
        "# ej: esIgualA5(5) devuelve True y para cualquier otro numero False\n",
        "def esIgualA5(n):\n",
        "    return n == 5\n",
        "# test\n",
        "assert esIgualA5(5)\n",
        "assert not esIgualA5(11) # como esIgualA5(11) es False, se antepone not\n",
        "                         # para que sea True y funcione el assert"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "yVWBrX7OizQE",
        "colab": {}
      },
      "source": [
        "esIgualA5(10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "hP1XpXSHwGEd"
      },
      "source": [
        "Ahora hagamos una función que retorne True si un valor está entre 5 y 6:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "e0voHx3XizQG",
        "colab": {}
      },
      "source": [
        "# estaEntre5y8: int -> bool\n",
        "# indica si entero n está entre los valores 5 y 8 (sin incluirlos)\n",
        "# ej: estaEntre5y8(6) devuelve True, también para 7, y el resto False\n",
        "def estaEntre5y8(n):\n",
        "  return n>5 and n<8\n",
        "# test\n",
        "assert estaEntre5y8(6)\n",
        "assert estaEntre5y8(7)\n",
        "assert not estaEntre5y8(5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ycAiQA6MizQH"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "## Condiciones\n",
        "\n",
        "**si** pregunta es verdadero **entonces** se ejecuta respuesta\n",
        "\n",
        "en python:\n",
        "\n",
        "```python\n",
        "if (pregunta):\n",
        "    respuesta\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_j5s3bKEr82H",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x=5\n",
        "y=5\n",
        "\n",
        "if x==y:\n",
        "  print ('son iguales!')\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "f9jyA_mlizQI",
        "colab": {}
      },
      "source": [
        "\n",
        "x = 5\n",
        "y = 1\n",
        "if (x > y):\n",
        "  print (x, 'es mayor que', y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "1viBDPWyizQJ",
        "colab": {}
      },
      "source": [
        "x = int(input('ingrese entero x '))\n",
        "y = int(input('ingrese entero y '))\n",
        "if (x > y):\n",
        "  print (x, 'es mayor que', y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "M_GXPjI2izQL"
      },
      "source": [
        "### ¿Cómo hago un programa que responda lo correcto en cualquier caso?\n",
        "\n",
        "- **si** pregunta **entonces** respuesta\n",
        "- **sino** pregunta **entonces** respuesta\n",
        "- ...\n",
        "- **si no ocurre nada de lo anterior entonces** respuesta\n",
        "\n",
        "\n",
        "en python:\n",
        "\n",
        "```python\n",
        "if (pregunta):\n",
        "    respuesta\n",
        "elif(pregunta):\n",
        "    respuesta\n",
        "# (...) elif puede repetirse todas las veces que necesitemos\n",
        "else:\n",
        "    respuesta\n",
        "```\n",
        "\n",
        "**Las condiciones siempre se evalúan en ORDEN**\n",
        "\n",
        "Ejemplo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "tfoDQYJxizQM",
        "colab": {}
      },
      "source": [
        "x = int(input('ingrese un entero x '))\n",
        "y = int(input('ingrese un entero y '))\n",
        "if (x > y):\n",
        "    print (x, 'es mayor que', y)\n",
        "elif (x < y):\n",
        "    print (x, 'es menor que', y)\n",
        "else:\n",
        "    print (x, 'es igual que', y)\n",
        "    \n",
        "# podemos omitir el ultimo elif, y reemplazarlo por un else,o incluso todos los elif"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "EWWAlYUlizQN"
      },
      "source": [
        "\n",
        "\n",
        "\n",
        "### Otro ejemplo:\n",
        "\n",
        "**Ejemplo:** Módulo jaliscoCachipun.py (debemos crearlo en un archivo aparte con el nombre del jaliscoCachipun.py)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "qqdvVawdizQO",
        "colab": {}
      },
      "source": [
        "from jaliscoCachipun import ganarCachipun\n",
        "\n",
        "# al importar usando from, no necesitamos poner jaliscoCachipun.ganarCachipun(parametro)\n",
        "# solo llamamos directamente a ganarCachipun(parametro)\n",
        "\n",
        "print ('Juego del Jalisco Cachipun')\n",
        "jugada = input ('Ingrese su jugada (piedra, papel o tijera) ')\n",
        "print ('Yo te gano con ' + ganarCachipun(jugada))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "sPuUK7pkzjgw"
      },
      "source": [
        "El módulo jaliscoCachipun.py consiste de:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "aMfmiDBWzpa7",
        "colab": {}
      },
      "source": [
        "# jaliscoCachipun: str -> str\n",
        "# entrega la jugada ganadora del cachipun dada una entrada valida\n",
        "# ejemplo: jaliscoCachipun('tijera') debe retornar 'piedra'\n",
        "def ganarCachipun(jugada):\n",
        "  if jugada == 'tijera':\n",
        "    return 'piedra'\n",
        "  elif jugada == 'papel':\n",
        "    return 'tijera'\n",
        "  else:\n",
        "    return 'papel'\n",
        "\n",
        "# test\n",
        "assert ganarCachipun('tijera')=='piedra'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7ZHFfEZ_zXsH",
        "colab_type": "text"
      },
      "source": [
        "Ejemplo: Ver si un entero es 'par'"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "5dy__ktaizQR",
        "colab": {}
      },
      "source": [
        "#par: int -> bool\n",
        "#True si un entero es par (False si no)\n",
        "#ej: par(4) debe ser True, par(15) debe ser False\n",
        "def par(x):\n",
        "    return x%2==0\n",
        "\n",
        "assert par(4) #par(4)==True\n",
        "assert not par(15) #par(15)==False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "QDwhzukaizQW",
        "colab": {}
      },
      "source": [
        "par(5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "dWl4YLm8izQd"
      },
      "source": [
        "\n",
        "### Propuesto: \n",
        "- Hacer un programa que dado un año N indique si este es bisiesto o no.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "aE74NDNcizQQ"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "## Receta de Diseño de funciones condicionales\n",
        "\n",
        "Para diseñar una función condicional debemos:\n",
        "\n",
        "1. Identificar cada una de las situaciones posibles (por ejemplo, para funciones numéricas podemos dibujar una recta e identificar intervalos)\n",
        "2. Dar ejemplos de uso de la función, un ejemplo por cada situación. Incluir casos de borde.\n",
        "3. Cuerpo de la función: diseñar condiciones:\n",
        "```python\n",
        "if(...):\n",
        "    ...\n",
        "elif(...):\n",
        "    ...\n",
        "else():\n",
        "```\n",
        "4. Simplificar condiciones"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "bcEQDmS4izQe"
      },
      "source": [
        "### Programa saludo.py\n",
        "Saludo es un programa que recibe la hora y saluda según corresponda a la hora del día (Buenos días, Buenas tades y Buenas noches):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "se9B_3MxizQf",
        "colab": {}
      },
      "source": [
        "# saludo: int -> str\n",
        "# Determinar el saludo adecuado a la hora del dia 1 <= hora <= 24 # ejemplos:\n",
        "# saludo(11) debe devolver Buenos dias!\n",
        "# saludo(15) debe devolver Buenas tardes!\n",
        "def saludo(hora):\n",
        "    ## condiciones\n",
        "    if (hora <12):\n",
        "        return 'Buenos dias!'\n",
        "    elif (hora <21):\n",
        "        return 'Buenas tardes!'\n",
        "    else:\n",
        "        return 'Buenas noches!'\n",
        "# test:\n",
        "# probar condiciones de BORDE (o límites): 1hrs, 12hrs, 21hrs, 24hrs \n",
        "assert saludo(1) == 'Buenos dias!'\n",
        "assert saludo(11) == 'Buenos dias!' \n",
        "assert saludo(12) == 'Buenas tardes!' \n",
        "assert saludo(15) == 'Buenas tardes!'\n",
        "assert saludo(21) == 'Buenas noches!' \n",
        "assert saludo(23) == 'Buenas noches!' \n",
        "assert saludo(24) == 'Buenas noches!'"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}