3_booleans_lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## El tipo Boolean\n",
    "\n",
    "El cuarto tipo de dato es el boolean. Estos valores corresponden a los estados \"encendido\" o \"apagado\", y son unicamente dos. Veremos que este tipo de datos es importante en ciertas estructuras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = True\n",
    "\n",
    "tengo_hambre = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes de ver para que se usan, veremos las operaciones que existen entre booleanos. Igual que yo puedo hacer $1 + 2 = 3$, donde la operación es la suma, puedo definir operaciones entre booleanos, que dan como resultado un booleano. Existen tres operaciones básicas con booleanos:\n",
    "\n",
    "1. La negación (`not`): Cambia el valor del booleano a su estado contrario. Entonces `not True` es igual a `False` y `not False` es igual a `True`.\n",
    "\n",
    "2. Disyunción (`or`): Igual que la suma necesita dos enteros para realizar la operación, la disyunción necesita dos booleanos para realizar la operación correspondiente. Da como resultado False solamente si ambos booleanos son False. Entonces `False or False` es igual a `False`, y los tres resultados `True or False`, `False or True` y `True or True` dan como resultado `True`. \n",
    "\n",
    "3. Conjunción (`and`): Igual que el `or`, necesita dos booleanos, y devuelve uno. En este caso, la conjunción `True and True` es la única que sale igual a `True`. Las otras tres, `True and False`, `False and True`, `False and False` salen `False`. \n",
    "\n",
    "Veamos unos ejemplos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ejemplo 1: True\n",
      "Ejemplo 2: False\n",
      "Ejemplo 3: True\n"
     ]
    }
   ],
   "source": [
    "print(\"Ejemplo 1:\", True or False)\n",
    "print(\"Ejemplo 2:\", False and (False or True))\n",
    "print(\"Ejemplo 3:\", not True or not False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### Ejercicios\n",
    "\n",
    "Considere las siguientes variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ejercicio 3.a\n",
    "\n",
    "x1 = True or False\n",
    "x2 = True and (True or False)\n",
    "x3 = (not (True and False)) or (False and (not True))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué valor tienen las siguientes expresiones?\n",
    "\n",
    "1. `x1 and (not x2)`\n",
    "2. `(not x2) or (not x3)`\n",
    "3. `(not x1) or ((not x2) and x3 )`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## El tipo List\n",
    "\n",
    "El último tipo de dato esencial de Python es el tipo List. Es como una caja ordenada de variables, delimitada por corchetes y separados por comas. Puede contener CUALQUIER objeto (de cualquier tipo, inclusive puede contener listas). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares = [1, 4, 9, 16, 25]\n",
    "\n",
    "milista = [1, 5, True, \"Python 3.8\", tengo_hambre]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entre las operaciones básicas, existen dos que se pueden realizar con listas:\n",
    "\n",
    "> La suma (`+`): Devuelve una lista que contiene elementos de ambas listas, en orden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 1, 27, 8, 64, 125]\n"
     ]
    }
   ],
   "source": [
    "#Ejemplo de suma de listas\n",
    "cubes = [1, 27, 8, 64, 125]\n",
    "print(squares + cubes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> El indexing: Igual que los strings, puedo preguntar por una posición específica de la lista. En el ejemplo arriba, `print(cubes[3])` mostraría el valor `64`. Tanto con strings y con listas, no tenemos permitido preguntar por valores que estan en una posición que no existe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-c49c983eece1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msquares\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "print(squares[10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es un error muy común en python, el `list index out or range` indica que no existe la posición 10 en la lista.\n",
    "\n",
    "> El slicing (`:`): Igual que un string, podemos pedir una rebanada de la lista. El formato adentro de los corchetes es `a:b`, donde \"a\" y \"b\" son enteros que pueden omitirse:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 9, 16]\n",
      "[9, 16, 25]\n",
      "[1]\n"
     ]
    }
   ],
   "source": [
    "print(squares[1:4]) #Elementos del segundo al cuarto\n",
    "print(squares[2:]) #Elementos del tercero al ultimo\n",
    "print(squares[:1]) #Elementos del primero al primero"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El resultado es siempre una lista. Esto es importante. Observe el último resultado: `[1]`. No es lo mismo tener un sandwich a tener una caja con un sandwich adentro. Es por eso que cuando le preguntamos a Python si `[1]` y `1` son iguales, devuelve como resultado, `False`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print([1] == 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No es lo mismo A diferencia de los strings, las listas **si son objetos parcialmente mutables**. Puedo elegir una posición de la lista y reemplazarlo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 5, True, [1, 8, 27, 64, 125], False]\n"
     ]
    }
   ],
   "source": [
    "milista[3] = cubes\n",
    "print(milista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo, solo tenemos permitido cambiar valores que ya existen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list assignment index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-0b0399092613>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m#No podemos agregar valores a la lista asi\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mmilista\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msquares\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: list assignment index out of range"
     ]
    }
   ],
   "source": [
    "#No podemos agregar valores a la lista asi\n",
    "\n",
    "milista[5] = squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Debido a que, una vez más, la lista solo posee 5 valores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existen dos operaciones más que son bastante útiles cuando usamos listas:\n",
    "\n",
    "1. El operador `in`: Necesita dos objetos, digamos `a` y `b` donde `b` debe ser una lista, y devuelve un booleano. `a in b` es verdadero si `a` pertenece a la lista, y es falso si no pertenece\n",
    "\n",
    "2. La función `len()`: `len(a)` devuelve la cantidad de elementos de la lista `a`. (Tambien funciona si `a` es de tipo string!)\n",
    "\n",
    "Por ejemplo, `len(milista)` es igual a `5`. Además:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(tengo_hambre in milista) #True. False pertenece a milista.\n",
    "print(5 in milista) #True. 5 pertenece a milista.\n",
    "print(-1 in milista) #False. -1 no pertenece a milista."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### Ejercicios\n",
    "\n",
    "1. Guarde todos los enteros positivos del -3 al 4 en una lista. Cual elemento ocupa la tercera posicion?.\n",
    "\n",
    "\n",
    "\n",
    "2. Considere la siguiente lista:\n",
    "\n",
    "`x = [2, 3, 5, 7, 11, 13, 17, 23, 27, 29]`\n",
    "\n",
    "Que resultado darán las siguientes expresiones?\n",
    "\n",
    "> `x[8] + x[2] * (-2)`\n",
    "\n",
    "> `x + x`\n",
    "\n",
    "3. Considere la siguiente lista:\n",
    "\n",
    "`y = [4, 5, 9, 12, 15, 29]`\n",
    "\n",
    "Usando indexado, reemplace todos los valores impares por valores pares.\n",
    "\n",
    "4. Considere las siguientes variables\n",
    "\n",
    "> `a = [1, 2, 3]`\n",
    "\n",
    "> `b = 2`\n",
    "\n",
    "> `c = 3`\n",
    "\n",
    "> `d = \"32\"`\n",
    "\n",
    "> `e = [\"3\"]`\n",
    "\n",
    "> `f = [2, c]`\n",
    "\n",
    "> `g = \"3\"`\n",
    "\n",
    "¿Cuántos pares de variables se pueden sumar sin que de error?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ejercicio\n",
    "\n",
    "#Copie la siguiente linea en el python IDLE:\n",
    "y = list(range(-270,302,4))\n",
    "#Esta variable es una lista. Es un ejemplo de una lista donde no sabemos cuantos \n",
    "#elementos posee\n",
    "\n",
    "#1) Calcule la cantidad de elementos de la lista y\n",
    "#2) Está el valor 0 en esta lista?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interludio. Cómo pedir datos al usuario.\n",
    "\n",
    "Hasta ahora todas las variables que tenemos fueron definidas en las líneas de código. Sin embargo a veces querremos que el usuario introduzca variables en vivo y en directo. Eso se hace de la siguiente forma:\n",
    "\n",
    "> `x = int(input(\"\"))`\n",
    "\n",
    "Entonces el IDLE esperará a que el usuario introduzca una variable de tipo entero. Para entender el código es solo cuestión de desglosarlo en tres partes:\n",
    "\n",
    "1. \"\": Es el mensaje que se muestra al usuario. Si ponemos \"Ingrese un número: \", entonces ese será el mensaje que verá el usuario.\n",
    "\n",
    "2. input(): Es la función que permite esperar a que el usuario ingrese un dato. **Devuelve un valor de tipo string**\n",
    "\n",
    "3. int(): Convierte el valor tipo string devuelto por `input()` a tipo entero. En general, si queremos convertir a los tipos mas comunes, deberemos usar las siguientes funciones:\n",
    "\n",
    "| Tipo | Función |\n",
    "| ----------- | ----------- |\n",
    "| String | `str()` |\n",
    "| Entero | `int()` |\n",
    "| Flotante | `float()`|\n",
    "| Booleano | `bool()`|\n",
    "|Lista| `list()`|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por ejemplo, hagamos un simple programa que reciba un entero del usuario y devuelva el cuadrado del entero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese un entero: 12\n",
      "144\n"
     ]
    }
   ],
   "source": [
    "x = int(input(\"Ingrese un entero: \"))\n",
    "\n",
    "print(x*x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el ejemplo arriba, yo he ingresado 42 a mano.\n",
    "\n",
    "Veamos otro ejemplo donde ingreso una oracion e imprimo el cuarto valor de la lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese una oracion: Esta es mi oracion\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "x = list(input(\"Ingrese una oracion: \"))\n",
    "\n",
    "print(x[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El cuarto caracter de la oración es \"a\". \n",
    "\n",
    "Finalmente, esas funciones pueden ser usadas en otros contextos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El numero es : 42981\n"
     ]
    }
   ],
   "source": [
    "x = 42981\n",
    "\n",
    "y = str(x)\n",
    "\n",
    "y = \"El numero es:\" + y\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe lo que sucede si no ponemos `str(x)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-14-81049af59ac2>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"El numero es: \"\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "x = 42981\n",
    "\n",
    "y = x\n",
    "\n",
    "y = \"El numero es: \" + y\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### Ejercicios\n",
    "\n",
    "1. Realice un script que pida dos enteros al usuario e imprima el producto.\n",
    "\n",
    "2. El Indice de Masa Corporal (IMC) de una persona se calcula dividiendo el peso de la persona en kilogramos por el cuadrado de su altura en metros. Josias mide aproximadamente 185 cm, pida al usuario que ingrese un posible valor para el peso de Josias e imprima el IMC de Josias utlizando ese valor.\n",
    "\n",
    "3. Pida al usuario que ingrese su peso en kg y su altura en cm e imprima el IMC del usuario.\n",
    "\n",
    "4. Realice un script que pida un entero de dos dígitos al usuario e imprima la suma de sus dígitos."
   ]
  }
 ],
 "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
}