{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [] }, "kernelspec": { "name": "python3", "display_name": "Python 3" } }, "cells": [ { "cell_type": "markdown", "metadata": { "id": "DgeXSaKt-r0-" }, "source": [ "# **Taller 1**\n", " El objetivo de este taller es aprender las primeras herramientas de programación. Cada grupo deberá leer este material en el taller, comenzar a trabajar y luego continuar sobre el mismo de forma domiciliaria, haciendo ejemplos y ejercicios. En el día miércoles 20/3 (hasta las 23:59hs) deberán entregar **de forma individual** un informe con los ejercicios que se detallan al final de este documento. El informe será un notebook de Colab que deberán subir al EVA con la solución de los ejercicios.\n", "\n", "Si bien podrán discutir dudas con sus compañeros, la codificación y los comentarios/explicaciones de los ejercicios deberán ser realizados individualmente. Podremos convocarlos para hacerles preguntas **si** quedaran dudas de si entendieron o no algún aspecto.\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "PpnNlLpLA7yc" }, "source": [ "# Expresiones en Python\n", "\n", "Una **expresión** es el valor de un dato o de un conjunto de operaciones que dan un valor. \n", "\n", "Ejemplos de expresiones: \n", " * 42 (un dato)\n", " * 1 + 4 * 3 (un conjunto de operaciones)\n", "\n", "Se pueden usar operaciones aritméticas**, por ejemplo**:\n", " * $+ - * /$: suma, resta, multiplicación, división.\n", " * $\\%$: módulo (resto de una división entera)\n", " * $**$: exponenciación\n", "\n", "La **precedencia** es el orden en el cual las operaciones se realizan. Los operadores $*$ $/$ $\\%$ $**$ tienen una mayor precedencia que $+$ $-$. Por ejemplo: $1 + 3 * 4$ es 13. Los paréntesis pueden ser usados para forzar un orden en las operaciones: $(1 + 3) * 4$ es 16.\n", "\n", "El operador $\\%$ calcula el resto de una división de enteros. Por ejemplo: $14\\%3$ es $2$; $218\\%5$ es $3$.\n", "\n", "Python también permite operar con números reales. Ejemplos: $6.022$ ; $-15.9997$ ; $42.0$ ; $2.143e17$.\n", "\n", "Los operadores $+ - * / \\% ** ( )$ todos funcionan para reales. Las reglas de precedencia también se aplican a los reales: se evalúa ( ) antes de $* / \\% $ antes de $+ -$." ] }, { "cell_type": "code", "metadata": { "id": "m_Fi5ZGgGnKm" }, "source": [ "# Cuando una linea de python se inicia con # es un comentario y no se ejecuta\n", "# Escribir en el recuadro inferior una expresión de Python que tome un número cualquiera\n", "# que usted elija, lo eleve a otro valor también a elección, sume 1 y devuelva el resto de dividirlo entre 5.\n", "# Ejecutar la expresión y ver que da un resultado correcto. Para ejecutar la expresión debe presionarse el botón \"play\"\n", "# en la parte superior izquierda del recuadro.\n", "# Para ver el resultado utilizará la función print que muestra el valor del argumento entre paréntesis. Por ejemplo:\n", "print(4**2)\n", "\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "hJcsglo01ee7" }, "source": [ "# Escriba la expresión solicitada a continuación:\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "7vMKSUf1IADe" }, "source": [ "Python tiene una biblioteca de funciones matemáticas denominada **math** que contiene muchas funciones de cálculo. En la siguiente tabla se listan algunas de ellas.\n", "\n", "instrucción | significado\n", "--- | ---\n", "abs(value) | valor absoluto\n", "ceil(value) | redondea hacia arriba\n", "cos(value) | coseno en radianes\n", "sin(value) | seno en radianes\n", "floor(value)| redondea hacia abajo\n", "log(value) | logaritmo neperiano \n", "log10(value)| logaritmo en base 10\n", "max(value1,value2) | devuelve el mayor de dos valores\n", "min(value1,value2) | devuelve el menor de dos valores\n", "round(value) | redondea al número más cercano\n", "sqrt(value) | raíz cuadrada \n", "\n", "Para usar estos comandos se debe importar la biblioteca (antes de usarla). Esto se hace con la siguiente instrucción:\n", "\n", "*from math import **\n", "\n", "Además de permitir la utilización de las funciones previamente listadas, la biblioteca permite escribir 'pi' y 'e' para representar a los números irracionales asociados.\n", "\n", "**Observación:** el conjunto de instrucciones para importar bibliotecas se escribe al inicio del código. Esto permite tener siempre claro qué se está importando y evita errores de usar una función de una librería antes de haberla importado." ] }, { "cell_type": "code", "metadata": { "id": "AVMP2csKKI9i" }, "source": [ "# Ejecutar el siguiente programa verificando que da los valores que esperados.\n", "# Imprimir el resultado de otras expresiones que usted desee usando las funciones de la biblioteca math.\n", "\n", "from math import *\n", "\n", "print(max(3.91,4.2))\n", "print(log(e))" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "B_uspBMI0KEO" }, "source": [ " # La función pow(x,y) de la biblioteca math, eleva x a la y. Ejecutar el siguiente código.\n", " # ¿Se obtuvo el resultado esperado?\n", "\n", "from math import *\n", "print(pow(16,(1/2)))\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "oK6ukTQt2PHx" }, "source": [ "# Variables en Python\n", "\n", "Una **variable** es una porción de memoria que se utiliza para almacenar un valor y a la que se le da un nombre. En lugar de tomar el nombre de una dirección de memoria (el cual sería difícil de recordar), se le asigna un \"apodo\" a la misma.\n", "\n", "Se utiliza habitualmente para realizar el siguiente conjunto de operaciones en un programa:\n", "\n", " * Calcular el resultado de una expresión,\n", " * Almacenar dicho resultado en una variable,\n", " * Usar esa variable luego en el programa.\n", "\n", "# Instrucción de asignación de una variable\n", "\n", "La siguiente instrucción almacena un valor en una variable en el lugar de memoria correspondiente.\n", "\n", "*nombre = valor*\n", "\n", "Donde *valor* es la cantidad a almacenar en memoria y *nombre* es el nombre de la variable.\n", "\n", "Ejemplo: \n", "$x = 5$\n", "\n", "Luego de ser asignada, a la variable a la que se le ha dado un valor puede ser usada en expresiones o funciones. Por ejemplo:\n", "\n", "$x + 4$, cuyo resultado es 9.\n", "\n", "$log(x)$, que devuelve el logaritmo de 5" ] }, { "cell_type": "markdown", "metadata": { "id": "ymBt4EIY5Wk-" }, "source": [ "# Ejercicio#\n", "Escribir un programa que permita evaluar diferentes puntos (x) de una ecuación cuadrática ($ax^2+bx+c$) para a, b, y c dados.\n" ] }, { "cell_type": "code", "metadata": { "id": "y-WW5GsF3x5X" }, "source": [ "#Por ejemplo:\n", "a = 5\n", "b = 7\n", "c = 3\n", "#Escribir la expresión y evaluar la misma para diferentes valores de x. Pueden cambiarse los valores de a,b,c.\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "r0Htyb2y5fMO" }, "source": [ "#Ejercicio#\n", "Escribir un programa que inicialmente asigne dos valores a dos variables $x$ e $y$. Por ejemplo:\n", "\n", "$x=5$\n", "\n", "$y=7$\n", "\n", "Luego de estas asignaciones, escribir un programa que intercambie los valores de las variables $x$ e $y$\n", "(cualquiera sea el valor que tengan inicialmente, al final debe quedar en $x$ lo que inicialmente estaba en $y$, y en $y$ lo que estaba en $x$).\n", "Puede utilizarse un *print* de $x$ e $y$ para comprobar que quedaron con los valores intercambiados." ] }, { "cell_type": "code", "metadata": { "id": "nBflNOgg4AZl" }, "source": [ "# Escribir el código del ejercicio anterior" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "0bIn5FSY57kg" }, "source": [ "# La instrucción *print*\n", "La instrucción *print* produce una salida de texto a la consola. A continuación se presenta la sintaxis y se explican los resultados en la consola.\n", "\n", "\n", "*print(\"texto\")*\n", "\n", "*print(expresion)*\n", "\n", " \n", "Imprime el texto dado en un mensaje o el valor de una expresión en la consola, y mueve el cursor a la siguiente línea.\n", "\n", "*print(Item1, Item2, ..., ItemN)*\n", " \n", "Imprime muchos mensajes y/o expresiones en la misma línea.\n", "La instrucción print al final del último argumento salta a una nueva línea.\n", "\n", "En algunos casos nos interesa que el cursor quede en la misma línea. Para eso se puede poner como último argumento: end = ' '. Por ejemplo: *print(\"Hola\",end = ' ')*\n", "\n", "\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "6NM7otNK7CrU" }, "source": [ "# Ejectuar el siguiente código para observar el funcionamiento de la función print.\n", "\n", "print(\"Hola, mundo!\")\n", "edad = 45\n", "print(\"A Usted le faltan\", 60 - edad, \"años para jubilarse\")" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "BE8nR_iD7aHf" }, "source": [ "#Ejecute el siguiente ejemplo\n", "print('*')\n", "print('*')" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "flDpo3WG7l8P" }, "source": [ "# Compare el ejemplo anterior con el resultado de ejecutar el siguiente código\n", "print('*',end = '')\n", "print('*')" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "hrM0p2kg3iAB" }, "source": [ "# La instrucción *input*\n", "\n", "La instrucción *input* lee un número desde la entrada del usuario (teclado). De esta forma, el usuario puede ingresar el valor a asignar a una variable.\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "gKloAXVF3cHi" }, "source": [ "# Ejecutar el siguiente código para observar el funcionamiento de la instrucción input.\n", "\n", "dia = input(\"¿Qué día es hoy? (Escribir un número del 1 al 31)\")\n", "mes = input(\"¿En qué mes estamos? (Escribir un número del 1 al 12)\")\n", "print(\"Hoy es \", dia, \"del mes\", mes)\n", "\n", "# Las vacaciones de turismo empiezan el lunes 25 de marzo\n", "\n", "print(\"Faltan \", (25 - int(dia)+(3-int(mes))*30), \" días para las vacaciones de turismo\")" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "Ev7PFHj1vb57" }, "source": [ "Observar que en el último print dice *int(dia)*, e *int(mes)*. ¿Qué es esto?\n", "\n", "La función *input()* lee una línea ingresada en la consola por un dispositivo de entrada como el teclado y lo convierte a un STRING (un texto). Por lo tanto, las variables *mes* o *dia* que devuelve la función input son texto y Python no sabe caclular *11+31-[texto]*; el resultado es un error. Ver que efectivamente es así en el código superior, quitando la instrucción *int*. Para que Python pueda hacer la operación es necesario decirle que convierta el texto a un número entero y eso se hace con la función *int(texto)*.\n" ] }, { "cell_type": "code", "metadata": { "id": "V7Kr0nz-wmfy" }, "source": [ "# Probar usar esta función para ver qué resultado obtiene con 100 - int(25) y con 100 - int(25.2), ejecutando\n", "# y editando el siguiente código.\n", "\n", "print(100-int(25))" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "trXaxayV4MAN" }, "source": [ "#Ejercicio#\n", "1. Escribir un programa que pida un número y devuelva el número al cuadrado, al cubo, el logaritmo neperiano y su raíz cuadrada.\n", "\n", "2. Escribir un programa que pida el ancho y el largo de un rectángulo y devuelva su área y su perímetro. Escribir otro programa que pida el radio de un círculo y devuelva su área y su circunferencia." ] }, { "cell_type": "code", "metadata": { "id": "C1g60OmL-HCa" }, "source": [], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "NV0jlQ8p53VT" }, "source": [ "#Ejecutar instrucciones varias veces: bucles de instrucciones#\n", "Al escribir código, es usual querer repetir una serie de instrucciones una gran cantidad de veces. En lugar de reescribir el mismo código, se utilizan instrucciones que permiten repetir cierto número de veces una porción de código. Se presentan a continuación algunas de estas instrucciones.\n", "\n", "#La instrucción for#\n", "La instrucción *for* realiza un bucle en el cual repite un conjunto de instrucciones utilizando la siguiente sintaxis:\n", "\n", "*for* `nombreVariable` *in* `grupoDeValores`:\n", "\n", " instrucciones\n", "\n", "\n", "donde,\n", "\n", "`nombreVariable`: le da un nombre a cada valor, de forma de poder utilizarlo en las *instrucciones*.\n", "\n", "`grupoDeValores`: puede ser un rango de enteros especificados en una función *range* que se explicará más adelante.\n", "\n", "\n", "En esta instrucción aparece por primera vez la importancia de la indentación para Python. Todas las instrucciones que deseamos que se repitan deben ir indentadas con un tabulador o espacios (y todas con la misma cantidad). En general se utiliza la tecla *tab* (tabulador) para evitar errores. Observar que los \":\" son obligatorios para indicar que allí termina esa instrucción *for*.\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "iqavCd_p77SC" }, "source": [ "#Ejecutar el siguiente código de ejemplo para entender el funcionamiento de la instrucción for.\n", "\n", "for x in range(1, 6):\n", " print(\"El valor de x es \", x)\n", " print(\"Su cuadrado es \", x * x)\n", "\n", "#Luego de ejecutarlo cambiar la indentación del segundo print y colocarlo al mismo nivel que el for. ¿Qué sucede ahora al ejecutarlo?" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "gniNB9DE8lHD" }, "source": [ "#La función range#\n", "La función *range* especifica un rango de enteros. *range(start, stop)* especifica todos los enteros entre *start* (inclusive) y *stop* (exclusive).\n", "\n", "Puede aceptar también un tercer parámetro que especifica el salto entre valores. *range(start, stop, step)* especifica los enteros entre *start* (inclusive) y *stop* (exclusive) cada *step*.\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "yHWOCck_8z4K" }, "source": [ "# Ejemplos range. Ejecutar el código, ver el resultado y analizar\n", "# qué representan en cada caso los parámetros de range.\n", "\n", "for i in range(0, 6, 2):\n", " print(i)\n", "print(\"FIN 1!\")\n", "\n", "\n", "for x in range(5, 0, -1):\n", " print(x)\n", "print(\"FIN 2!\")\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "CTpe3D8D9aaT" }, "source": [ "Algunos loops calculan incrementalmente un valor que es inicializado fuera del loop. Por ejemplo, el siguiente código permite obtener la suma de varios números al cuadrado:\n" ] }, { "cell_type": "code", "metadata": { "id": "Q2esJVMl9llk" }, "source": [ "sum = 0\n", "for i in range(1, 11):\n", " sum = sum + (i * i)\n", "print(\"la suma de los primeros 10 cuadrados es\", sum)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "OEvchngB9_Bc" }, "source": [ "#Ejercicio#\n", "Escribir un programa en Python que reciba un entero ingresado por el usuario y calcule el factorial de dicho entero. Verificar que el programa funciona correctamente.\n", "\n", "Para realizar el factorial de un número, la idea es que ejecute un for similar al del ejemplo anterior. En lugar de hacer la suma de los cuadrados, se debe calcular un producto desde el 1 hasta el número del que se busca obtener el factorial. Para que el usuario ingrese el número deseado, utilizar la instrucción input y recordar la conversión con int().\n", "\n", "A continuación se presenta una idea del código escrita con palabras (en lugar de con instrucciones). Este listado de pasos se denomina *pseudocódigo*. Se trata de un \"plan\" a seguir al momento de codificar, y es recomendable escribirlo previo a la codificación de cualquier programa.\n", "\n", "\n", "* variable = pedir que el usuario ingrese un valor\n", "\n", "* convertir la variable a entero\n", "\n", "* inicializar una variable factorial en el valor adecuado\n", "\n", "* realizar un bucle que vaya de 1 hasta la variable inclusive\n", "\n", "* dentro del bucle multiplicar el valor anterior del factorial por el número que recorre el bucle." ] }, { "cell_type": "code", "metadata": { "id": "PJxl_Kp560v1" }, "source": [], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "090XhXdo-YE_" }, "source": [ "#La instrucción if#\n", "La instrucción *if* ejecuta un grupo de instrucciones solo si una cierta condición es verdadera. En otro caso, las instrucciones se saltean.\n", "\n", " if condicion:\n", " \tinstrucciones\n", "\n", "Observar nuevamente que las instrucciones a ejecutar si se cumple la condición van debajo del *if* y todas indentadas de la misma forma.\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "elgHrQDQ_EjU" }, "source": [ "#Ejemplo. Ejecutar el siguiente código y observar el funcionamiento de la instrucción if.\n", "\n", "edad = int(input(\"Ingrese su edad: \"))\n", "anio = 2024-edad\n", "\n", "if anio <= 2000:\n", " print(\" Usted nacio el siglo XX\")\n", "if anio > 2000:\n", " print(\" Usted nacio el siglo XXI\")" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "tQF2VrheAQXs" }, "source": [ "#if/else#\n", "\n", "Ejecuta un bloque de instrucciones si una cierta condición es verdadera y un segundo bloque de instrucciones si la condición es falsa.\n", "\n", " if condicion:\n", " \tinstrucciones_verdadera\n", " else:\n", " \tinstrucciones_falsa\n", "\n", "Observar nuevamente la indentación y los : luego del if y el else.\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "F-IKzubTAkPj" }, "source": [ "# El ejemplo anterior podría haberse escrito de la siguiente forma:\n", "\n", "edad = int(input(\"Ingrese su edad: \"))\n", "anio = 2023-edad\n", "\n", "if anio <= 2000:\n", " print(\" Usted nacio el siglo XX\")\n", "else:\n", " print(\" Usted nacio el siglo XXI\")\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "MJpLE73YAklL" }, "source": [ "\n", "Múltiples condiciones se pueden encadenar con elif (\"else if\").\n", "\n", " if condition1:\n", " \tinstrucciones1\n", " elif condition2:\n", " \tinstrucciones2\n", " else:\n", " \tinstrucciones3\n", "\n", "\n", "Nuevamente observar la indentación y los : que son obligatorios para que el programa se ejecute.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "vi6Ccy4KBifv" }, "source": [ "#Ejercicio#\n", "\n", "Escribir un programa que cuente el número de divisores de un número entero e informe si el número es primo o no. Ejemplo:\n", "\n", "\tCuál es su número favorito? 24\n", "\n", "\t24 tiene 8 divisores\n", "\n", "\t24 no es primo\n", "\n", "\tCuál es su número favorito? 31\n", "\n", " 31 tiene dos divisores\n", "\n", "\t31 es primo\n", "\n", "Para contar el número de divisores de un entero n, utilizar un bucle que pruebe todos los enteros menores o iguales que n para ver si n es divisible por él. Para ver si un número divide a otro recuerde que tiene el operador % que devuelve el resto de la división entera entre dos numeros.\n" ] }, { "cell_type": "code", "metadata": { "id": "M-TVzfPtBPcl" }, "source": [], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "A8DTikW4Bun8" }, "source": [ "#Expresiones Lógicas#\n", "Algunas expresiones lógicas muy utilizadas son :\n", "\n", "Operador | Significado | Ejemplo | Resultado\n", "--- | --- | --- | ---\n", " == | pregunta si tienen el mismo valor | 1+1 == 2 | True\n", " != | pregunta si tienen distinto valor | 7+3 != 2 | True\n", " $<$ | pregunta si es menor que | 7+3 < 2.1 | False\n", " $>$ | pregunta si es mayor que | 7+3 > 2.1 | True\n", " $>=$ | pregunta si es mayor o igual que | 0.5+1.2 >= 2.1 | False\n", " $<=$ | pregunta si es menor o igual que | 0.5+1.5 <= 2 | True\n", "\n", "Las expresiones lógicas pueden ser combinadas con operadores lógicos. Algunos de ellos son:\n", "\n", "Operador | Ejemplo | Resultado\n", "--- | --- | ---\n", "and | 7.1 $>=$ 3.0 and 8.5 $!=$ 0 | True\n", "or | $7.1 >= 3.0$ or $8.5 == 0$ | True\n", "not | not $5.3 < 7.1$ | False" ] }, { "cell_type": "markdown", "metadata": { "id": "d6wO6khJGp0x" }, "source": [ "# Funciones en Python\n", "\n", "Muchas veces en un programa se debe ejecutar el mismo conjunto de instrucciones varias veces. Por ejemplo, calcular el factorial de un número. Lo razonable es no repetir el conjunto de instrucciones necesarias para calcular el factorial cada vez que necesitamos hacerlo. Para eso el código se estructura mediante funciones. Las mismas se llaman cada vez que es necesario ejecutar ese conjunto de instrucciones. Esto estructura el código, lo hace más legible por otro ser humano y nos permite minimizar errores.\n", "\n", "Previamente se han utilizado varias funciones que vienen con Python o con bibliotecas desarrolladas para Python. Por ejemplo *print()*, *max()*, *sum()*, etc. son funciones a las que llamamos cuando se necesita imprimir algo, calcular el máximo de una lista, etc.\n", "\n", "Dado que no siempre se busca imprimir lo mismo, a *print* se le pasa una variable o un valor con lo que se quiere imprimir *print([parametros])*. Estos se llaman parámetros de la función, que son valores que necesita la función para poder ejecutar sus instrucciones. Python permite, además de utilizar las funciones de sus bibliotecas, que quien escribe el código implemente sus propias funciones.\n", "\n", "Las funciones se definen en Python siguiendo ciertas reglas de sintaxis:\n", "Los bloques de función comienzan con la palabra reservada **def** seguida por el nombre de la función y paréntesis ( ).\n", "Todo argumento o parámetros de entrada debe ser ubicado entre estos paréntesis.\n", "El bloque de código de toda función comienza con : y está indentado.\n", "\n", "La instrucción **return [expresión]** termina la función y opcionalmente retorna a quien lo llamó el valor de expresión. Un return sin argumentos termina la función y no devuelve nada.\n", "\n", "\n", " def nombredefuncion( parametros ):\n", "\t código_función\n", " \treturn [expression]\n", "\n", "\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "P6tHPy5GG02S" }, "source": [ "#Ejemplo\n", "\n", "def factorial(n):\n", " fact = 1\n", " for x in range(1,n+1):\n", " fact = fact*x\n", " return fact\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "bKwr9YwXHDeh" }, "source": [ "Por el momento, ejecutar el código anterior no hace nada. Es necesario invocar a la función creada y pasarle los parámetros que corresponden para obtener un resultado." ] }, { "cell_type": "code", "metadata": { "id": "hlGMaLfwHLeP" }, "source": [ "# Se invoca la función previamente creada para el cálculo del factorial y el valor que retorna lo asignamos a la variable v\n", "v = factorial(5)\n", "# Se imprime en la consola el valor de v\n", "print(v)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "bGN8e9vyE7ir" }, "source": [ "#**Ejercicios e Informe para entregar por EVA la semana próxima**#\n", "\n", "Cada estudiante debe entregar el código (y la explicación del mismo) de los siguientes ejercicios. La entrega se realizará en un notebook nuevo que deberán subir por EVA. Los docentes corregirán estos informes y podrán hacer preguntas individuales de los ejercicios o de los temas de este material en la semana próxima. También se podrá solicitar la reentrega de algún ejercicio. \n", "\n", "Tanto el código cómo su explicación deberán ser realizados de manera **individual**. Cada uno deberá escribir su propio código y la explicación de lo que hizo. El código además debe ejecutarse correctamente.\n", "\n", "**ATENCIÓN: No se considerará que el ejercicio está bien si no está explicado detalladamente lo que hace el código. Los comentarios pueden agregarse en el mismo código, explicando lo que hace cada línea, o también pueden utilizarse cuadros de texto.**\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "oPdZApVLGEOg" }, "source": [ "#**Ejercicio 1 para entrega individual**#\n", "\n", "---\n", "\n", "\n", "Escribir un programa Python que imprima a pantalla el siguiente dibujo. Será necesario utilizar bucles para hacerlo.\n", "\n", "a\n", "\n", "a a\n", "\n", "a a a\n", "\n", "a a a a\n", "\n", "a a a a a\n", "\n", "a a a a\n", "\n", "a a a\n", "\n", "a a\n", "\n", "a\n" ] }, { "cell_type": "code", "metadata": { "id": "1TP8zspJGAiC" }, "source": [ "# La idea de este código es escribir uno o mas bucles que vayan haciendo los print\n", "# de la letra 'a' de forma que al final se haya impreso la figura anterior. No es una solución\n", "# válida escribir los 9 prints uno a continuación del otro; la idea es utilizar la menor cantidad\n", "# de instrucciones print que pueda. Hay muchas formas de resolver este ejercicio, una sugerencia\n", "# es observar lo que imprime el siguiente código:\n", "\n", "i = 3\n", "print('a'*i)\n", "\n", "# Si i varía en un for se tiene buena parte del problema resuelto. ¿Puede resolver el ejercicio utilizando un for, un if y dos prints?\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "0Z2zps-4H0Cy" }, "source": [ "#**Ejercicio 2 para entrega individual**#\n", "Escribir una **función** que reciba un entero N>0 y devuelva la siguiente operación $\\sum_{i=0}^{i=N-1} i*(i+1)$. En caso\n", "de que N sea menor o igual que cero, la función debe avisar que no se\n", "realizó la suma y devolver el valor de N.\n", "\n", "Verificar que la función opera correctamente probando para N=1, N=2, N=3, N=5, N=-5, utilizando el programa de prueba escrito más abajo.\n" ] }, { "cell_type": "code", "source": [ "# Escribir aquí la función que resuelve el ejercicio anterior\n", "\n", "def funcion_sumatoria(N):\n", " #calcular el resultado y guardarlo en la variable \"resultado\"\n", "\n", "\n", " return resultado" ], "metadata": { "id": "WiTAxs9HJewb" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "# Se provee al estudiante con un programa de prueba para verificar el correcto funcionamiento de la función anterior.\n", "res_1 = funcion_sumatoria(1)\n", "res_2 = funcion_sumatoria(2)\n", "res_3 = funcion_sumatoria(3)\n", "res_5 = funcion_sumatoria(5)\n", "\n", "if res_1 == 0 and res_2 == 2 and res_3 == 8 and res_5 == 40:\n", " print(\"El funcionamiento es correcto\")\n", "else:\n", " print(\"El funcionamiento NO es correcto\")" ], "metadata": { "id": "sUg2AJXSEKDC" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [], "metadata": { "id": "LEcEgqO-Fo6W" }, "execution_count": null, "outputs": [] } ] }