Introducción a Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OpSHrtcJLQEU"
   },
   "source": [
    "# Introducción a Python\n",
    "\n",
    "A lo largo de este _Jupyter Notebook_ explicaré algunos básicos de Python. Los tópicos específicos a cubrir en este cuaderno interactivo son los siguientes:\n",
    "\n",
    "> - ¿Qué es Python? \n",
    "> - _Variables_ – Tipos, conversión y operación\n",
    "> - Control de flujo I – _Condicionales_ y _ciclos_\n",
    "> - Objetos avanzados – _Listas_\n",
    "> - Control de flujo II – _Ciclos_\n",
    "\n",
    "\n",
    "## ¿Qué es Python?\n",
    "\n",
    "<center>\n",
    "    <img width=\"50%\" src=\"https://www.python.org/static/community_logos/python-logo-generic.svg\">\n",
    "</center>\n",
    "\n",
    "Python es un lenguaje de programación **interpretado**, lo que significa que un _intérprete_ corre y ejecuta tu código línea por línea en vez compilar un programa para crear un archivo ejecutable, esto permite que podamos utilizar un cuaderno interactivo como éste. Python cuenta con una elegante sintaxis que nos obliga a **_indentar_ nuestro código para escribir bloques**, lo que significa que Python no utiliza `{ }` para bloques de código (como otros lenguajes). Con Python no es común utilizar `;` al final de caa sentencia. Otra cosa cool acerca de Python es que no necesitas declarar variables, sino que sólo las defines, y sucede que Python es de **tipado dinámico**.\n",
    "\n",
    "En esencia, Python es un lenguaje muy sencillo de aprender con el cual pueden realizarse muchas cosas. Es por ello que el lenguaje se utiliza en diversas instituciones y compañías como Harvard, Google o Instagram, en temas que van desde Introducción a la Programación, hasta Ciencia de Datos e Inteligencia Artificial.\n",
    "\n",
    "### `¡Hola mundo!` en Python\n",
    "\n",
    "`input()` y `print()` son las funciones de entrada y salida (respectivamente) de información en Python. `input()` tiene como argumento una cadena de texto que da las instrucciones que se deseas desplegar y lo que retorna (la respuesta) siempre es una cadena de texto; mientras que `print()` tiene como argumentos cadenas de texto o variables que se desean desplegar.\n",
    "\n",
    "Vamos a utilizar las funciones de entrada y salida para crear nuestro primer programa, el famoso `¡Hola mundo!` en Python.\n",
    "\n",
    "Para ello, sólo basta correr la siguiente celda de código presionando el botón _play_ o presionando `Shift + Enter` en tu teclado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lBy00gJgHaQo"
   },
   "outputs": [],
   "source": [
    "# ¡Hola mundo! en Python:\n",
    "tu_nombre = input(\"Porfa ingresa tu nombre: \")\n",
    "print(f\"¡Saluda al mundo, {tu_nombre}!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RSJW87sPXOAh"
   },
   "source": [
    "## Variables\n",
    "\n",
    "Podemos pensar que una variable es como un contenedor de información. Python puede albergar distintos tipos de datos, como valores numéricos, _booleanos_ y cadenas de texto. Al ser Python de tipado dinámico, no hace falta declarar el tipo de variable, sino que sólo basta con definir sus valores.\n",
    "\n",
    "Comenzando con variables numéricas, Python tiene números enteros, números de punto flotante y números complejos. También cuenta con cadenas de caracteres para definir palabras y otro tipo de variables llamadas _booleanas_ para almacenar variables binarias.\n",
    "\n",
    "La manera en la que definimos variables es como sigue:\n",
    "\n",
    "```python\n",
    "nombre_de_variable = <value>\n",
    "```\n",
    "\n",
    "El nombre de la variable no puede contener espacios, debe comenzar con una letra, y puede contener letras mayúsculas o números en el nombre.\n",
    "\n",
    "#### Ejemplo:\n",
    "\n",
    "```python\n",
    "mi_perrito = \"Mirlo\"\n",
    "```\n",
    "\n",
    "Para obener el tipo de una variable, podemos utilizar la función `type()` y pasarle como argumento la variable sobre la cual queremos conocer el nombre.\n",
    "\n",
    "#### Ejemplo:\n",
    "\n",
    "```python\n",
    "type(mi_perrito)\n",
    "```\n",
    "\n",
    "¿Qué sucede si estos códigos de ejemplo son ejecutados?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8i5sDqw-XUJP"
   },
   "outputs": [],
   "source": [
    "# TODO.\n",
    "# Declara una variable llamada mi_perrito y almacena el nombre de un perrito\n",
    "# Imprime el tipo de esa variable\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nlMAcIGEYIef"
   },
   "source": [
    "Existen diversos tipos de variables en Python, ¡incluso números complejos!\n",
    "\n",
    "#### Ejercicio:\n",
    "\n",
    "Define e imprime el tipo y valor de variables llamadas:\n",
    "- `nombre`, debe ser de tipo `<str>` conteniendo cualquier nombre\n",
    "- `edad`, debe ser de tipo `<int>` conteniendo cualquier edad\n",
    "- `pi`, debe ser de tipo `<float>`conteniendo tu mejor aproximación de pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RmbbjQIqYT6i"
   },
   "outputs": [],
   "source": [
    "# TODO.\n",
    "# Define variables ejemplo e imprime cada tipo y valor\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operaciones básicas\n",
    "\n",
    "En esencia hay tres tipos de operaciones que pueden realizarse con variables para declarar sentencias:\n",
    "\n",
    "- **Operaciones aritméticas.** Operan a nivel matemático-aritmético sobre los valores de las variables (`+, -, *, /, //, **, %`).\n",
    "- **Operaciones de comparación.** Operan a nivel matemático-de-comaración sobre los valores de las variables (`<, >, <=, >=, ==, !=`).\n",
    "- **Operaciones lógicas.** Operan a nivel matemático-lógico sobre los valores de las variables (`and, or, not`).\n",
    "\n",
    "\n",
    "#### Ejemplo:\n",
    "\n",
    "```python\n",
    "print(34 ** 5)\n",
    "print(5 ** 2)\n",
    "print(12345678 % 2)\n",
    "print(26 >= 18)\n",
    "```\n",
    "\n",
    "¿Qué sucede si ejecutamos esas líneas de código?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO.\n",
    "# Imprime las operaciones con variables mencionadas\n",
    "# Experimenta con otras operaciones\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "U_cKNLU3YnP8"
   },
   "source": [
    "## Control de flujo – Condicionales\n",
    "\n",
    "Los condicionales los utilizaremos para validar si se cumple una o más condiciones para ejecutar cierto bloque de código, en esencia nos ayuda a tomar decisiones sobre el flujo de nuestro código.\n",
    "\n",
    "Hasta ahora sabemos cómo definir variables, así que debemos ser capaces de crear bloques de código un poco más complejos. La primera cosa que haremos es crear una nueva variable llamada `menor_de_edad` y la definiremos con una expresión condicional. Para ello, será util recordar operadores de comparación (`<, >, <=, >=, ==, !=`).\n",
    "\n",
    "La idea es la siguiente: si una persona es menor de edad, el valor de la variable será `True`, y será `False` en caso contrario.\n",
    "\n",
    "Para declarar una expresión condicional, utilizamos la siguiente sintaxis de código:\n",
    "\n",
    "```python\n",
    "if condicion:\n",
    "    # Bloque de código para una condición satisfecha\n",
    "else:\n",
    "    # Bloque de código para una condición NO satisfecha\n",
    "```\n",
    "\n",
    "#### Ejemplo:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9oJook66anxJ"
   },
   "outputs": [],
   "source": [
    "color_del_perrito = \"negro\"\n",
    "if color == \"negro\":\n",
    "    print(\"Es correcto, este perrito es negro.\")\n",
    "else:\n",
    "    print(\"No, definitivamente no es un perrito negro.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XYjNLN8VjFfK"
   },
   "source": [
    "Para el caso en que queramos verificar más de una condición, podemos utilizar sentencias `elif`:\n",
    "\n",
    "```python\n",
    "if condicion_uno:\n",
    "    # Bloque de código para una condición uno satisfecha\n",
    "elif condicion_dos:\n",
    "    # Bloque de código para una condición dos satisfecha\n",
    "...\n",
    "elif condicion_n:\n",
    "    # Bloque de código para una condición n-ésima satisfecha\n",
    "else:\n",
    "    # Bloque de código para condiciones NO satisfechas\n",
    "```\n",
    "\n",
    "#### Ejercicio:\n",
    "\n",
    "Ahora crea una condición para definir la variable `menor_de_edad` que compare si una edad es mayor o igual a 18 para definirla como `False` o `True` en caso contrario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xcu423b2liUI"
   },
   "outputs": [],
   "source": [
    "# TODO.\n",
    "# Escribe un condicional para definir una edad\n",
    "\n",
    "edad = input(\"Introduce tu edad: \")\n",
    "edad = int(edad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rhmQtvUmnNNx"
   },
   "source": [
    "Antes de continuar a la segunda parte sobre control de flujo (ciclos), será útil entender qué es una lista en Python.\n",
    "\n",
    "## Listas y colecciones de datos\n",
    "\n",
    "Una lista es una colección ordenada de cualquier tipo de variable. La sintaxis utilizada para ello es la siguiente:\n",
    "\n",
    "```python\n",
    "nombre_de_lista = [primer_elemento, segundo_elemento, etcetera]\n",
    "```\n",
    "\n",
    "Las reglas para nombrar listas son las mismas que para nombrar variables. \n",
    "\n",
    "También podemos declarar listas vacías y llenarlas conforme se realiza un proceso o añadir un elemento nuevo conforme se realiza un proceso. Una lista vacía se define con corchetes vacíos `[]`. Si queremos agregar un nuevo elemento al final de una lista, utilizaremos la función `.append(x)`, donde `x` sería el elemento a insertar.\n",
    "\n",
    "#### Ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5f8xkD-VoerM"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de una lista:\n",
    "numeros_primos = [2, 3, 5, 7, 11]\n",
    "print(\"Lista inicial de números primos:\")\n",
    "print(numeros_primos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numeros_primos.append(13)\n",
    "print(\"Lista editada de números primos:\")\n",
    "print(numeros_primos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yP1GTen8ovX9"
   },
   "source": [
    "Para acceder a los valores o elementos de una lista usamos un sistema de _indexación_, lo que significa que cada elemento tiene un índice asociado. Para acceder al elemento asociado, usaremos el índice dentro de corchetes.\n",
    "\n",
    "#### Ejemplo:\n",
    "\n",
    "En nuestra lista `numeros_primos` obtendríamos los siguientes elementos como sigue:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xAevC47uqN7i"
   },
   "outputs": [],
   "source": [
    "# Accedemos a los elementos:\n",
    "print(\"Primer elemento:\", numeros_primos[0])\n",
    "print(\"Segundo elemento:\", numeros_primos[1])\n",
    "print(\"Tercer elemento:\", numeros_primos[2])\n",
    "\n",
    "# Podemos incluso acceder a los elementos utilizando índices negativos:\n",
    "print(\"Último elemento: \", numeros_primos[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WaNJemIwq419"
   },
   "source": [
    "#### Ejercicio:\n",
    "\n",
    "Deberíamos ser capaces de crear una lista llamada `open_data` conteniendo los nombres de los asistentes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nMCLlFAerDWG"
   },
   "outputs": [],
   "source": [
    "# TODO.\n",
    "# Crear una nueva lista con todos los nombres\n",
    "open_data = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Gz2JkK8DrRIc"
   },
   "source": [
    "Ahora añade a dos nuevos estudiantes (puedes inventar los nombres)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1d-CEterrZL6"
   },
   "outputs": [],
   "source": [
    "# TODO.\n",
    "# Usa la función append para añadir a dos nuevos estudiantes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hkoa6UOarhBD"
   },
   "source": [
    "> Hasta este punto haremos una pausa para hacer énfasis en la utilidad de listas como una colección de objetos. Los datos abiertos que estaremos trabajando seguirán (en esencia) éste formato.\n",
    "\n",
    "## Control de flujo – Ciclos\n",
    "\n",
    "**Iterar** significa ejecutar el mismo  bloque de código una y otra vez, potencialmente muchas veces. Una estructura de programación que implementa una iteración o un bloque de iteraciones es llamada un **ciclo**.\n",
    "\n",
    "### Ciclo `for`\n",
    "\n",
    "Python tiene un ciclo basado en colecciones. Este tipo de ciclo itera sobre una colección de objetos, en lugar de especificar valores o condiciones numéricos:\n",
    "\n",
    "```python\n",
    "for elemento in coleccion:\n",
    "    <loop body>\n",
    "```\n",
    "\n",
    "#### Ejemplo:\n",
    "\n",
    "Podemos iterar e imprimir los elementos de una lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RFk0YLulqOQW"
   },
   "outputs": [],
   "source": [
    "from time import sleep\n",
    "\n",
    "meses = [\n",
    "    'Enero',\n",
    "    'Febrero',\n",
    "    'Marzo',\n",
    "    'Abril',\n",
    "    'Mayo',\n",
    "    'Junio',\n",
    "    'Julio',\n",
    "    'Agosto',\n",
    "    'Septiembre',\n",
    "    'Octubre',\n",
    "    'Noviembre',\n",
    "    'Diciembre',\n",
    "]\n",
    "\n",
    "for mes in meses:\n",
    "    print(f\"> El mes actual es {mes}.\")\n",
    "    sleep(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OHMgj3aavIqc"
   },
   "source": [
    "O podemos simplemente iterar sobre un rango de números:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nevHbKcsvIBa"
   },
   "outputs": [],
   "source": [
    "for numero in range(10):\n",
    "    print(f\"El número actual es {numero}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7Ko9pJ0_vrnb"
   },
   "source": [
    "##### Nota: \n",
    "*¿Qué hay acerca de las tuplas u otro tipo de colecciones?*\n",
    "\n",
    "Ahora que sabemos iterar sobre elementos en una lista, imprimamos de manera ordenada los elementos de nuestra lista `open_data`, previamente definida."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PZTz7Shhrs1M"
   },
   "outputs": [],
   "source": [
    "# TODO.\n",
    "# Usa un ciclo para imprimir los nombres de los asistentes en open_data\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "include_colab_link": true,
   "name": "Intro to Python",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}