{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [] }, "kernelspec": { "name": "python3", "display_name": "Python 3" } }, "cells": [ { "cell_type": "markdown", "metadata": { "id": "NY5i3t-WRAG5" }, "source": [ "#**Taller 2**#\n", "El objetivo de este taller es continuar aprendiendo los aspectos básicos de Python. Esta herramienta nos permitirá comenzar a trabajar con aplicaciones de Ingeniería Eléctrica/Ing. en Sistemas de Comunicación y en particular de Comunicaciones. La fecha de entrega límite de este taller es el miércoles 03/04/24.\n", "\n", "#Los Strings en Python#\n", "\n", "Un string es una cadena o secuencia de caracteres de texto en un programa.\n", "Los strings comienzan y terminan con comillas \" o apóstrofe '.\n", " * \"hola\"\n", " * \"Esto es un string\"\n", " * \"Esto, también es un string. Puede ser muy largo!\"\n", "\n", "\n", "Un string no puede expandirse a través de varias líneas o contener el carácter \".\n", "\n", " * \"Esto no es\n", "\n", " un String válido.\"\n", "\n", " * \"Este no es un string \"válido\" tampoco.\"\n", "\n", "Un string puede tener dentro caracteres especiales precedidos de un backslash $\\backslash$. Algunos ejemplos de caracteres especiales son los siguientes.\n", "\n", " * $\\backslash$t que inserta un tabulador\n", " * $\\backslash$n que inserta una nueva línea\n", " * $\\backslash$\" que permite utilizar comillas\n", " * $\\backslash \\backslash$ que permite utilizar backslash\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "source": [ "\n", "Si en Python escribe el código de la siguiente celda, ¿qué se espera obtener como salida? Correr el programa y observar el resultado." ], "metadata": { "id": "MY8icOnPaaxS" } }, { "cell_type": "code", "metadata": { "id": "UWXovcZCSLWv" }, "source": [ "print(\"Hola\\tamigos\\nCómo están?\")" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "hgMoCMJxSdXl" }, "source": [ "\n", "\n", "Como fue mencionado en el taller anterior, es posible asignar un valor entero o real a una variable. A continuación veremos que también se le puede asignar un string.\n", "\n", "\n", "Ejemplo: se asigna la variable *nombre*: \n", "\n", "*nombre = \"P. Perez\"*\n", "\n", "Si se observara la memoria de la computadora, en particular el lugar donde se encuentra la variable *nombre*, se observaría en la primer celda una *P*, en la siguiente un *.* , luego un espacio, etc.\n", "\n", "\n", "\n", "\n", "Para acceder a un carácter individual en un string se usa la sintaxis:\n", "\n", " variableName [ index ]\n", "\n", "Al utilizarlo, se reemplaza *variableName* con el nombre de la variable e *index* con la posición del caracter de interés. Es importante notar que la numeración comienza desde el cero." ] }, { "cell_type": "code", "metadata": { "id": "8ApKsKs8S7Aj" }, "source": [ "# Ejemplo\n", "\n", "nombre = \"P. Perez\"\n", "print(nombre, \"comienza con\", nombre[0])\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "sT2YmlztTfKo" }, "source": [ "Sobre los strings se pueden aplicar varias funciones. Algunos ejemplos son los siguientes.\n", "\n", " * len(string) \t - número de caracteres en un string (incluido espacios)\n", " * str.lower(string) - versión del string en minúscula\n", " * str.upper(string) - versión del string en mayuscula\n", "\n", "Se aconseja la lectura del siguiente archivo de la documentación de referencia de Python. En él se encuentran más funciones sobre strings y otros tipos de datos.\n", "\n", "https://docs.python.org/2/library/stdtypes.html\n", "\n", " \n", "Para tener más información sobre strings en Python se recomienda leer el siguiente tutorial:\n", "https://www.programiz.com/python-programming/string\n", "\n", "El ejemplo a continuación utiliza algunas funciones sobre strings:\n" ] }, { "cell_type": "code", "metadata": { "id": "8ULUVnBbTxtt" }, "source": [ "name = input(\"Hola, ¿cuál es su nombre? \")\n", "print(name, \"... muchas gracias!\")" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "K6da1cA5ULzL" }, "source": [ "#Procesamiento de texto : Examinar, editar, formatear texto.#\n", "\n", "Muchas veces se utilizan bucles para analizar el string caracter a caracter.\n", "Un *for* permite examinar cada caracter del string.\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "F7Benp4MU-_u" }, "source": [ "# Ejemplo de uso del 'for' para analizar un string.\n", "\n", "for c in \"juan\":\n", " print(c)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "PNa_Bh_bVRKU" }, "source": [ "Las computadoras representan los caracteres mediante un número para poder almacenarlos en memoria. Para eso existen diferentes mapeos de caracteres a números. Dos de los mapeos más utilizados son ASCII y UNICODE.\n", "\n", "ASCII codifica 128 caracteres (del 0 al 127) que incluyen los dígitos (0 al 9), las letras minúsculas, mayúsculas (del alfabeto en inglés) y algunos caracteres especiales como, por ejemplo, el tabulador, espacio, nueva línea, etc..\n", "\n", "Ver el código ASCII en: https://ascii.cl/es/\n", "\n", "ASCII es un subconjunto de UNICODE, es decir, los primeros 128 caracteres coinciden pero UNICODE agrega otros caracteres que no están en ASCII (por encima del número 128).\n", "\n", "Se puede acceder a la codificación de UNICODE en: https://unicode-table.com/es/#ipa-extensions\n", "\n", "Python tiene una función que dado un caracter devuelve el código ASCII asociado:\n", "\n", " ord(caracter) - convierte un caracter en un número (su código ASCII).\n", "\n", "\n", "Por ejemplo:\n", " * ord(\"A\") es 65.\n", " * ord(\"a\") es 97.\n", " * ord(\"b\") es 98.\n", " * ord(\"\\n\") es 10.\n", "\n", "Por otro lado, existe una función que hace la conversión en el otro sentido:\n", "\n", " chr(number) - convierte un número en un caracter.\n", "Ejemplos:\n", " * chr(65) es \"A\".\n", " * chr(99) es \"c\".\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "xnbLgnhEVmCP" }, "source": [ "#Ejercicio#\n", "\n", " 1. Se define la variable string s=\"abcde\" y s1= \"xyz”. Especular el resultado de las siguientes operaciones mediante su análisis, y luego verificar las respuestas corriendo el programa:\n", "\n", " * ¿Cuál es el resultado de s+s1?\n", " * ¿Cuál es el resultado de 3*s?\n", " * ¿Cuál es el resultado de s[1]?\n", " * ¿Cuál es el resultado de s[-1]?\n", " * ¿Cuál es el resultado de s[::2]?\n", " * ¿Cuál es el resultado de s[1::3]?\n", "\n", " A partir del análisis de los ejempos anteriores, explicar dados dos strings s1 y s2 cualquiera qué hace la operación suma, qué hace el producto por un escalar y qué sería s[-n], s[::n] y s[n:m:z].\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "y-xaoQsF-TJU" }, "source": [ "# Celda para realizar el ejercicio anterior\n", "s = \"abcde\"\n", "s1 = \"xyz\"\n", "\n", "\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "7F2Obn9Z-NJp" }, "source": [ "# **Ejercicio para entrega individual 1**\n", " Escribir un programa que dado un string genere otro string donde cada carácter es el original desplazado un valor n.\n", " \n", " Ejemplo \"ataque\" con n=1 sería \"bubrvf\".\n", " \n", "Aclaración: Por desplazar un caracter un valor n se quiere decir lo siguiente. Por ejemplo, si se tiene el caracter 'A', entonces como el código ASCII de el caracter 'A' es 65 (que se obtiene haciendo ord('A')), desplazarlo por ejemplo n=2, quiere decir cambiarlo por el caracter con código ASCII 67 que corresponde al caracter 'C' (es decir chr(ord('A')+ 2) = 'C').\n", "\n", "Sugerencia: Recorrer la lista de caracteres del string original y obtener para cada caracter su código ASCII usando la función ord( ) vista. Luego, crear un nuevo string donde cada nuevo caracter de este string, corresponde al caracter que se obtiene de sumar el código ASCII del caracter del string original con el desplazamiento n. \n", "\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "Cu-1-lvB-cm6" }, "source": [ "# Programa que desplaza en un carácter una palabra\n", "\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "r0Jv3TQeYNwL" }, "source": [ "#Listas en Python#\n", "\n", "La lista en Python es una colección que permite mantener muchos valores en una única variable. Por ejemplo, se puede crear una lista de amigos (lista de strings) y asignarla a la variable *Amigos* de la siguiente forma:\n", "\n", " Amigos = [ ‘juan’, ‘pedro’]\n", "\n", "Las variables utilizadas hasta ahora almacenan un valor. En caso de asignarles un valor nuevo, se pierde el anterior.\n" ] }, { "cell_type": "code", "metadata": { "id": "tH9G4J_aYVh5" }, "source": [ "# Por ejemplo:\n", "x=5\n", "x=6\n", "print(x)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "1apEwtO2YsFv" }, "source": [ "Las listas habitualmente se asignan con un conjunto de valores que luego pueden ser modificados.\n", "\n", "Se debe observar que los valores de la lista van entre corchetes [ ] y separados por comas.\n", "La lista puede ser de enteros, strings, números reales u otros tipos de datos de Python.\n", "\n", "Una lista también pueden mezclar diferentes tipos:\n", "\n", " nacimiento = [12,’Nov’, 2005]\n", "\n", "Incuso un elemento de la lista puede ser otra lista:\n", "\n", " a = [1.3, 2.8,[3,1]]\n", "\n", "Una lista también puede estar vacía:\n", "\n", " a = []\n", "\n", "En realidad ya hemos utilizado listas, sin saberlo. Ya un string es una lista en sí mismo." ] }, { "cell_type": "code", "metadata": { "id": "CFcx3ZAvY5uV" }, "source": [ "# Ejemplos\n", "\n", "for i in [5, 4, 3, 2, 1] :\n", " print(i)\n", "print('FIN')\n", "\n", "colores = ['rojo','azul','verde']\n", "for color in colores:\n", "\tprint(color)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "L-q0WiRRMgsJ" }, "source": [ "\n", "Al igual que con los strings, la función *len()* devuelve el tamaño de la lista. Por ejemplo:\n", "\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "QRFRtEb9MhD5" }, "source": [ "colores = ['rojo','azul','verde']\n", "print(len(colores))\n", "varios = [1,3.4,'valores',7,9.1]\n", "print(len(varios))\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "XmB61WBvNVot" }, "source": [ "A continuación se listan algunas operaciones básicas con listas (hay muchas más que se pueden ver en las referencias de Python):" ] }, { "cell_type": "code", "metadata": { "id": "28jPRo0JNWIs" }, "source": [ "# Concatenar listas\n", "a =[1,2,3]\n", "b =[\"hola\",5]\n", "c = a + b\n", "print(c)" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "5kyuFiYBOBzB" }, "source": [ "# Obtener una sublista\n", "c = [10,2,35,41,53]\n", "d = c[1:3]\n", "print(d)\n", "" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "s-ntQGL4OQyI" }, "source": [ "# Agregar un elemento a una lista: append(x)\n", "c = [10,2,35,41,53]\n", "c.append(\"verde\")\n", "print(c)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "UBq_1bb2OidN" }, "source": [ "# Eliminar el último elemento de la lista: pop()\n", "c = [10,2,35,41,53]\n", "c.pop()\n", "print(c)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "kmcpyVOAOvtl" }, "source": [ "# Eliminar el elemento de la lista de índice n: pop(n)\n", "c = [10,2,35,41,53]\n", "c.pop(1)\n", "print(c)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "CB-Us-5JPMrZ" }, "source": [ "#Ejercicio\n", "\n", "1. Estudiar y escribir código para mostrar qué se obtiene si se aplica a una lista de reales las funciones *max(list)*, *min(list)*, *sum(list)*.\n", "2. Estudiar y escribir código para mostrar cómo se hace para ordenar los elementos de una lista de números.\n", "\n", "3. Se definen las siguientes variables x e y\n", "\n", " x=[1, 2, 3, 4, 5]\n", " y=[11, 12, 13, 14, 15]\n", "\n", " 1. ¿Cuál es el valor de 3*x?\n", " 2. ¿Cuál es el valor de x+y?\n", " 3. ¿Cuál es el valor de x[1]?\n", " 4. ¿Cuál es el valor de x[0]?\n", " 5. ¿Cuál es el valor de x[-1]?\n", " 6. ¿Cuál es el valor de x[:]?\n", " 7. ¿Cuál es el valor de x[2:4]?\n", " 8. ¿Cuál es el valor de x[1:4:2]?\n", " 9. ¿Cuál es el valor de x[:2]?\n", " 10. ¿Cuál es el valor de x[::2]?\n", " 11. ¿Cuál es el resultado de las siguientes dos instrucciones?\n", " \n", " x[3]=8\n", " \n", " print(x)\n" ] }, { "cell_type": "markdown", "metadata": { "id": "8_ubvi2UQE1m" }, "source": [ "Para obtener más información sobre funciones a ejecutar sobre listas, se recomienda leer el siguiente material: https://docs.python.org/es/3/tutorial/datastructures.html\n" ] }, { "cell_type": "code", "metadata": { "id": "faS8ebbnYTTt" }, "source": [ "# Celda para ejercicios y pruebas\n", "\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "ols6XA6BSEhp" }, "source": [ "#Ejercicio#\n", "\n", "Escribir una **función** (revisa en el Taller 1 cómo se definen las funciones) que reciba como parámetros dos listas de números reales y devuelva, en **una lista de un elemento**, la suma del producto elemento a elemento de ambas listas. Por ejemplo si recibe $[2.0,5.5]$ y $[3.1,6.0]$ debe devolver $[2.0*3.1+5.5*6.0]$. Las listas pueden ser de cualquier largo pero ambas deben tener el mismo largo. La función lo primero que debe hacer es chequear que ambas listas tienen el mismo largo. Si las listas son de largos diferentes debe imprimir un mensaje de error y devolver una lista vacía. \n", "Escribir un programa que pruebe la función escrita.\n", "\n", "\n" ] }, { "cell_type": "code", "source": [ "# Escribir a continuación la función pedida y ejemplos de invocación.\n" ], "metadata": { "id": "wyuyQyvpo6Om" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "8PAQ9Q4xSLGv" }, "source": [ "## Ejercicio opcional\n", "Escribir una función que reciba como parámetros dos listas de números reales y devuelva una lista, donde cada elemento de la lista de salida es el elemento de la primera lista recibida elevado al correspondiente de la segunda lista recibida (elemento a elemento). Las listas pueden ser de cualquier largo pero ambas deben tener el mismo largo. La función lo primero que debe hacer es chequear que ambas listas tienen el mismo largo. Si las listas son de largos diferentes debe imprimir un mensaje de error y devolver una lista vacía. Escribir un programa que pruebe la función escrita, es decir que en otra celda escriba otro código que defina las listas de entrada y llame a la función creada y luego imprima lo que devuelve la función.\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "YBiT55SKZh79" }, "source": [ "#Ejemplo de lo que debe hacer el código\n", "# Si la función recibe por ejemplo las siguientes dos listas\n", "[1.1,2.2]\n", "[2,3]\n", "#debe devolver la siguiente lista\n", "[1.1**2,2.2**3]" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "MVumgowWL8pB" }, "source": [ "# Celda para resolución de ejercicio opcional (es muy similar al anterior, pero el resultado es una lista del mismo largo que las que se ingresaron como parámetros)" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "A2kNV3yUWm4F" }, "source": [ "#Introducción a la biblioteca numpy de Python#\n", "\n", "*Numpy*, que es una biblioteca que usaremos mucho y permite hacer cálculo científico, tiene muchas funciones matemáticas que serán de gran utilidad. La utilizaremos también con la biblioteca matplotlib, que permitirá graficar vectores (entre otras cosas), y se verá en más detalle en el próximo taller.\n", "\n", "*Numpy* es un paquete básico para cálculo científico con Python. Permite hacer vectores N-dimensionales (matrices, por ejemplo). Tiene funciones para álgebra lineal, para ver las frecuencias de una señal, para trabajar con números aleatorios, etc.\n", "\n", "Sobre esta biblioteca además se han desarrollado otros paquetes (por ejemplo *Scipy*, de la que utilizaremos algunas funciones más adelante).\n", "\n", "#Los arrays de numpy#\n", "El siguiente código muestra el uso básico de numpy:\n", "\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "Ofw8tnwzWkpr" }, "source": [ "# Lo primero siempre es importar la biblioteca y en este caso se le asigna un nombre, np, para no tener que escribir numpy cada vez\n", "import numpy as np\n", "# Creación de vectores (arrays para numpy) de dos dimensiones.\n", "# Observar que se crean a partir de las listas de Python\n", "A = np.array([[1, 2, 3], [4, 5, 6]])\n", "print(A)\n", "# Observar que el resultado es una matriz en este caso de 2 filas y 3 columnas" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "JMyVWnnyW4YB" }, "source": [ "Los vectores o arrays en numpy también se pueden crear de otras formas :\n" ] }, { "cell_type": "code", "metadata": { "id": "WiwZjPG3XM_g" }, "source": [ "# Crear un array numpy mediante uso de la función arange de numpy.\n", "# Consultar que hace la función 'arange' y qué parámetros recibe.\n", "import numpy as np\n", "arr = np.arange(0, 1, 0.2)\n", "print(arr)" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "wM3keoMXXrJ0" }, "source": [ "# Crear un array de numpy mediante la función linespace de numpy\n", "# Buscar qué hace la función 'linspace' y qué parámetros recibe\n", "import numpy as np\n", "arr = np.linspace(0, 2*np.pi, 4)\n", "print(arr)" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "Yee46IefYD4U" }, "source": [ "# Crear un array de numpy mediante la función zeros de numpy.\n", "import numpy as np\n", "# Creo un array de 2 filas y 3 columnas con todos ceros\n", "A = np.zeros((2,3))\n", "print(A)\n", "#La función shape de un array de numpy nos devuelve las dimensiones del array\n", "print(A.shape)\n", "\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "wsaH-7sEZJCX" }, "source": [ "Probar también otras funciones para crear e inicializar vectores con numpy como por ejemplo: *np.ones* y *np.diag*, y ver qué se obtiene.\n", "\n", "Asignación de arrays en numpy: observar que al modificar uno se modifica también el original.\n", "\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "wDq5F-x2ZPb1" }, "source": [ "\n", "import numpy as np\n", "A = np.zeros((2, 2))\n", "C = A\n", "C[0, 0] = 1\n", "print(C)\n", "print(A)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "Ejfxf2hxmUIH" }, "source": [ "import numpy as np\n", "A = np.zeros((2, 2))\n", "B = np.zeros((2, 2))\n", "A[0, 0] = 1\n", "B[0, 0] = 2\n", "B[1,1] = 5\n", "print(A)\n", "print(B)\n", "print(A+B)" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "9iGn9CERZcuy" }, "source": [ "Los arrays en numpy se pueden sumar, multiplicar y otras operaciones de cálculo.\n", "#Ejercicio#\n", "Escriba un programa que muestre la diferencia entre sumar o multiplicar por un número listas de Python y arrays numpy. \n", "\n", "\n", "\n" ] }, { "cell_type": "code", "source": [ "# Celda para resolución de ejercicio" ], "metadata": { "id": "5aQPp-R4y_ZX" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "HgeWJdzemUtD" }, "source": [ "#Operaciones con arrays *Numpy*#\n", "\n", "Las siguientes son algunas operaciones básicas con arrays *Numpy*.\n", "\n", "Hay muchas más funciones en *Numpy*, esto es solo lo básico. Se recomienda ver la documentación de *Numpy* para ver otras funciones." ] }, { "cell_type": "code", "metadata": { "id": "j3NrYSCSZ3P4" }, "source": [ "#Para obtener una parte de un vector con numpy:\n", "#a[2, :] me da la tercer fila, y todas las columnas\n", "#a[1:3] segunda y tercer fila, todas las columnas\n", "#a[:, 2:4] # todas las filas, columnas 3 y 4\n", "\n", "A = np.array([[1, 2, 3], [4, 5, 6],[7, 8, 9]])\n", "print(A)\n", "print(A[2, :]) # me da la tercer fila, y todas las columnas\n", "print(A[1:3]) # segunda y tercer fila, todas las columnas\n", "print(A[:, 1:3]) # todas las filas, columnas 2 y 3\n", "\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "y7UdxHDKabY3" }, "source": [ "#Uso de números aleatorios en numpy#\n", "\n", "En el siguiente ejemplo se crea un array de dimensiones 2x3 de números aleatorios entre 0 y 1:\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "3X2AxGXHamqc" }, "source": [ "#Ejecute el ejemplo varias veces y verá que da resultados diferentes\n", "import numpy as np\n", "A = np.random.random((2,3))\n", "print(A)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "A2u2cDCZa7KD" }, "source": [ "#Ejercicio #\n", "Escriba un programa que realice las siguientes tareas:\n", " 1. Defina una función llamada matriz que acepte un entero $N$ como parámetro de entrada, construya y retorne un vector numpy de dos dimensiones (N $\\times$ N) con un valor $-2.0$ en la diagonal principal y un valor 1.0 en la supradiagonal y en la subdiagonal. Llamaremos $A$ a la matriz que devuelve.\n", " 2. Para $N=3$. Se define el vector $x =[x_1,x_2,x_3]$. Escribir una función que reciba el vector $x$ y devuelva el vector producto de $Ax$, siendo A una matriz como la generada en la parte 1.\n", "\n", " Observación: Si se tiene una matriz $A$ 3x3 de coeficientes aij (este es el elemento de la fila i y la columna j) y se lo multiplica por un vector columna x de componentes $[x_1,x_2,x_3]$. $Ax$ se define como el vector columna de componentes $[a_{11} x_1+ a_{12} x_2+a_{13} x_3, a_{21} x_1+ a_{22} x_2+a_{23} x_3, a_{31} x_1+ a_{32} x_2+a_{33} x_3]$. Observar además que en Python los vectores, listas, matrices se indexan desde cero y no desde 1 por lo que hay que adaptar la notación.\n", " 3. Escriba un programa que verifique que el resultado de la función de la parte anterior es el correcto." ] }, { "cell_type": "code", "metadata": { "id": "oe4oA70E-zt4" }, "source": [ "# Celda para resolución de ejercicio" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "VzEdMBjLbkXe" }, "source": [ "#**Ejercicio**#\n", "\n", "\n", "\n", " Cuando se tiene un array $ar$ con $N$ valores, el promedio de los valores del array se calcula como:\n", "\n", "$$pm= \\frac{ \\sum_{j=0}^{N-1} ar[j]}{N}$$\n", "\n", "\n", "\n", "\n", "Esto asume que se tienen almacenados los $N$ valores del array. Sin embargo, muchas veces este valor de N es grande o indeterminado, debido a que los valores se reciben de a uno. Esto implica que no se puedan almacenar todos los valores en un array porque la cantidad de datos del array puede ser mayor que la memoria disponible. \n", "\n", "También se podría ir almacenando la suma de los valores recibidos ($sm(N) =\\sum_{j=0}^{N-1} ar[j]$) y la cantidad $N$ de valores recibidos.\n", "Cuando llegue un nuevo valor ($ar[N+1]$), se podrá calcular el promedio sumando al valor de la suma guardada el nuevo valor $sm(N)+ar[N+1]$ y luego dividiendo esto entre $N+1$.\n", "Ahora se deben almacenar únicamente dos valores en lugar de los N valores del array. Pero esta solución tiene como inconveniente que la suma, si los valores del array son numéricamente grandes y son muchos, puede desbordar la memoria.\n", "\n", "Por eso, para ir calculando en línea el promedio se utiliza la siguiente ecuación:\n", "\n", "$pm[N]= \\frac{ \\sum_{j=0}^{N-1} ar[j]}{N} = \\frac{ \\sum_{j=0}^{N-2} ar[j] *\\frac{N-1}{N-1} + ar[N-1]}{N} = pm[N-1]* \\frac{N-1}{N} + \\frac{ar[N-1]}{N}$\n", "\n", "1. Comprender y explicar esta fórmula\n", "\n", "2. Implementar la función $\\texttt{calcular_promedio}$ que recibe: el valor de N hasta ahora, el promedio hasta ahora y un nuevo dato. Esa función debe implementar la fórmula anterior y devolver el nuevo promedio y el valor de N actualizado. Verificar su funcionamiento con el siguiente código.\n", "\n", "3. Explicar el funcionamiento del programa y si con la verificación se obtuvo lo esperado.\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "QmxbvshQugjL" }, "source": [ "# Celda para resolución de ejercicio (escritura de la función calcular_promedio)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "IXU0nbAT-682" }, "source": [ "#prueba con un vector de datos aleatorios\n", "ar = np.random.random((10000))\n", "prom = 0\n", "N= 0\n", "\n", "for ari in ar:\n", " prom,N = calcular_promedio(N,prom,ari)\n", "\n", "print('\\n ENSAYO DE VERIFICACIÓN \\n')\n", "\n", "print('Promedio en línea: ', prom,'.Total de muestras: ',N)\n", "\n", "#comparo con el promedio del array calculado con numpy\n", "promedio_verificacion = np.mean(ar)\n", "print('Promedio de verificación:', promedio_verificacion)\n", "\n", "if abs(prom - promedio_verificacion) < 1e-6:\n", " print(\"Exito en la verificación!!\")\n", "else:\n", " print(\"Falla en la verificación\")" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "b88t5Mgo-ySE" }, "source": [ "\n", "\n", "\n", "\n", "#**Ejercicio para entrega individual 2**#\n", "Suponer un programa que genere un array numpy aleatorio de 1000 valores. Con este ejercicio se buscará generar otro array cuyos valores sean el promedio móvil de $N$ valores del array aleatorio. Esto quiere decir lo siguiente: si llamamos $ar$ al array aleatorio y $pm$ al promedio móvil, entonces el elemento $i$ de $pm$ se obtiene de:\n", "\n", "$pm[i] = \\frac{ \\sum_{j=i}^{i+N-1} ar[j]}{N}$\n", "\n", "\n", "Tener en cuenta que la sumatoria anterior tiene sentido si $i+N-1 \\leq 999$.\n", "\n", "Crear una función *promedio_movil* que reciba el array a promediar y N. Esa función debe devolver en otro array los valores del promedio móvil.\n", "\n", "Correr su programa usando el código suministrado más abajo y grafique los valores obtenidos para diferentes valores de N=1,2,..,20. El código utiliza una de las bibliotecas que hay en Python para graficar: matplotlib. Esta biblioteca la utilizaremos con frecuencia en los siguientes talleres así que se aconseja buscar información sobre su uso y posibilidades.\n", "\n", "Una vez hechas las gráficas, explicar qué sucede y por qué, en especial cuando se va aumentando el valor de $N$." ] }, { "cell_type": "code", "metadata": { "id": "hfrWsqGebj51" }, "source": [ "#FUNCION AUXILIAR PARA GRAFICAR\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "def graficar(vector,N,titulo):\n", " # matriz es un array(M,N) donde M es la cantidad de\n", " # vectores a graficar y N es el largo de cada vector\n", "\tf, ax = plt.subplots(1, 1, figsize=(10,10))\n", "\tax.plot(vector)\n", "\tax.set_xlim((0, N))\n", "\tax.set_ylim((0, 1))\n", "\t#ax.set_xlabel('mi etiqueta x')\n", "\t#ax.set_ylabel('mi etiqueta y')\n", "\tax.set_title(titulo)\n", "\tplt.tight_layout()\n", "\n", "\tplt.show()\n", "\tplt.savefig('gráfico_1.pdf')\n", "\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "bJqZWj-Q_CDH" }, "source": [ "#función a codificar del ejercicio, escritura de la función promedio_movil\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "# código de prueba de la función anterior\n", "vector = np.random.random(1000)\n", "for N in range(1,21):\n", " pm_movil = promedio_movil(vector, N)\n", " graficar(pm_movil, len(pm_movil), titulo=\"Ventana movil\")" ], "metadata": { "id": "GNfMBNplA6JP" }, "execution_count": null, "outputs": [] } ] }