Intro a Python

intro-a-python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Intro a Python",
      "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/gist/RodolfoFerro/a031fc10cd6539f90341cc63cff119e8/intro-a-python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OpSHrtcJLQEU"
      },
      "source": [
        "# Introducción a Python\n",
        "\n",
        "A lo largo de este cuaderno explicaremos algunos conceptos básicos de Python. Los temas específicos que cubriremos en estos cuadernos introductorios son los siguientes:\n",
        "\n",
        "1. ¿Qué es Python?\n",
        "2. _Variables_: tipos, declaraciones y operaciones\n",
        "3. _Control de flujo_ - Condicionales y bucles\n",
        "4. Objetos avanzados: _Listas_ y _diccionarios_\n",
        "5. Empaquetando código - _Funciones_\n",
        "\n",
        "### Planteamiento del problema:\n",
        "\n",
        "Imagina que queremos crear un directorio que contenga toda la información de los estudiantes de nuestro club. Para ello, necesitaremos construir paso a paso la idea completa del proyecto.\n",
        "\n",
        "Para ello, necesitamos saber sobre tipos de variables, objetos avanzados como listas y diccionarios, cómo crear funciones para operar algunos valores y cómo crear nuevos objetos.\n",
        "\n",
        "> #### ¿Qué tenemos que hacer?\n",
        ">\n",
        "> En concreto, vamos a hacer lo siguiente:\n",
        "> - Crearemos una lista de diccionarios que contienen la información de los estudiantes\n",
        "> - Cada diccionario contendrá los siguientes atributos:\n",
        ">     - Nombre `<str>`\n",
        ">     - Edad `<int>`\n",
        ">     - Temas `<lista>`\n",
        ">     - Menores de edad `<bool>`\n",
        "> - Crea una función que solicita automáticamente información del estudiante\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 _interpretador_ ejecuta y ejecuta su código línea por línea en lugar de compilarlo. Python tiene una sintaxis elegante que te obliga a **aplicar sangría a tu código para construir bloques de código**, por lo que Python no usa `{}` para bloques de código. No es común usar punto y coma en Python (`;`) al final de cualquier oración. Otra cosa interesante de Python es que no necesita declarar variables, solo las define, y sucede que Python **se escribe dinámicamente**.\n",
        "\n",
        "### Hola mundo en Python\n",
        "\n",
        "Usaremos las funciones de entrada y salida de Python para crear nuestro primer hola mundo.\n",
        "\n",
        "Solo necesita ejecutar la siguiente celda con código presionando el botón _play_ o presionando `Shift + Enter` en su teclado."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lBy00gJgHaQo"
      },
      "source": [
        "# Hello world in Python:\n",
        "your_name = input(\"Please write your name: \")\n",
        "print(f\"Say hello to the world, {your_name}!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RSJW87sPXOAh"
      },
      "source": [
        "## Variables\n",
        "\n",
        "Python tiene varios tipos de variables de forma nativa. Comenzando con variables numéricas, Python puede trabajar con números enteros, números flotantes y números complejos. También cuenta con cadenas de caracteres para trabajar con texto y otro tipo de variables llamadas booleanos para guardar valores binarios.\n",
        "\n",
        "La forma en que declaramos las variables es la siguiente:\n",
        "\n",
        "```python\n",
        "variable_name = <value>\n",
        "```\n",
        "\n",
        "El nombre de una variable no puede tener espacios, debe comenzar con una letra, puede contener letras mayúsculas o números dentro del nombre.\n",
        "\n",
        "#### Ejemplo:\n",
        "\n",
        "```python\n",
        "my_dog = \"Mirlo\"\n",
        "```\n",
        "\n",
        "Para obtener el tipo de una variable, podemos usar la función `type ()` y pasar como parámetro la variable que queremos conocer.\n",
        "\n",
        "#### Ejemplo:\n",
        "\n",
        "```python\n",
        "type(my_dog)\n",
        "```\n",
        "\n",
        "\n",
        "¿Qué sucede si ejecuto el bloque previo de código?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8i5sDqw-XUJP"
      },
      "source": [
        "# TODO.\n",
        "# Declare a variable named my_dog and set it with a dog's name.\n",
        "# Print the type of that variable.\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nlMAcIGEYIef"
      },
      "source": [
        "Hay varios tipos de variables, ¡incluso números complejos en Python!\n",
        "\n",
        "#### Ejercicio:\n",
        "\n",
        "Define e imprime el tipo y valor de las variables denominadas:\n",
        "- `name`, debe ser un` <str> `que contenga cualquier nombre\n",
        "- `age`, debe ser un` <int> `que contenga cualquier edad\n",
        "- `pi`, debe ser un` <float> `que contenga su mejor aproximación a pi\n",
        "- `modulus_one`, debe ser un `<complex>`que tiene [módulo](https://en.wikipedia.org/wiki/Absolute_value#Complex_numbers) uno"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RmbbjQIqYT6i"
      },
      "source": [
        "# TODO.\n",
        "# Define sample variables and print each type and value.\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U_cKNLU3YnP8"
      },
      "source": [
        "## Control de flujo (condicionales)\n",
        "\n",
        "Hasta ahora, sabemos cómo definir variables, por lo que podemos crear bloques de código un poco más avanzados. Lo primero que queremos hacer es crear una nueva variable llamada `under_age` y necesitaremos definirla usando una declaración contitional. Para ello, será útil recordar los operadores de comparación (`<, >, <=, >=, ==, !=`).\n",
        "\n",
        "La idea es la siguiente, si la persona es menor de edad, el valor de esta variable será \"Verdadero\" y será \"Falso\" en el otro caso.\n",
        "\n",
        "Para declarar una declaración condicional, se usa la siguiente sintaxis:\n",
        "\n",
        "```python\n",
        "if condition:\n",
        "    # Block of code for a satisfied condition \n",
        "else:\n",
        "    # Block of code for a non-satisfied condition \n",
        "```\n",
        "\n",
        "#### Ejemplo:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9oJook66anxJ"
      },
      "source": [
        "dog_color = \"black\"\n",
        "if color == \"black\":\n",
        "    print(\"Indeed, this dog is black.\")\n",
        "else:\n",
        "    print(\"Nope, it is not a black dog.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XYjNLN8VjFfK"
      },
      "source": [
        "En el caso de tener más de una condición, podemos usar declaraciones `elif`:\n",
        "\n",
        "```python\n",
        "if condition_one:\n",
        "    # Block of code for a satisfied condition one\n",
        "elif condition_two:\n",
        "    # Block of code for a satisfied condition two\n",
        "...\n",
        "elif condition_nth:\n",
        "    # Block of code for a satisfied condition nth\n",
        "else:\n",
        "    # Block of code for non-satisfied conditions\n",
        "```\n",
        "\n",
        "#### Ejercicio:\n",
        "\n",
        "Ahora crea una condición para definir una nueva variable llamada `under_age` que comparará si la edad es mayor o igual a 18 para establecerla como \"Falso\" o \"Verdadero\" en el otro caso."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xcu423b2liUI"
      },
      "source": [
        "# TODO.\n",
        "# Write a conditional to set the age.\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rhmQtvUmnNNx"
      },
      "source": [
        "## Listas\n",
        "\n",
        "Una lista es una colección ordenada de cualquier tipo de variables. La sintaxis utilizada para la lista es la siguiente:\n",
        "\n",
        "```python\n",
        "list_name = [first_element, second_element, etcetera]\n",
        "```\n",
        "\n",
        "Las reglas de nomenclatura son las mismas que para otras variables.\n",
        "\n",
        "Puedes declarar una lista vacía simplemente estableciendo corchetes `[]`. Si desea agregar un elemento al final de una lista, usamos el método `.append (x)`, donde `x` sería el elemento que queremos insertar.\n",
        "\n",
        "#### Ejemplo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5f8xkD-VoerM"
      },
      "source": [
        "# Example list:\n",
        "prime_numbers = [2, 3, 5, 7, 11]\n",
        "print(prime_numbers)\n",
        "prime_numbers.append(13)\n",
        "print(prime_numbers)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yP1GTen8ovX9"
      },
      "source": [
        "Para acceder a los valores de una lista, utilizamos la indexación, lo que significa que cada elemento tiene un índice asociado. Para acceder al elemento asociado usaremos el índice entre corchetes.\n",
        "\n",
        "####Ejemplo:\n",
        "\n",
        "En nuestros `prime_numbers` obtendríamos los elementos correspondientes de la siguiente manera:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xAevC47uqN7i"
      },
      "source": [
        "# We can access the elements:\n",
        "print(\"First element: \", prime_numbers[0])\n",
        "print(\"Second element: \", prime_numbers[1])\n",
        "print(\"Third element: \", prime_numbers[2])\n",
        "\n",
        "# We can even access using negative indices:\n",
        "print(\"Last element: \", prime_numbers[-1])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WaNJemIwq419"
      },
      "source": [
        "#### Ejercicio:\n",
        "\n",
        "Ahora, deberías poder crear una lista llamada `clubes_online` que contenga los nombres de los miembros de su club."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nMCLlFAerDWG"
      },
      "source": [
        "# TODO.\n",
        "# Create a new list containing all the names.\n",
        "clubes_online = []"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gz2JkK8DrRIc"
      },
      "source": [
        "Ahora agrega dos nuevos estudiantes (puedes inventar sus nombres)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1d-CEterrZL6"
      },
      "source": [
        "# TODO.\n",
        "# Append two new students called 'Brent' and 'Rodolfo'."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hkoa6UOarhBD"
      },
      "source": [
        "## Bucles (ciclos)\n",
        "\n",
        "**Iteración** significa ejecutar el mismo bloque de código una y otra vez, potencialmente muchas veces. Una estructura de programación que implementa la iteración se llama **bucle** (o **ciclo**).\n",
        "\n",
        "Hay dos tipos de iteración:\n",
        "- **Iteración definida**, en la que el número de repeticiones se especifica explícitamente de antemano\n",
        "- **Iteración indefinida**, en la que el bloque de código se ejecuta hasta que se cumple alguna condición\n",
        "\n",
        "En Python, la iteración indefinida se realiza con un ciclo `while` y la iteración definida se realiza con un ciclo `for`.\n",
        "\n",
        "### Ciclo `while`\n",
        "\n",
        "Para un ciclo `while` será importante **establecer una condición de parada**. El formato de un ciclo `while` se muestra a continuación:\n",
        "\n",
        "```python\n",
        "while condition:\n",
        "    # Code goes ehre!\n",
        "```\n",
        "\n",
        "#### Ejemplo:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SSnssdYwqI_G"
      },
      "source": [
        "n_interation = 1\n",
        "\n",
        "while n_iteration <= 10:\n",
        "    print(f\"Iteration {n_iteration}.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xJFl2lQ1qJak"
      },
      "source": [
        "### Ciclo `for`\n",
        "\n",
        "Python tiene un **ciclo basado en colecciones** o **ciclo basado en iteradores**. Este tipo de bucle itera sobre una colección de objetos, en lugar de especificar valores numéricos o condiciones:\n",
        "\n",
        "```python\n",
        "for i in <collection>:\n",
        "    <loop body>\n",
        "```\n",
        "\n",
        "#### Ejemplo:\n",
        "\n",
        "Podemos iterar a través de los elementos de una lista:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RFk0YLulqOQW"
      },
      "source": [
        "months = [\n",
        "    'January',\n",
        "    'February',\n",
        "    'March',\n",
        "    'April',\n",
        "    'May',\n",
        "    'June',\n",
        "    'July',\n",
        "    'August',\n",
        "    'September',\n",
        "    'October',\n",
        "    'November',\n",
        "    'December',\n",
        "]\n",
        "\n",
        "for month in months:\n",
        "    print(f\"The current month is {month}.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OHMgj3aavIqc"
      },
      "source": [
        "O iterar solo a través de un rango de números:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nevHbKcsvIBa"
      },
      "source": [
        "for number in range(10):\n",
        "    print(f\"The current number is {number}.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7Ko9pJ0_vrnb"
      },
      "source": [
        "**Nota:** *¿Todo esto aplica para las tuplas?*\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "------"
      ],
      "metadata": {
        "id": "cqUL_WR0UJNV"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DZOOUM4jrn5O"
      },
      "source": [
        "## Diccionarios\n",
        "\n",
        "Python proporciona otro tipo de datos compuestos llamado **diccionario**, que es similar a una lista en que es una colección de objetos.\n",
        "\n",
        "Los diccionarios son diferentes de las listas principalmente por cómo acceder a sus elementos:\n",
        "\n",
        "- Se accede a los elementos de la lista por su posición en la lista, mediante indexación.\n",
        "- Se accede a los elementos del diccionario mediante llaves o claves (pares clave-valor)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FNo_LTSuzEvk"
      },
      "source": [
        "student = {\n",
        "    \"name\": \"Rodolfo Ferro\"\n",
        "    \"email\": \"ferro@cimat.mx\"\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i6I0b2UkzcJb"
      },
      "source": [
        "## Funciones\n",
        "\n",
        "Las funciones nos permitirán empaquetar código que puede ser invocado a través de una línea con el nombre de la función.\n",
        "\n",
        "La estructura básica de una función es como sigue:\n",
        "\n",
        "```python\n",
        "def name_of_function(arguments):\n",
        "    # Code of the function\n",
        "\n",
        "    return something\n",
        "```\n",
        "\n",
        "La nomenclatura de las funciones es consistente con la de las variables."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PZTz7Shhrs1M"
      },
      "source": [
        "# Implement the 2nd of the Newton's laws of motion\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1y8uhVgk0LfN"
      },
      "source": [
        "## Módulos y paquetes\n",
        "\n",
        "Así como hemos estado avanzando, las funciones nos permitirán continuar avanzando en empaquetar aún más algunos blñoques de código, puesto que varias funciones y objetos más robustos pueden escribirse en archivos de código fuente que puede ser _importado_ para uso directo en nuestros programas de día a día.\n",
        "\n",
        "Un ejemplo de ello es el módulo `random`, que cuenta con funciones para generar números aleatorios y que exploraremos a continuación:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_n-4U4r00RLs"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d0tk7XbG0tnu"
      },
      "source": [
        "Una gran ventaja que tiene Python sobre otros lenguajes de programación (y que contribuye a que el lenguaje sea tan utilizado para muchas cosas), es el hecho de que cuenta con una gran comunidad de personas que contribuyen a paquetes robustos para áreas específicas, como cómputo numérico, cómputo cuántico, inteligencia artificial, astrofísica, imagenología biomédica y muchas, muchas cosas más.\n",
        "\n",
        "En los siguientes dos módulos exploraremos un par con algunos ejemplos y aplicaciones interesantes.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w7DrerwS1zd_"
      },
      "source": [
        "## ¡A resolver el reto!\n",
        "\n",
        "Vamos a prodecer a crear una lista de diccionarios, esto es, un directorio de estudiantes de Clubes de Ciencia que participarán en una edición en línea.\n",
        "\n",
        "Cada estudiante debe tener los siguientes atributos:\n",
        "- Nombre <str>\n",
        "- Edad <int>\n",
        "- Temas <lista>\n",
        "- Menores de edad <bool>\n",
        "\n",
        "Puedes asignar los datos a mano o utilizar funciones aleatorias para llenar los campos."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SVynPZKD2RAm"
      },
      "source": [
        "# All your code goes here!!!"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "efpB7jYb3hQj"
      },
      "source": [
        "--------\n",
        "\n",
        "> Contenido creado por **Rodolfo Ferro** para [CdeCMx](https://clubesdeciencia.mx/), 2022. <br>\n",
        "> Puedes contactarme a través de Insta ([@rodo_ferro](https://www.instagram.com/rodo_ferro/)) o Twitter ([@rodo_ferro](https://twitter.com/rodo_ferro))."
      ]
    }
  ]
}