{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "7qyS3NIdKd4P" }, "source": [ "# AABC Notebook 1 - Python\n", "\n", "Este texto es parte del notebook.\n", "\n", "Prueba ahora hacer doble click sobre este texto; aparecerá un recuadro en *texto plano* con este mismo texto pero en formato **Markdown**. El Markdown es un lenguaje que permite generar texto con formato de manera extremadamente sencilla. Por ejemplo, para hacer una lista hacemos así:\n", "* Pera\n", "* Manzana\n", "* Naranja\n", "\n", "O una lista enumerada:\n", "\n", "1. Uno\n", "1. Dos\n", "1. Tres (notar que siempre se pone '1.'; la numeración sigue sola)\n", "\n", "Para más detalles ver la [guía oficial de markdown](https://colab.research.google.com/notebooks/markdown_guide.ipynb).\n", "\n", "Los Notebooks permiten intercalar bloques (*celdas*) de texto markdown como éste, con celdas de código Python (u otros lenguajes). Abajo vemos nuestra primera celda de código:\n", "\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "vqb8V9-IMrcm", "outputId": "0f2043ed-adb2-4021-9337-734c3f9f540f" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Bienvenidos al AABC!\n", "5+3 = 8\n" ] } ], "source": [ "# Esta es una celda de código\n", "# En una linea de texto cualquiera, todo lo que sigue a la derecha de un numeral es considerado _comentario_\n", "# Un comentario permite anotar y comentar partes de código para mejorar su interpretación\n", "# Lo primero que vamos a hacer es imprimir un mensaje sencillo en pantalla.\n", "print('Bienvenidos al AABC!')\n", "print('5+3 =',5+3)\n", "# para _ejecutar_ este código hay que presionar el botón de \"Play\" que aparece arriba a la izquierda de la celda (o Ctrl+Enter en el teclado)." ] }, { "cell_type": "markdown", "metadata": { "id": "A7lDZzGFNpng" }, "source": [ "# Lenguaje de programación Python\n", "\n", "En general, los lenguajes de programación indican a una computadora cómo realizar ciertas tareas. Hay tareas muy sencillas, como calcular el resultado de una cuenta, imprimir un texto, o evaluar un polinomio.\n", "\n", "En otros casos los programas pueden ser grandes y muy complejos.\n", "\n", "## Scripts\n", "\n", "El tipo de programación que vamos a ver en este curso es el denominado _scripts_. Esto son similares a _recetas de cocina_, donde uno especifica una serie de pasos a realizar en secuencia.\n", "\n", "## Sentencias\n", "Dicho de manera simplificada, esos pasos se denominan _sentencias_ (anglicismo para _sentence_ --frase-- del inglés). En el primer bloque de código vimos dos sentencias consecutivas, ambas con el objetivo de mostrar algo en pantalla.\n", "La primera simplemente imprime un texto. La segunda imprime un texto seguido del resultado de la _expresión matemática_ $5+3$.\n", "\n", "Esta es la forma más simple de trabajar en Python, y a los efectos de este curso, la única realmente necesaria. Para terminar de comprender bien las sentencias anteriores hay que entender el concepto de _función_ en el contexto de un programa de computadora.\n", "\n", "## Funciones y argumentos\n", "\n", "De manera similar al concepto de _función_ en matemática, una función en Python recibe como _entrada_ uno o más _parámetros_ o _argumentos_, y produce una _salida_ como resultado.\n", "\n", "La función se identifica de manera única por su _nombre_. En nuestro caso, la función que _invocamos_ o _llamamos_ es `print`, y el argumento que pasamos es el texto a imprimir.\n", "\n", "## Expresiones\n", "\n", "En la primera invocación, el argumento es simplemente el texto 'Bienvenidos a AABC'; al texto se le llama 'cadena de texto' o 'cadena de caracteres'. Cuando un texto es constante, se le llama 'cadena literal' (string literal). Sin embargo, ya en la segunda invocación, ocurren más cosas:\n", "\n", "1. el _primer_ argumento es el el texto (_cadena literal_) '5+3 ='\n", "1. el _segundo_ argumento es el _resultado_ de la _expresión_ `5+3`\n", "\n", "Una _expresión_ es una combinación de operandos, operadores, llamadas a funciones (y otras cosas). En nuestro caso tenemos dos operandos: las constantes _numéricas_ `5` y `3`, un operador de suma `+`; el resultado de esta expresión es, naturalmente, $8$. Ese valor es el que en última instancia es pasado como _argumento_ a la función `print`.\n", "\n", "En resumen, la segunda sentencia:\n", "```\n", "print('5+3 =', 5+3)\n", "```\n", "involucra internamente _dos_ pasos:\n", "1. la expresión `5+3` es sustituída por su resultado, `8`\n", "2. se invoca `print` con los argumentos `'5+3 ='` y `8`\n", "\n", "## Sintaxis\n", "\n", "Estas son dos de las características más importantes de los lenguajes de programación.\n", "\n", "La sintaxis especifica cómo construir expresiones y sentencias válidas. Por ejemplo, el código:\n", "```\n", "print( '5+3= , 5+3 )\n", "```\n", "no es válido, ya que falta el caracter `'` que indica el final de la constante de texto `5+3=`. Eso hace que el sistema que traduce el texto que escribimos a operaciones dentro de la computadora (en el caso de Python, a este sistema le llamamos _intérprete_) no pueda determinar de manera exacta lo que la expresión anterior debería producir. Puede ser obvio para nosotros, pero el intérprete es bastante tonto.\n", "De la misma manera,\n", "```\n", "print( '5+3=' , 5+3\n", "```\n", "también es una sentencia inválida, porque le falta el paréntesis que cierra la lista de argumentos en la función.\n", "\n", "---\n", "***Ejercicio:*** \n", "1. pruebe ejecutar la siguiente celda y vea qué produce como resultado.\n", "2. corrija las sentencias de la celda para que funcionen correctamente.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "nW0i1HFTUJYA", "outputId": "b8c27eb6-ade4-4243-c88f-f173676d06ba" }, "outputs": [], "source": [ "# nota: EOL significa \"End Of Line\"\n", "print('5+3= , 5+3)\n", "print('5+3= ' 5+3)\n", "print('5+3= ' ; 5+3)\n", "print('5+3= ',5+3\n", "pront('5+3= ',5+3)\n" ] }, { "cell_type": "markdown", "metadata": { "id": "9MLKJs7Pewc2" }, "source": [ "# Semántica\n", "\n", "La sintaxis indica cómo armar expresiones válidas.\n", "La semántica del lenguaje determina cómo se debe interpretar una expresión.\n", "En el caso anterior, `5 + 3` tiene como resultado la sustitución de ambos operandos por el resultado de la operación binaria `+`, que naturalmente se traduce en su suma. Más adelante veremos sin embargo que expresiones similares pueden tener resultados muy distintos según los operadores y operandos involucrados. Dominar la semántica de un lenguaje es esencial para su comprensión y uso.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "k6ZcGvmjVkec" }, "source": [ "# Funciones incorporadas\n", "\n", "Como todo lenguaje de programación moderno, Python incluye muchísimas funciones prontas para realizar tareas comunes. La primera que uno siempre muestra es `print`, pero hay otras. La siguiente celda muestra algunos ejemplos; ejecútela y vea su salida.\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "3NqiZvGtV7NJ", "outputId": "daa2bd22-679d-4105-e690-10b184790079" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hola mundo!\n", "3\n", "5\n", "Help on built-in function print in module builtins:\n", "\n", "print(...)\n", " print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n", " \n", " Prints the values to a stream, or to sys.stdout by default.\n", " Optional keyword arguments:\n", " file: a file-like object (stream); defaults to the current sys.stdout.\n", " sep: string inserted between values, default a space.\n", " end: string appended after the last value, default a newline.\n", " flush: whether to forcibly flush the stream.\n", "\n" ] } ], "source": [ "print('Hola mundo!')\n", "print(min(5,3)) # devuelve como resultado el mínimo de sus argumentos\n", "print(max(5,3)) # devuelve como resultado el máximo de sus argumentos\n", "help(print) # muestra la ayuda de la función 'print'" ] }, { "cell_type": "markdown", "metadata": { "id": "QSPY2swIXG7s" }, "source": [ "# Paquetes\n", "\n", "Como todo lenguaje moderno, Python permite incorporar funcionalidad adicional mediante colecciones de funciones llamadas `paquetes`. La instalación del propio lenguaje Python incluye, junto con su intérprete y otras utilidades, la llamada [biblioteca estándar](https://docs.python.org/3/library/). Esta biblioteca incluye una cantidad _enorme_ de funciones que cubren desde operaciones matemáticas (paquete `math`), interfaz con el sistema operativo (paquetes `os` y `sys`), hasta manejo de bases de datos (ej., paquete `sqlite3`).\n", "El usuario debe especificar qué paquetes desea usar en su programa o script mediante las sentencias `import`. El siguiente ejemplo muestra cómo funciona esto:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "XUKIFU_kYKQl", "outputId": "60144e43-438f-42df-83ab-c889eaf84109" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "pi = 3.141592653589793\n", "número aleatorio entre 0 y 1: 0.022097844767667296\n", "fecha de hoy: Tue Feb 20 11:21:24 2024\n" ] } ], "source": [ "import math # matemáticas\n", "import random # generación de números aleatorios\n", "# abajo le ponemos un alias 'fecha' al módulo 'datetime' para su uso posterior\n", "import time as fecha # hora; le ponemos un alias 'fecha' al módulo para su uso posterior\n", "\n", "print('pi =',math.pi)\n", "print('número aleatorio entre 0 y 1: ',random.random())\n", "print('fecha de hoy: ',fecha.asctime())\n" ] }, { "cell_type": "markdown", "metadata": { "id": "gTUys4fRZXcJ" }, "source": [ "para acceder a una función o una constante de un módulo es necesario poner como sufijo el nombre del módulo en cuestión (o el alias que usamos), seguido de un punto `.`. En el caso anterior, `math.pi` es una constante del módulo `math`,\n", "mientras que `random()` es una función del módulo `random` y `asctime()`\n", "es la función del módulo `time` (que nosotros usamos con el alias `fecha`) que\n", "produce una cadena de texto con la fecha actual.\n", "\n", "## Paquetes de terceros\n", "\n", "Además de los paquetes estándar, Python contiene un _ecosistema_ de paquetes contribuídos por otros. Hoy en día, la utilidad de un lenguaje de programación cualquiera depende _enormemente_ del ecosistema de paquetes disponibles para el usuario; esta es una de las grandes ventajas de Python, como veremos más adelante.\n", "En general, estos paquetes deben ser instalados manualmente por el usuario, si bien el entorno de Google Colaboratory ya incluye muchos de los más usados, en especial los de ciencias.\n", "\n", "En el próximo Notebook vamos a trabajar con estos módulos. A modo de ejemplo, veamos cómo generar una muestra aleatoria de una distribución de Poisson usando el módulo [scipy.stats](https://docs.scipy.org/doc/scipy/reference/stats.html):\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "s2WA4EtbaqnF", "outputId": "39a8d3e2-4ba7-4d54-eff1-e09001216fc3" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/emidan19/anaconda3/envs/telefonicaAD/lib/python3.9/site-packages/scipy/__init__.py:155: UserWarning: A NumPy version >=1.18.5 and <1.25.0 is required for this version of SciPy (detected version 1.26.3\n", " warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion}\"\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0.24197072451914337\n" ] } ], "source": [ "#!pip install mglearn\n", "\n", "import scipy.stats as st\n", "\n", "print(st.norm.pdf(0,1)) # muestra aleatoria de distribución Normal de media 0 y varianza 1\n" ] }, { "cell_type": "markdown", "metadata": { "id": "BKOqUcI4bsCq" }, "source": [ "# Más elementos del lenguaje: variables, tipos y funciones\n", "\n", "Lo último que vamos a ver es una breve descripción de los tres elementos fundamentales que debemos manejar, aunque sea a nivel básico, para poder entender y crear nuestros propios scripts.\n", "\n", "## Variables\n", "\n", "El primer concepto es el de _variable_. Al igual que en matemáticas, una variables es un _símbolo_ que tiene asociado un _valor_. Como el nombre del concepto lo indica, el valor de una variable puede _variar_ durante la ejecución de un script. Para seguir con la analogía de matemáticas, el valor puede ser un número. Veamos un ejemplo:\n" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "N2M1Sp4Sc4u9", "outputId": "4448b811-ecd4-420a-f1aa-be7d57bcbbd9" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "la variable a vale 5\n", "ahora la variable a vale 8\n", "la suma de 8 y 3.5 es 11.5\n" ] } ], "source": [ "a = 5\n", "print('la variable a vale', a)\n", "a = a + 3\n", "print('ahora la variable a vale', a)\n", "b = 3.5\n", "print('la suma de',a,'y',b,'es', a + b)\n" ] }, { "cell_type": "markdown", "metadata": { "id": "V5PEpbqKdTys" }, "source": [ "# Tipos\n", "En Python, sin embargo, el valor de una variable puede tener muchos _tipos_. Incluso en el ejemplo anterior, `a` y `b` tienen dos tipos numéricos distintos! `a` es un número entero, mientras que `b` es un número con decimales (a estos números se los llama de *punto flotante*, por cuestiones técnicas que no vienen al caso ahora). El resultado de la suma de un entero y uno con decimales es siempre un número con decimales; de esa manera el lenguaje evita que se pierda información en la operación. Podemos ver el tipo de una variable (o expresión) usando la función incorporada `type`:\n" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "6KTwW1fHeGNa", "outputId": "1c9b7205-22d4-407e-c7e8-8899e641292d" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\n", "\n" ] } ], "source": [ "print(type(a)) # tipo de la variable a\n", "print(type(b)) # tipo de la variable b\n", "print(type(a+b)) # tipo de la suma de a y b" ] }, { "cell_type": "markdown", "metadata": { "id": "61R9CalsePSI" }, "source": [ "El siguiente _tipo_ más común son las cadenas de texto o _strings_:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "nE865TYleYGl", "outputId": "5062ed27-74f0-4e99-b74f-8c5a77544bef" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hola, soy una cadena de texto! \n", "Hasta luego\n", "Hola, soy una cadena de texto! Hasta luego\n" ] } ], "source": [ "a = 'Hola, soy una cadena de texto! '\n", "print(a)\n", "b = 'Hasta luego'\n", "print(b)\n", "print(a+b) # semántica: sumar dos cadenas de texto equivale a _concatenarlas_" ] }, { "cell_type": "markdown", "metadata": { "id": "v7KL679-fosM" }, "source": [ "## Revisitando la semántica\n", "\n", "Anteriormente mencionamos que la semántica de un lenguaje indica cómo debe interpretarse una expresión. En el ejemplo anterior vemos que `a+b` puede arrojar resultados _muy_ distintos según el _tipo_ de las variables involucradas! Si `a` y `b` son números, la expresión `a+b` produce su suma. Sin embargo, si `a` y `b` son cadenas de texto, el resultado es la _concatenación_ de ambas cadenas!\n", "\n", "---\n", "***Ejercicio***\n", "Pruebe ejecutar el siguiente código (adelanto: no va a funcionar!). Lea con atención el mensaje de error producido. ¿Cuál es el problema y cómo lo soluciona?." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "fFdb4q1igJ6e", "outputId": "430180ad-0abe-4932-97b7-24e46c585cc6" }, "outputs": [], "source": [ "a = 'El número '\n", "b = 'cinco punto dos'\n", "c = 5.2\n", "print(a + b)\n", "print( a + c ) # intentamos sumar una cadena de texto y un número.\n", "print(a + str(c)) # la función interna str convierte un número en texto " ] }, { "cell_type": "markdown", "metadata": { "id": "ueLegVaQg5dc" }, "source": [ "# Otros tipos importantes\n", "\n", "Además de números y texto, Python define [varios tipos muy útiles](https://docs.python.org/3/library/stdtypes.html), de los cuales vamos a ver rápidamente los siguientes:\n", "* valores _booleanos_, pueden tener dos valores: `True` o `False` (tipo `bool`)\n", "* listas (tipo `list`)\n", "* tuplas, o listas inmutables (tipo `tuple`)\n", "* conjuntos: listas de elementos sin repetición (tipo `set`)\n", "* diccionarios: mapeos _clave -> valor_ (tipo `dict`)\n", "\n", "Presione 'Play' en la siguiente celda para ver un poutpourri de estos tipos:\n" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "G2F3fRAdiXx6", "outputId": "fc7ed29e-fcf2-4d87-f24b-f661157b68a1" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a = True b = False\n", "se cumplen a y b? False\n", "se cumple a o b? True\n", "NO cumple a? True\n", "par de variables vale (1, 2)\n", "el segundo elemento de la tupla vale 2\n", "lista de variables [1, 2, 2, 1]\n", "lista de variables modificada [3, 2, 2, 4]\n", "elementos del 1 al 3 (exclusive!) [2, 2]\n", "elementos del 1 en adelante [2, 2, 4]\n", "elementos hasta el 3 (exclusive) [3, 2, 2]\n", "último elemento de la lista 4\n", "penúltimo elemento de la lista 2\n", "todos los elementos hasta el penúltimo (exclusive) [3, 2]\n", "abbac [3, 2, 2, 4, 5]\n", "abbac [3, 2, 4, 5]\n", "frutas {'naranja', 'manzana', 'pera'}\n", "tenés una banana? False\n", "{'nombre': 'Eugenio', 'peso': 90, 'altura': 175, 'ojos': 'marrones'}\n", "Nombre: 90 kg\n", "Peso: 90 kg\n", "Altura: 175 cm\n", "Eugenio subió de peso\n", "Peso: 100 kg\n", "Tenemos datos de género de Eugenio? False\n", "agregamos dato de género...\n", "Tenemos datos de género de Eugenio? True\n" ] } ], "source": [ "#\n", "# variables boolanas\n", "#\n", "a = True\n", "b = False\n", "print('a =',a,'b =',b)\n", "# expresiones lógicas con variables booleanas\n", "print('se cumplen a y b?', a and b)\n", "print('se cumple a o b?', a or b)\n", "print('NO cumple a?', not b)\n", "#\n", "# TUPLAS\n", "#\n", "ab = (1,2)\n", "print('par de variables vale',ab)\n", "#\n", "# _acceso_ a un elemento de la tupla mediante _índices_\n", "# los índices empiezan en _0_\n", "#\n", "print('el segundo elemento de la tupla vale',ab[1])\n", "#\n", "# LISTAS\n", "#\n", "abba = [1,2,2,1] # notar la diferencia: (...) vs [...]\n", "print('lista de variables ',abba) # notar la diferencia: (...) vs [...]\n", "\n", "#\n", "# la lista es modificable!\n", "#\n", "abba[0] = 3 # primer elemento de la lista\n", "abba[3] = 4 # último elemento de la lista\n", "print('lista de variables modificada',abba)\n", "#\n", "# las listas y tuplas pueden accederse de a _segmentos_ (slices)\n", "#\n", "print('elementos del 1 al 3 (exclusive!)',abba[1:3])\n", "print('elementos del 1 en adelante',abba[1: ])\n", "print('elementos hasta el 3 (exclusive)',abba[ :3])\n", "#\n", "# índices negativos: cuentan desde el final\n", "#\n", "print('último elemento de la lista',abba[-1])\n", "print('penúltimo elemento de la lista',abba[-2]) #\n", "print('todos los elementos hasta el penúltimo (exclusive)',abba[:-2])\n", "#\n", "# la lista se puede modificar\n", "#\n", "abbac = abba\n", "abbac.append(5)\n", "print('abbac',abbac)\n", "abbac.remove(2) # quita _primer_ ocurrencia del no. 2\n", "print('abbac',abbac)\n", "#\n", "# CONJUNTOS (set)\n", "#\n", "frutas = set()\n", "frutas.add('pera')\n", "frutas.add('manzana')\n", "frutas.add('naranja')\n", "print('frutas',frutas)\n", "print('tenés una banana?','banana' in frutas) # test de pertenencia, produce booleano!\n", "#\n", "# MAPAS O DICCIONARIOS (dict)\n", "#\n", "datos = {'nombre':'Eugenio','peso':90,'altura':175,'ojos':'marrones'}\n", "print(datos)\n", "print('Nombre:',datos['peso'],'kg') # valor del 'peso'\n", "print('Peso:',datos['peso'],'kg') # valor del 'peso'\n", "print('Altura:',datos['altura'],'cm') # valor del 'peso'\n", "\n", "# podemos modificar el valor asociado a una clave\n", "print('Eugenio subió de peso')\n", "datos['peso'] = 100 # Eugenio engordó\n", "print('Peso:',datos['peso'],'kg')\n", "#\n", "# test de pertenencia\n", "# podemos guardar el resultado del test en una variable booleana!\n", "#\n", "tiene_genero = 'género' in datos # expresión: clave in conjunto. Resultado: booleano\n", "print('Tenemos datos de género de Eugenio?',tiene_genero)\n", "\n", "# podemos quitar o agregar claves\n", "print('agregamos dato de género...')\n", "datos['género'] = 'masculino'\n", "print('Tenemos datos de género de Eugenio?','género' in datos)\n" ] }, { "cell_type": "markdown", "metadata": { "id": "ILw2FhQ1q1J2" }, "source": [ "---\n", "\n", "**Ejercicio**\n", "\n", "Pruebe modificar las sentencias de la celda anterior a ver qué pasa!\n", "\n", "---" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "AwkkhIfIxXcq", "outputId": "4a8aa66b-a5c8-41f7-8ba6-7f728ff9334c" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "bucle for\n", "\n", "a vale 0\n", "a vale 1\n", "a vale 2\n", "a vale 3\n", "a vale 4\n", "a vale 5\n", "a vale 6\n", "a vale 7\n", "a vale 8\n", "a vale 9\n" ] } ], "source": [ "#\n", "# for: repetir una sentencia para distintos valores de una variable\n", "#\n", "print('\\nbucle for\\n') # \\n es un 'enter'\n", "for a in range(10): # a toma valores entre 0 y 9\n", " # esto se repite para cada valor de 'a'\n", " print('a vale',a)\n", " # <- notar la indentación! esto determina a qué grupo\n", " # de sentencias se aplica el bucle!\n" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "P_x3bMwurF_-", "outputId": "a2ba6c28-fb34-4808-e212-f1d066da8519" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Tengo una naranja\n", "Tengo una manzana\n", "Tengo una pera\n", "\n", "Datos de la persona:\n", "nombre : Eugenio\n", "peso : 100\n", "altura : 175\n", "ojos : marrones\n", "género : masculino\n", "\n", "bucle while\n", "\n", "a vale 2\n", "a vale 3\n", "a vale 4\n", "a vale 5\n", "a vale 6\n", "\n", "condicionales: if-elif-else\n", "\n", "más vale que esto se imprima\n", "\n", "desempeño del estudiante:\n", "\tbueno\n" ] } ], "source": [ "#\n", "# for se puede usar con tuplas, listas, etc!\n", "#\n", "for f in frutas:\n", " print('Tengo una',f)\n", "\n", "print('\\nDatos de la persona:')\n", "for clave in datos: # para cada 'clave' en el diccionario\n", " valor = datos[clave]\n", " print(clave,':',valor)\n", "\n", "#\n", "# while: repetir mientras se cumpla la condición\n", "#\n", "print('\\nbucle while\\n')\n", "a = 2\n", "while a < 7:\n", " # notar indentación (4 espacios en este caso)\n", " print('a vale',a)\n", " a += 1 # abreviación para a = a + 1\n", "\n", "#\n", "# if: ejecutar si se cumple una condición\n", "print('\\ncondicionales: if-elif-else\\n')\n", "if 5 > 8:\n", " print('imposible')\n", "\n", "#\n", "# else: ejecutar si NO se cumple la condición del 'if' correspondiente\n", "#\n", "if 5 > 8:\n", " print('imposible')\n", "else:\n", " print('más vale que esto se imprima')\n", "\n", "# elif: para concatenar tests sucesivos\n", "# sólo uno de los bloques de sentencias se ejecuta!\n", "print('\\ndesempeño del estudiante:')\n", "a = 7\n", "if a < 3:\n", " print('\\tisuficiente') # \\t imprime un TAB\n", "elif a < 6:\n", " print('\\tregular')\n", "elif a < 8:\n", " print('\\tbueno')\n", "elif a < 12:\n", " print('\\tmuy bueno')\n", "elif a == 12:\n", " print('\\texcelente')\n", "else:\n", " print('\\tnota inválida')\n" ] }, { "cell_type": "markdown", "metadata": { "id": "ENB0A4EkuiG3" }, "source": [ "---\n", "\n", "**Ejercicio**\n", "\n", "Pruebe modificar la celda anterior y ver qué pasa.\n", "\n", "En particular, cambie el valor de `a` en la última parte y vea qué sucede.\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": { "id": "3Pzy34zorPgp" }, "source": [ "# Definición de funciones\n", "\n", "El último ingrediente importante de todo lenguaje es la posibilidad de _encapsular_ tareas, funcionalidades, procedimentos que se repiten una y otra vez en funciones definidas por el usuario (también se pueden definir _tipos_ propios, pero no vamos a entrar en eso).\n", "\n", "En python esto es muy sencillo de hacer. Veamos un ejemplo:\n" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "61RdVtbwviVD", "outputId": "465d0894-d8fc-4149-de80-e0a4c7e48ac7" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on function polinomio in module __main__:\n", "\n", "polinomio(x, a, b, c)\n", " Este comentario acompaña a la función y se muestra al invocar help()\n", " Esta función evalúa un polinomo de segundo orden\n", " de coeficientes a,b,c para el valor de x suministrado como argumento\n", "\n", "P( 0 ) = 3\n", "P( 1 ) = 6\n", "Valores entre -5 y 5:\n", "\tP( -5 ) = 111\n", "\tP( -4 ) = 73\n", "\tP( -3 ) = 43\n", "\tP( -2 ) = 21\n", "\tP( -1 ) = 7\n", "\tP( 0 ) = 1\n", "\tP( 1 ) = 3\n", "\tP( 2 ) = 13\n", "\tP( 3 ) = 31\n", "\tP( 4 ) = 57\n", "\tP( 5 ) = 91\n" ] } ], "source": [ "def polinomio(x,a,b,c):\n", " '''\n", " Este comentario acompaña a la función y se muestra al invocar help()\n", " Esta función evalúa un polinomo de segundo orden\n", " de coeficientes a,b,c para el valor de x suministrado como argumento\n", " '''\n", " y = a*x**2 + b*x + c # x**2 es la expresión correspondiente a 'x elevado a la 2'\n", " # y es una variable _local_: solo existe durante la ejecución de la función\n", " return y # con 'return' indicamos que terminamos la función y que su resultado es 'y'\n", "\n", "termino_cuad = 1\n", "termino_lineal = 2\n", "termino_indep = 3\n", "\n", "#\n", "# podemos ver la ayuda de nuestra función!\n", "#\n", "help(polinomio)\n", "#\n", "# los argumentos entre paréntesis proveen valores a las variables x,a,b,c\n", "# de la función.\n", "x = 0\n", "y = polinomio(x, 1, 2, 3)\n", "print(f'P( {x} ) = {y}') # otra forma de intercalar números y texto\n", "\n", "# cambiamos el valor de x\n", "x = 1\n", "# volvemos a evaluar polinomio; su resultado se almacena en la variable y\n", "y = polinomio(x, termino_cuad, termino_lineal, termino_indep)\n", "print(f'P( {x} ) = {y}')\n", "\n", "#\n", "# evaluamos el polinomio en un rango de valores!\n", "#\n", "print('Valores entre -5 y 5:')\n", "for x in range(-5,6): # de -5 a 5 inclusive\n", " y = polinomio(x, 4, -2, 1)\n", " print(f'\\tP( {x:2d} ) = {y:2d}')\n" ] }, { "cell_type": "markdown", "metadata": { "id": "Z_g5hYunrUIW" }, "source": [ "# Avanzado y elegante: list comprehensions\n", "\n", "Una de las cosas más lindas de Python es que permite trabajar con listas, conjuntos y diccionarios de manera clara, concisa y elegante mediante lo que se llaman _comprehensions_. No es necesario que Ud. las domine en este curso, pero es posible que algún día se cruce con ellas, por lo que vale la pena familiarizarse con su sintaxis y semántica.\n", "Veamos algunos ejemplos.\n" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "id": "IDaZkvp3rS4H" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "lista original\n", "[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]\n", "lista con valores x 2 \n", "[-10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10]\n", "lista con polinomio evaluado en valores de a\n", "[18, 11, 6, 3, 2, 3, 6, 11, 18, 27, 38]\n", "lista con polinomio evaluado solo en valores PARES de a\n", "[11, 3, 3, 11, 27]\n" ] } ], "source": [ "#\n", "# podemos generar listas a partir de otras listas\n", "#\n", "a = list(range(-5,6)) # lista con elementos del -5 al 5\n", "print('lista original')\n", "print(a)\n", "\n", "print('lista con valores x 2 ')\n", "b = [2*x for x in a] # generamos otra lista con cada elemento de 'a' multiplicado por 2\n", "print(b)\n", "\n", "print('lista con polinomio evaluado en valores de a')\n", "c = [polinomio(x,1,2,3) for x in a] # lo mismo que hicimos con el for antes\n", "print(c)\n", "\n", "print('lista con polinomio evaluado solo en valores PARES de a')\n", "d = [polinomio(x,1,2,3) for x in a if (x % 2 == 0)] # lo mismo que hicimos con el for antes\n", "print(d)\n" ] } ], "metadata": { "colab": { "provenance": [] }, "kernelspec": { "display_name": "Python 3", "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.13" } }, "nbformat": 4, "nbformat_minor": 0 }