1.2. Coding en Python v1/1. Introduccion a Python (MIA UAI).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducción a Python\n",
    "\n",
    "En este Notebook vamos a aprender conceptos básicos de Python. Los contenidos son:\n",
    "\n",
    "- Valores y tipos básicos\n",
    "- Control de flujo\n",
    "- Funciones\n",
    "- Manejo de _strings_\n",
    "- Manejo de listas y diccionarios\n",
    "- Clases y métodos\n",
    "\n",
    "La idea es que esta sea una introducción rápida a Python para programadores que dominen otros lenguajes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Valores y tipos básicos\n",
    "\n",
    "En Python tenemos todos los tipos básicos de un lenguaje de programación como `integer`, `float`, `string`, `boolean`, entre otros. Vamos a ver ahora como definir variables y como operarlas entre ellas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "c = a + b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el programa anterior definimos dos variables `a` y `b` con valores `1` y `2` respectivamente. Ojo que estas variables son de tipo entero, pero no lo tenemos que señalar como pasa en otros lenguajes. Además podemos sumar estas dos variables y almacenarlas en en la variable `c`. Para imprimir un valor usamos la función `print`. Ahora vamos a ver un ejemplo de manejo de `strings`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "s1 = 'Hello'\n",
    "s2 = ' World'\n",
    "s3 = s1 + s2\n",
    "print(s3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí concatenamos dos variables de tipo `string` con el operador `+`. Ahora para terminar vamos a ver operadores lógicos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El valor de b3 es False\n",
      "El valor de b3 ahora es True\n",
      "El valor de b3 ahora es False\n"
     ]
    }
   ],
   "source": [
    "b1 = True\n",
    "b2 = False\n",
    "\n",
    "b3 = not(b1)\n",
    "print(f'El valor de b3 es {b3}')\n",
    "\n",
    "b3 = b1 or b2\n",
    "print(f'El valor de b3 ahora es {b3}')\n",
    "\n",
    "b3 = b1 and b2\n",
    "print(f'El valor de b3 ahora es {b3}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hay varias cosas por notar de este último ejemplo. Aquí estamos operando dos variables booleanas `b1`y `b2` y los resultados los vamos guardando en `b3`. Es muy importante notar que podemos sobrescribir el valor de b3.\n",
    "\n",
    "Las operaciones que estamos haciendo son: negación, `or` y `and`. Estas son operaciones lógicas que están en la mayoría de los lenguajes. Además las podemos combinar de diversas formas.\n",
    "\n",
    "Por último, tenemos que notar el uso de strings formateables (se antepone una `f` a los paréntesis). La idea de estos strings es que uno puede _inyectar_ valores de variables dentro de los paréntesis de llave `{ }`.\n",
    "\n",
    "Ahora vamos a pasar a estudiar control de flujo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control de Flujo\n",
    "\n",
    "Primero vamos a estudiar control de flujo con `if`, `elif` y `else`. Luego repasaremos ciclos con `while` y `for`.\n",
    "\n",
    "### If, elif y else\n",
    "\n",
    "Como en todo lenguaje de programación, podemos hacer un control de flujo del estilo _if, else if y else_. La _keyword_ para _else if_ es `elif`. Veamos un ejemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Ingrese un número entero:  7\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El usuario ingresó un número positivo\n"
     ]
    }
   ],
   "source": [
    "a = int(input('Ingrese un número entero: '))\n",
    "\n",
    "if a > 0:\n",
    "    print('El usuario ingresó un número positivo')\n",
    "elif a == 0:\n",
    "    print('El usuario ingresó un número igual a 0')\n",
    "else:\n",
    "    print('El usuario ingresó un número negativo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí estamos usando la función `input` para pedirle un número al usuario. Ojo que estamos asumiendo que va a ser un número entero. Además, `input` retorna un `string`, así que lo estamos transformando a entero con la función `int`.\n",
    "\n",
    "Luego viene la sección de control de flujo, en que imprimimos un mensaje distinto dependiendo del caso. Notamos que para esto usamos `if`, `elif` y `else` para separar los casos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While y for\n",
    "\n",
    "Podemos hacer una iteración clásica utilizando la _keyword_ `while`. Por ejemplo, veamos cómo imprimir los números del 1 al 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "while count <= 10:\n",
    "    print(count)\n",
    "    count += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí iniciamos un contador que vale 1, y lo incrementamos en 1 en cada iteración (con la instrucción `+=`). Vamos imprimiendo el valor actual de la variable `count` en cada iteración. Podemos hacer un programa que hace lo mismo con la instrucción `for`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 11):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí hacemos un `for` que itera desde el 1 (primer valor en la instrucción `range`) al 10 (la instrucción `range` llega hasta el segundo valor menos uno). La variable `i` va cambiando de valor en cada iteración. Finalmente, es bueno recordar la instrucción `break`, con la que podemos terminar un ciclo. Veamos un ejemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "count = 1\n",
    "while True:\n",
    "    print(count)\n",
    "    if count == 10:\n",
    "        break\n",
    "    count += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí hacemos lo mismo que en el primer `while`, solo que el `while` se ejecutará por siempre. Sin embargo, cuando el contador vale 10, entre en el `if` y rompe el _loop_ con la instrucción `break`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones\n",
    "\n",
    "Podemos definir funciones Python con la _keyword_ `def`. Es importante notar que no es necesario indicar el tipo de retorno ni el tipo de los argumentos. Veamos como ejemplo una función que retorna la suma de dos números."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "def sumar(a, b):\n",
    "    return a + b\n",
    "\n",
    "suma = sumar(1, 4)\n",
    "print(suma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Primero estamos declarando la función `sumar` que recibe dos argumentos `a` y `b`. Luego la estamos utilizando, entregando los valores 1 y 4. El resultado se guarda en la variable `suma` que después se imprime. También podemos entregar valores por defecto a las funciones. Veamos un ejemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "def sumar(a, b=0):\n",
    "    return a + b\n",
    "\n",
    "suma = sumar(2)\n",
    "print(suma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso, si llamamos a la función con un único parámetro se usará el valor por defecto de la variable `b` en la función, que es 0. Por eso al llamar a la función sumar con un único parámetro esta retorna 2, porque le estamos sumando 0 a 2. Ojo que los parámetros con valores por defecto siempre deben ir al final en la lista de argumentos de la función."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manejo de Strings\n",
    "\n",
    "Ya sabemos que podemos concatenar _strings_ con `+`, pero hay muchas funciones que nos conviene conocer. Vamos a ver primero cómo recorrer un _string_ y cómo obtener el largo de este."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El largo del string es 12\n",
      "----------\n",
      "Los caracteres del string son:\n",
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n",
      " \n",
      "W\n",
      "o\n",
      "r\n",
      "l\n",
      "d\n",
      "!\n"
     ]
    }
   ],
   "source": [
    "s = 'Hello World!'\n",
    "largo_s = len(s)\n",
    "\n",
    "print(f'El largo del string es {largo_s}')\n",
    "print('----------')\n",
    "print('Los caracteres del string son:')\n",
    "\n",
    "for c in s:\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notamos que el largo del _string_ se obtiene con `len`. Más aún, podemos recorrer el _string_ con un `for`. En este caso la línea `for c in s` lo que hace es iterar una vez por cada caracter en el _string_. El caracter actual se guarda en la variable `c`. Ahora bien, también podemos recorrer el _string_ por posiciones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n",
      " \n",
      "W\n",
      "o\n",
      "r\n",
      "l\n",
      "d\n",
      "!\n"
     ]
    }
   ],
   "source": [
    "s = 'Hello World!'\n",
    "for i in range(len(s)):\n",
    "    print(s[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso tenemos un par de cosas por notar. Primero, la variable `i` del `for` va tomando los valores que nos entrega la instrucción `range(len(s))`. Ahora la función `range` recibe un atributo, así que va a entregar valores desde el 0 hasta el largo del string (`len(s)`) menos 1. Para acceder el caracter en la posición `i` lo hacemos de la forma `s[i]`. \n",
    "\n",
    "**Recordemos que las posiciones van del 0 hasta el `len - 1`**. \n",
    "\n",
    "Ahora vamos a mostrar las funciones `strip` y `replace`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Hello World con espacios al inicio y al final   \n",
      "Hello World con espacios al inicio y al final\n",
      "Hello con espacios al inicio y al final\n"
     ]
    }
   ],
   "source": [
    "s = '  Hello World con espacios al inicio y al final   '\n",
    "print(s)\n",
    "s = s.strip()\n",
    "print(s)\n",
    "\n",
    "s = s.replace('World ', '')\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí lo que estamos haciendo con la función `strip` es recortar los espacios del inicio y del final. Con la función `replace` estamos reemplazando `'World '` por el _string_ vacío. Finalmente para obtener un _substring_ podemos usar _indexing_. Por ejemplo, si queremos el _substring_ de la posición `i` a la `j-1` de un _string_ `s`, podemos hacer `s[i:j]`. Veamos un ejemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y un st\n"
     ]
    }
   ],
   "source": [
    "s = 'Soy un string'\n",
    "subs = s[2:9]\n",
    "\n",
    "# Se van a imprimir los caracteres de la posición 2 a la 8\n",
    "print(subs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para más detalles sobre _strings_, puedes revisar el libro de Python que hemos preparado. Lo puedes encontrar [aquí](https://adriansoto.cl/resources)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listas y diccionarios\n",
    "\n",
    "### Listas\n",
    "\n",
    "Para definir una lista lo hacemos con el uso de paréntesis `[ ]`. Podemos agregar elementos con la función `append` y quitar elementos con la función `pop`. Veamos unos ejemplos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La lista ahora tiene los elementos [0, 1, 1, 2, 3, 5, 8, 13, 21]\n",
      "La lista ahora tiene los elemenots [0, 1, 1, 2, 5, 8, 13, 21]\n"
     ]
    }
   ],
   "source": [
    "l = [0, 1, 1, 2, 3, 5, 8, 13]\n",
    "\n",
    "l.append(21)\n",
    "print(f'La lista ahora tiene los elementos {l}')\n",
    "\n",
    "# Vamos a eliminar el elemento en la posición 4, que es el número 3\n",
    "l.pop(4)\n",
    "print(f'La lista ahora tiene los elemenots {l}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos recorrer las listas de la misma forma que un _string_. Veamos dos ejemplos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Forma 1:\n",
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "----------\n",
      "Forma 2:\n",
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n"
     ]
    }
   ],
   "source": [
    "print('Forma 1:')\n",
    "for element in l:\n",
    "    print(element)\n",
    "\n",
    "print('----------')\n",
    " \n",
    "print('Forma 2:')\n",
    "for i in range(len(l)):\n",
    "    print(l[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como vemos, para acceder a la posición `i` de una lista `l`, lo hacemos con la instrucción `l[i]`. **Es importante recordar que las posiciones van desde 0 hasta `len(l) - 1`**.\n",
    "\n",
    "También podemos hacer _split_ de un _string_ con la función `split`. Veamos un ejemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista con split: ['Soy', 'un', 'string', 'con', 'espacios']\n"
     ]
    }
   ],
   "source": [
    "s = 'Soy un string con espacios'\n",
    "l = s.split(' ')\n",
    "\n",
    "print(f'Lista con split: {l}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finalmente podemos definir listas de listas. Veamos un ejemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[4, 5, 6]\n",
      "[7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "\n",
    "for row in m:\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acceder a la posición `i, j` de una lista bidimensional `m` podemos usar la instrucción `m[i][j]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "elemento = m[2][0]\n",
    "print(elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para más detalles sobre listas, puedes revisar el libro de Python que hemos preparado. Lo puedes encontrar [aquí](https://adriansoto.cl/resources).\n",
    "\n",
    "### Diccionarios\n",
    "\n",
    "Podemos usar diccionarios, que en otros lenguajes se conocen también como `HashMap`. Los diccionarios nos permiten trabajar con pares _key - value_. Vamos a ver un ejemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El valor de d para la key a es: 10\n"
     ]
    }
   ],
   "source": [
    "d = {'a': 10, 'b': 100}\n",
    "\n",
    "print('El valor de d para la key a es: ' + str(d['a']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este ejemplo tenemos un diccionario con dos llaves: `'a'` y `'b'`, cuyos valores son 10 y 100 respectivamente. Notar que en el ejemplo anterior estamos concatenando el _string_ dentro del `print`. Como supondráas, para más detalles de diccionarios, puedes revisar el libro de Python que hemos preparado. Lo puedes encontrar [aquí](https://adriansoto.cl/resources)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clases\n",
    "\n",
    "Para definir una clase en Python usamos la _keyword_ `class`. Los métodos de la clase se definen utilizando `def`, como con las funciones. En este ejemplo definiremos una clase **Punto** que representa un punto en el espacio y tiene como atributos sus posiciones `x` e `y`. Además haremos un método llamado `transladar`, que recibe un `delta_x` y un `delta_y` y que nos sirve para _trasladar_ nuestro punto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Punto de cordenadas (1, 2)\n",
      "Punto de cordenadas (6, 12)\n"
     ]
    }
   ],
   "source": [
    "class Punto:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def trasladar(self, delta_x, delta_y):\n",
    "        self.x += delta_x\n",
    "        self.y += delta_y\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'Punto de cordenadas ({self.x}, {self.y})'\n",
    "    \n",
    "p = Punto(1, 2)\n",
    "print(p)\n",
    "\n",
    "p.trasladar(5, 10)\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el ejemplo anterior tenemos que notar lo siguiente:\n",
    "\n",
    "- La función `__init__` es la que actúa como constructor.\n",
    "- En todos los métodos de la clase, el primer atributo actúa como el `this`, que es la forma de hacer referencia a la instancia con la que estamos trabajando.\n",
    "- La función `__str__` nos sirve para poder serializar al elemento como _string_ y, entre otras cosas, es útil cuando queremos imprimir el elemento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Palabras al cierre\n",
    "\n",
    "La idea de este _notebook_ es servir como resumen a los conceptos básicos que vamos a necesitar durante el semestre. Una referencia más completa la puedes encontrar en (adivina) el [libro de Python que hemos realizado a modo de referencia](https://adriansoto.cl/resources). Esperamos que este resumen te sea de utilidad!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}