Array (parte 1)

Contenido
Motivación: graficar funciones

Importando paquetes y módulos

Creación de arrays

Accediendo a y modificando elementos

Operaciones elemento a elemento y broadcasting

Graficando funciones

Graficando múltiples lineas

Motivación: graficar funciones

Para graficar una función y = f (x) en un dado rango de x , tenemos que:

1. elegir algunos valores x i en ese rango,

2. calcular y i = f (x i ) ,
3. graficar los puntos (x i , y i ) y unirlos con lineas.

Para el primer punto, podríamos guardar los x i en una lista:

x = [0, 1, 2, 3]

Para el segundo punto, podríamos recorrer dicha lista, aplicar la función a cada valor, y guardar el resultado
en otra lista.

Por ejemplo, para f (x) = x2:

y = []
for xi in x:
yi = xi**2
[Link](yi)

y
 [0, 1, 4, 9]

Volver arriba
Pero, se puede hacer de una manera mucho más simple (y rápida) utilizando un array de NumPy.

Importando paquetes y módulos

Para poder reutilizar valores, los asignamos en variables.

Para poder reutilizar bloques de código, definimos funciones, que nos permiten volver a correrlos
cambiando algunas variables (parámetros).

Para poder reutilizar funciones, hay que crear módulos, que nos permiten «importar» variables y funciones,
y reutilizarlas en diferentes proyectos.

Hasta ahora, estuvimos usando funciones, como print y len , que vienen «pre-importadas» en Python.

Python incluye varios módulos, donde hay funcionalidad extra que nos puede ser útil.

Por ejemplo, el módulo math , que podemos importar así:

import math

Ahora, tenemos una variable math que contiene el módulo math :

math

<module 'math' from '/home/runner/work/python-tutorial/python-tutorial/.pixi/envs/defaul

Para acceder a las variables y funciones dentro de math , hay que agregar math. antes.

Por ejemplo, la constante π está definida dentro de math :

[Link]

3.141592653589793

y la función coseno:
 [Link](0)

1.0

Hay otros módulos que no vienen pre-incluidos en Python, y hay que instalarlos aparte.

Los que vamos a usar, numpy y matplotlib , ya vienen pre-instalados en Google Colab.

import [Link] as plt

import numpy as np

Como el nombre del módulo es muy largo, se le puede asignar un alias con el as .

La convención es llamar np a numpy y plt a [Link] .

Entonces, en la variable plt está el (sub)módulo pyplot de matplotlib :

plt

<module '[Link]' from '/home/runner/work/python-tutorial/python-tutorial/.pix

que nos permitirá realizar gráficos.

Al igual que el módulo math , NumPy también define la constante π :

[Link]

3.141592653589793

y la función coseno:

[Link](0)

np.float64(1.0)

¿Por que vamos a usar NumPy en lugar del módulo math ?

Porque, como veremos más adelante, las funciones de NumPy nos permiten operar sobre arrays.

Creación de arrays
Para crear un array, le podemos pasar una lista a la función [Link] :

x = [2, 3, 5]
x = [Link](x)

array([2, 3, 5])

También hay diversas funciones que permiten crear arrays comúnmente utilizados.

Por ejemplo, un array de n ceros:

[Link](5)

array([0., 0., 0., 0., 0.])

o funciones para crear rangos de números, como:

1. arange(start, stop, step)

2. linspace(start, stop, num)

La primera es análoga a range(start, stop, step) , que crea números desde start , hasta (pero sin
incluir) stop , separados por un paso step :

[Link](0, 10, 2)

array([0, 2, 4, 6, 8])

La segunda nos permite especificar la cantidad de números, num , en lugar del paso entre números:

[Link](0, 10, 5)
 array([ 0. , 2.5, 5. , 7.5, 10. ])

y los genera equiespaciados entre start y stop .

Es decir, genera un paso step = (stop - start) / num .

Ejercicio 1
Crear un array de 9 números equiespaciados en el intervalo [−1, 1] .

# Escriba su solución aquí

Solución

Show code cell content

Accediendo a y modificando elementos

El array es similar a la lista, y comparten ciertos comportamientos.

x = [Link]([2, 3, 5])

array([2, 3, 5])

Al igual que una lista, se puede acceder al primer elemento como:

x[0]

np.int64(2)

O reasignar el segundo elemento:

 x[1] = 7

array([2, 7, 5])

Pero, a diferencia de la lista, no se puede cambiar la cantidad de elementos, ya sea borrando:

del x[0]

---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
Cell In[20], line 1
----> 1 del x[0]

ValueError: cannot delete array elements

o agregando nuevos elementos al final:

[Link](7)

---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
Cell In[21], line 1
----> 1 [Link](7)

AttributeError: '[Link]' object has no attribute 'append'

Entonces, ¿qué tiene de bueno el array ?

Operaciones elemento a elemento y broadcasting

El array de NumPy nos permite hacer operaciones aritméticas entre elementos sin tener que recorrer el
array con un for-loop.

Por ejemplo, si tenemos dos arrays x e y :

x = [Link]([1, 2, 3])
y = [Link]([10, 20, 30])
podemos calcular la suma elemento a elemento, x[i] + y[i] , como:

x + y

array([11, 22, 33])

Para el caso de la suma, es igual a la suma vectorial, si piensan los arrays como vectores.

Pero también funciona con otras operaciones, que no están definidas para vectores:

x * y

array([10, 40, 90])

Si los arrays tienen diferente tamaño, nos arroja un error:

[Link]([1, 2, 3]) + [Link]([1, 2])

---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
Cell In[25], line 1
----> 1 [Link]([1, 2, 3]) + [Link]([1, 2])

ValueError: operands could not be broadcast together with shapes (3,) (2,)

Pero, ¿qué sucede si queremos sumarle un número a x ?

x + 1

array([2, 3, 4])

A esto le llama broadcasting, que consiste en «estirar» el 1 hasta que tenga el mismo largo que x , y
realizar la suma elemento a elemento.

Imprimir en PDF
Funciona para todas las operaciones aritméticas, y permite escribir el código de manera más simple, como
si estuviésemos trabajando con un solo número.
 2 * x

array([2, 4, 6])

x**2

array([1, 4, 9])

NumPy también define ciertas funciones matemáticas que saben operar sobre arrays, es decir, elemento a
elemento:

[Link](x)

array([ 2.71828183, 7.3890561 , 20.08553692])

Por ejemplo, si definimos un array de ángulos (en radianes), podemos calcular el seno de cada ángulo
como:

angulos = [Link] * [Link]([0, 1 / 4, 1 / 2])

[Link](angulos)

array([0. , 0.70710678, 1. ])

En cambio, si queremos usar la función seno del módulo math :

[Link](angulos)

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[31], line 1
----> 1 [Link](angulos)

TypeError: only length-1 arrays can be converted to Python scalars

Si quieren ver que funciones define NumPy, pueden leer la documentación.

Ejercicio 2
Generar un array con los 10 primeros números enteros, k ∈ {0, 1, … } , y calcular:

sus cuadrados: k
2

las potencias de 2 : 2 .
k

# Escriba aquí su solución

Solución

Show code cell content

Graficando funciones
Recordemos:

Para graficar una función y = f (x) en un dado rango de x , tenemos que:

1. elegir algunos valores x i en ese rango,

2. calcular y i = f (x i ) ,
3. graficar los puntos (x i , y i ) y unirlos con lineas.

Con estas herramientas, podemos graficar funciones muy fácilmente.

Para el primer punto, podemos usar la función [Link] .

Para el segundo punto, aprovechamos las operaciones elemento a elemento y broadcasting de NumPy.

Para el tercer punto, vamos a usar la función plot de [Link] (que importamos como
plt ).

Por ejemplo, grafiquemos una función cuadrática:

x = [Link](-1, 1, 100)
y = x**2

[Link](x, y)
 [<[Link].Line2D at 0x7f1ae0c46ad0>]

Al graficar, matplotlib grafica puntos en las posiciones (x[i], y[i]) y los une con lineas.

Esto es más claro si usamos una menor cantidad de puntos:

x = [Link](-1, 1, 5)
y = x**2

[Link](x, y)

[<[Link].Line2D at 0x7f1ae0dba0d0>]
También, podemos agregar la opción marker para que dibuje los puntos:

[Link](x, y, marker="o")

[<[Link].Line2D at 0x7f1ae0b52910>]
En este caso, elegimos o como marker, pero hay más variantes para elegir, que pueden consultar en la
documentación.

Ejercicio 3
Graficar el polinomio f (x) = 2x 2 − 5x + 2 en el rango −3 ≤ x ≤ 1 .

# Escriba aquí su solución

Solución

Hide code cell content

x = [Link](-3, 1, 50)
y = 2 * x**2 + 5 * x + 2

[Link](x, y)

[<[Link].Line2D at 0x7f1ae0cb5b10>]
Graficando múltiples lineas
Para graficar múltiples lineas, se puede llamar múltiples veces a la función [Link] .

Por ejemplo,

x = [Link](-1, 1, 100)

[Link](x, x)
[Link](x, x**2)
[Link](x, x**3)

[<[Link].Line2D at 0x7f1ae0a6d350>]
Si le damos un nombre a cada línea con el parámetro label , y podemos usar la función [Link]
para que nos muestre la leyenda:

x = [Link](-1, 1, 100)

[Link](x, x, label="x")
[Link](x, x**2, label="x^2")
[Link](x, x**3, label="$x^3$")

[Link](title="Función")

<[Link] at 0x7f1ae0dcd490>
Ejercicio 4
Para el rango x ∈ [−π, π] , graficar la sumatoria:

1 sin(kx)
f (x) = ∑
4π k∈N impar
k

donde la suma es sobre los números naturales impares. Es decir, k ∈ {1, 3, 5, … } .

Equivalentemente, se puede escribir como:

n sin ((2k + 1) x)
1
f (x) = ∑
4π k=0 (2k + 1)

para k ∈ {0, 1, 2, … } .

Cortar la sumatoria en diferente cantidad de términos. Por ejemplo, n ∈ {1, 2, 3, 10, 100} .

# Escriba aquí su solución

Solución

Hide code cell content

def onda_cuadrada(x, n_terminos):

y = 0
for k in range(1, 2 * n_terminos + 1, 2):
y = y + [Link](k * x) / k
y = y / ([Link] / 4)
return y

x = [Link](-[Link], [Link], 1000)

for n_terminos in (1, 2, 3, 10, 100):

[Link](x, onda_cuadrada(x, n_terminos=n_terminos), label=n_terminos)

[Link](title="N términos")

<[Link] at 0x7f1ae09060d0>
 Array (parte 2)
Imprimir en PDF

Contenido
Cargando un archivo

Visualizando datos

Indexing y slicing

Reducción

import [Link] as plt

import numpy as np

[Link]("figure", dpi=100) # aumenta la resolución de las figuras

Cargando un archivo
Hay muchos formatos para guardar datos en archivos. El más simple es guardarlos en un archivo de texto.

En este caso, tenemos preparado un archivo de ejemplo que pueden descargar de aqui.

Si están corriendo este notebook en Google Colab, pueden descargar el archivo de ejemplo corriendo la
siguiente linea en una celda de código:

!wget [Link]

También, pueden descargarlo manualmente, y subirlo a Google Colab.

Si abren el archivo [Link] en un editor de texto, como el bloc de notas o notepad, pueden ver que es
un archivo de texto con un número en cada línea:

10.50
9.86
10.65
...
Para cargarlo a un array de NumPy, podemos usar la función [Link] , a la que le tenemos que pasar
el nombre o ubicación del archivo:

datos = [Link]("[Link]")

datos

array([10.5 , 9.86, 10.65, 11.52, 9.77, 9.77, 11.58, 10.77, 9.53,

10.54, 9.54, 9.53, 10.24, 8.09, 8.28, 9.44, 8.99, 10.31,
9.09, 8.59, 11.47, 9.77, 10.07, 8.58, 9.46, 10.11, 8.85,
10.38, 9.4 , 9.71, 9.4 , 11.85, 9.99, 8.94, 10.82, 8.78,
10.21, 8.04, 8.67, 10.2 , 10.74, 10.17, 15. , 9.7 , 8.52,
9.28, 9.54, 11.06, 10.34, 8.24, 10.32, 9.61, 9.32, 10.61,
11.03, 10.93, 9.16, 9.69, 10.33, 10.98, 9.52, 9.81, 8.89,
8.8 , 10.81, 11.36, 9.93, 11. , 10.36, 9.35, 10.36, 11.54,
9.96, 11.56, 7.38, 10.82, 10.09, 9.7 , 10.09, 8.01, 9.78,
10.36, 11.48, 9.48, 9.19, 9.5 , 10.92, 10.33, 9.47, 10.51,
10.1 , 10.97, 9.3 , 9.67, 9.61, 8.54, 10.3 , 10.26, 10.01,
9.77])

Si tienen problemas al cargar el archivo, puede deberse a que no se encuentre en la misma carpeta en la
que están ejecutando el notebook.

Números con coma decimal

Un problema típico es que los programas de adquisición de datos hayan guardado los números con coma,
en lugar de punto, como separador decimal.

En ese caso, necesitan definir una función para convertir los números con coma, y pasársela a
[Link] en el parámetro converters :

def comma_to_float(x):
x = [Link]().replace(",", ".")
return float(x)

[Link]("[Link]", converters=comma_to_float)

En versiones de NumPy anteriores a la 1.23, hay que pasar un diccionario con numero_de_columna:
funcion . En este caso, que solo hay una columna, sería para la columna 0 :

[Link]("[Link]", converters={0: comma_to_float})

Comentarios o títulos
Otro problema sucede cuando en la(s) primera(s) línea(s) del archivo no hay números, sino texto con
comentarios o títulos sobre los datos. Podemos decirle que se saltee la primera linea con:

[Link]("[Link]", skiprows=1)

Si lo llegaran a necesitar, pueden ver más opciones para [Link] en la documentación.

Visualizando datos
Lo primero y más importante que hay que hacer al trabajar con datos es visualizarlos.

Una forma es usar la función [Link] , que usamos en la sección anterior:

[Link](datos, marker="o")

[<[Link].Line2D at 0x7f6f50839050>]

Cuando solo le pasamos un array a [Link] , lo usa para los valores en y , mientras que para x usa la
posición (o índice) de cada valor.
Es decir, x = [Link](len(y)) .

Otra forma de visualizarlos es hacer un histograma:

[Link](datos, bins="auto")

[Link]("Cantidad de datos")

Text(0, 0.5, 'Cantidad de datos')

Un histograma se construye dividiendo el rango de los datos en «canastas», o bins , y contando cuantos
datos caen en cada canasta.

En el histograma anterior, dejamos que la cantidad y ancho de los bins se elijan automáticamente, pero se
pueden especificar manualmente.

A diferencia del gráfico de linea, en el histograma se puede entender mejor la distribución de los datos. Hay
una mayor cantidad de datos alrededor de ~10, y disminuye su cantidad a medida que nos alejamos.

En ambos gráficos, podemos notar que hay un valor, alrededor de 15 , que se aleja significativamente del
resto. Veamos como podemos hacer para descartarlo*.

(*no vamos a discutir acá si está bien o no descartarlo)

Indexing y slicing
Los arrays de NumPy permiten seleccionar un subconjunto de elementos de diversas maneras.

Para el siguiente array:

x = [Link]([10, 20, 5, 7, 8])

podemos seleccionar un elemento particular por su índice, por ejemplo, el tercer elemento como:

x[2]

np.int64(5)

(recuerden que el primer elemento es el 0 ).

Si queremos acceder al último elemento, necesitamos saber el largo del array. Podemos usar la función
len , y restarle 1 :

x[len(x) - 1]

np.int64(8)

Python nos permite ahorrarnos el len(x) y directamente poner -1 :

x[-1]

np.int64(8)

Para seleccionar un rango (o slice) de elementos, usamos:

x[1:3]

array([20, 5])
donde la sintaxis es x[start:stop] , incluyendo start y excluyendo stop , al igual que la función
range .

Otras variantes de slicing son:

especificar el paso con x[start:stop:step] ,

omitir start , x[:stop] , donde el valor por defecto es 0 ,

omitir stop , x[start:] , donde el valor por defecto es «hasta el final».

Por ejemplo, para seleccionar los dos primeros elementos:

x[:2]

array([10, 20])

Todo esto también es válido para las listas, pero lo siguiente no.

Advanced indexing
NumPy permite indexar los arrays de otras maneras, que no son válidas para la lista.

Una de ellas es pasarle una lista con los índices de los valores que queremos:

x[[0, 1, 3]]

array([10, 20, 7])

Otra es pasarle un array de valores booleanos, es decir, True o False .

Si este array tiene True en la posición i -ésima, es que queremos quedarnos con el valor en la posición
i -ésima, y False , que no lo queremos.

Para generar este array, podemos usar operadores de comparación:

x > 7

array([ True, True, False, False, True])

Recuerden que x era:

array([10, 20, 5, 7, 8])

Entonces, podemos usar ese array para quedarnos con los valores mayores a 7 :

x[x > 7]

array([10, 20, 8])

Si queremos obtener los índices donde se cumple la condición, podemos usar la función [Link] :

[Link](x > 7)

(array([0, 1, 4]),)

Ejercicio 1
Filtrar los datos para descartar el dato cuyo valor es ~15, y rehacer el histograma para los datos filtrados.

# Escriba aquí su solución

Solución

Show code cell content

Reducción
De esta parte sobre los arrays de NumPy, nos queda aprender las operaciones de reducción.

Hasta ahora, habíamos visto las operaciones elemento a elemento y de broadcasting.

En la primera, a partir de dos arrays iguales, se generaba un tercero del mismo tamaño.

En la de broadcasting, al combinar un número con un array, el número se «estiraba» al tamaño del array, y
se combinaba elemento a elemento.

En las operaciones de reducción, partimos de un array y lo reducimos a un número.

Por ejemplo, para este array:

x = [Link]([1, 2, 4, 3])

podemos usar la función [Link] para calcular la suma:

[Link](x)

np.int64(10)

o [Link] para calcular el máximo:

[Link](x)

np.int64(4)

o [Link] para encontrar la posición del máximo:

[Link](x)

np.int64(2)

y muchas otras que pueden buscar en la documentación.

 Nota

Puede parecer innecesario que haya un término específico, reducción, para operaciones como
calcular la suma o el máximo. Pero va a tener sentido cuando veamos arrays en 2 o más
dimensiones.
Ejercicio 2
Para el array de datos filtrados, calcular la cantidad de datos, su promedio x̄ , y su desviación estándar σ
^.

La fórmula para estos últimos es:

n
x1 + … + xn 1
x̄ = = ∑ xi
n n i=1

 n
(x 1 − x̄) 2 + … + (x n − x̄) 2 1
^ =√
σ = ∑ (x i − x̄) 2
n ⎷n i=1

Ayuda: usar las funciones [Link] , [Link] . Para restar el promedio a todos los números, rever la
sección, broadcasting.

# Escriba aquí su código

Solución

Hide code cell content

x = datos_filtrados

total = [Link](x)
promedio = [Link](x) / total
varianza = [Link]((x - promedio) ** 2) / total
desv_estandar = varianza**0.5

total, promedio, desv_estandar

(99, np.float64(9.896464646464647), np.float64(0.9080919202475125))

función que encapsule esas operaciones.

Pero esas funciones ya están definidas en NumPy:

[Link](x), [Link](x), [Link](x)


Si necesitáramos calcular constantemente la desviación estándar de los datos, nos convendría definir una
(99, np.float64(9.896464646464647), np.float64(0.9080919202475125))

mean es media o promedio en inglés,

std viene de standard deviation, desviación estándar en inglés.