01 - Tipos de datos y operadores.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tipos de datos y operadores\n",
    "\n",
    "## Tipos de datos\n",
    "\n",
    "Se usan para representar valores que usamos en nuestros cálculos y procedimientos.\n",
    "\n",
    "`int` -> se usa para representar enteros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "num_images = 20\n",
    "num_students = 26\n",
    "num_variables = 33\n",
    "dataset_size = 98234\n",
    "amount_of_money = -70"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "`float` -> se usa para representar números con decimales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "pi = 3.1416\n",
    "learning_rate = 0.0001\n",
    "scale_factor = 1.2\n",
    "probability_of_approval = 0.5\n",
    "probability_of_approval_after_studing = 0.9\n",
    "probability_of_approval_after_studing_harder = 0.99"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Escribiendo esto caí en la cuenta de que los flotantes tienen un *método* para obtener el numerador y denominador de su representación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 0.5\n",
    "a.as_integer_ratio()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por ahora, postergaremos la discusión sobre lo que es un método, pero usaremos algunos útiles mientras tanto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "`bool` -> se usa para representar valores de falso y verdadero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "life_is_hard = True\n",
    "you_must_pause_and_think = True\n",
    "follow_your_instinct = False\n",
    "follow_data = True\n",
    "you_already_know_everything = False\n",
    "you_must_keep_learning = True\n",
    "money_is_all_that_matters = False\n",
    "helping_is_showing_answers = False\n",
    "you_can_pass_without_projects = False\n",
    "you_can_pass_without_comming_to_class = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "`str` -> se usa para representar texto "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Sebastián\"\n",
    "last_name = \"Rodríguez Colina\"\n",
    "activation = \"relu\"\n",
    "name_of_course = \"Fundamentos de programación para ciencia de datos\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python utiliza codificación `utf-8` por defecto, lo cual permite representar muchos caracteres (como letras con tildes). No todos los sistemas utilizan el mismo tipo de codificación y vale la pena que tengas esto presente. Te sugiero leer [Unicode & Character Encodings in Python: A Painless Guide](https://realpython.com/python-encodings-guide/), [Python String encode()](https://www.programiz.com/python-programming/methods/string/encode#:~:text=The%20string%20encode()%20method,sequence%20of%20Unicode%20code%20points.) y [Unicode HOWTO](https://docs.python.org/3/howto/unicode.html).\n",
    "\n",
    "Los tipos `str` vienen con unos métodos bastante útiles para trabajar con ellos, acá unos ejemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SABER PROGRAMAR EN PYTHON ES MUY IMPORTANTE!'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"saber programar en python es muy importante!\".upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sebastian'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"sebastian\".capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"otorrinolaringologo\".count(\"go\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"quiero saber si empiezo con [cualquier string]\".startswith(\"hola\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Dr. Julanito\".startswith(\"Dr.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"students paying attention: 20%\".endswith(\"%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"str\".isidentifier()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"333\".isdecimal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Nombre', 'Apellido1', 'Appellido2']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Nombre Apellido1 Appellido2\".split(\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "los `str` también pueden ser indexados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'has '"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Muchas palabras \"[3:7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Muchas '"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Muchas palabras \"[:7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Muchas pa'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Muchas palabras \"[:-7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' sarbalap sahcuM'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Muchas palabras \"[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Revisa la documentación oficial para ver más](https://docs.python.org/3/library/stdtypes.html#string-methods)\n",
    "\n",
    "---\n",
    "`None` -> se usa para decir que no hay ningún valor asignado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "best_student = None\n",
    "worst_student = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Observaciones adicionales:**\n",
    "\n",
    "En este punto ya usamos el concepto de variable, simplemente es una manera de referenciar los valores con los que se ejecuta un programa. La variable es un espacio en la memoria del computador (usualmente RAM), diferente del disco duro. Entre más variables uses, y más valores contengan esas, más RAM usas.\n",
    "\n",
    "Las variables pueden escribirse con cualquier fomato (`comoEste` y `EsteOtro`), pero usualmente la comunidad de Python las escribe `en_el_formato_que_he_mostrado` y es bastante agradable seguir las convenciones cuando se habla de trabajo colaborativo; vale la pena mencionar, `esto` y `EstO` representan variables diferentes. Además, es importante saber que existe un estándar general de *estilo* para programar en python. En este se enmarca el nombramiento de variables, funciones, forma de identar, etc. Este estándar se llama [PEP8](https://www.python.org/dev/peps/pep-0008/).\n",
    "\n",
    "Finalmente, con respecto a las variables, nunca podrás usar una [palabra reservada de Pyhton](https://www.programiz.com/python-programming/keyword-list), pero también se recomienda no usar nombres propios de tipos de datos the pyhton.\n",
    "\n",
    "## Operadores\n",
    "\n",
    "Nos permiten ejecutar distintas operaciones en pares de valores, el comportamiento de los operadores depende de los valores con los que se estén llamando. Acá veremos unos ejemplos, pero te recomiendo ver [una lista más completa](https://www.w3schools.com/python/python_operators.asp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6 / 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 // 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 % 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True, False, False, True)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "edad = 18\n",
    "edad == 18, edad < 20, edad > 30, edad <= 12, edad >= 18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and True, True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or True, True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Se puede con cadenas de caracteres, Se puede con cadenas de caracteres, Se puede con cadenas de caracteres, '"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Se puede con cadenas de caracteres, \"* 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[45, 45, 45, 45, 45, 45, 45]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[45] * 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imprimiendo valores y formateando cadenas de texto\n",
    "\n",
    "Antes de seguir adelante, vamos a revisar cómo imprimir valores en el entorno de ejecución que estemos usando (por ahora, jupyter notebook) y cómo darle formato a lo que imprimimos.\n",
    "\n",
    "Para imprimir, podemos usar la *función* `print`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "esto es una cadena de caracteres\nesto también es una cadena de caracteres\nnotar cómo implementar \"comillas\" dobles como caracteres\nnotar cómo implementar 'comillas' simples como caracteres\n"
     ]
    }
   ],
   "source": [
    "print(\"esto es una cadena de caracteres\")\n",
    "print('esto también es una cadena de caracteres')\n",
    "print('notar cómo implementar \"comillas\" dobles como caracteres')\n",
    "print(\"notar cómo implementar 'comillas' simples como caracteres\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['también', 'puedo', 'imprimir', 'listas']\n"
     ]
    }
   ],
   "source": [
    "print([\"también\", \"puedo\", \"imprimir\", \"listas\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n"
     ]
    }
   ],
   "source": [
    "y_numeros = 40\n",
    "print(y_numeros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Realmente se puede imprimir cualquier objeto, aunque no todos tienen una representación bonita.\n",
    "\n",
    "Hasta ahora podrías pensar que no hay diferencia entre usar o no usar `print`, dado que los ejemplos anteriores se imprimían sin necesidad de usarlo; sin embargo, esto se debe a que `jupyter notebook` internamente se encarga de imprimir lo último que pones en una celda, esto no funcionaría ejecutando código de python en otro entorno y no funciona si lo que quieres imprimir no está al final de la celda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "edad = 40\n",
    "edad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "edad\n",
    "edad = 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "print(edad)\n",
    "edad = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "edad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora veamos como dar un poco de formato al texto que imprimimos, solo veremos la sintaxis, pero te recomiendo [leer más del tema](https://pyformat.info/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Edad promedio de los estudiantes: {}'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "texto = \"Edad promedio de los estudiantes: {}\"\n",
    "texto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Edad promedio de los estudiantes: 24'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "texto.format(24)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Edad promedio con una 'f' al principio: 24\""
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "edad = 24\n",
    "f\"Edad promedio con una 'f' al principio: {edad}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{variable_name} promedio con campos nombrados: {edad}'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "texto = \"{variable_name} promedio con campos nombrados: {edad}\"\n",
    "texto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Edad promedio con campos nombrados: 56'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "texto.format(variable_name=\"Edad\", edad=56)"
   ]
  }
 ],
 "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.3-final"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}