Pensamiento Computacional
NumPy
Introducción
Equipo Docente
Universidad de San Andrés
Buenos Aires
Mayo 2022
¿Qué es?
NumPy
El paquete es conocido por una estructura de datos muy útil
llamado arreglo de NumPy. NumPy también permite a los
desarrolladores de Python realizar en forma rápida una
amplia variedad de cálculo numéricos.
NumPy es una librería de Python para computación
científica. NumPy significa Python numérico.
1 23
Introducción
Principal beneficio
Permite una generación y manejo de datos extremadamente
rápido.
NumPy tiene su propia estructura de datos incorporada
llamado arreglo que es similar a la lista normal de Python,
pero puede almacenar y operar con datos de manera mucho
más eficiente.
2 23
Principal beneficio
Permite una generación y manejo de datos extremadamente
rápido.
NumPy tiene su propia estructura de datos incorporada
llamado arreglo que es similar a la lista normal de Python,
pero puede almacenar y operar con datos de manera mucho
más eficiente.
3 23
Arreglos en NumPy
Arreglos
Los arreglos NumPy son la forma principal de almacenar
datos.
Son similares a las listas normales en Python, pero tienen la
ventaja de ser más rápidas y tener más métodos integrados.
Son creados llamando al método array() de la librería de
NumPy. Dentro del método, deberías pasar una lista.
El contenedor array() indica que ya no es una lista normal de
Python. En cambio, es un arreglo de NumPy.
import numpy as np
sample_list = [1, 2, 3]
[Link](sample_list)
# array([1,2,3])
4 23
Dos tipos principales de arreglos
Los vectores son arreglos de NumPy uni-dimensionales.
Las matrices son arreglo bi-dimensionales y son creadas
pasando una lista de lista dentro del método [Link]().
También puedes expandir los arreglos de NumPy para
trabajar con matrices de tres, cuatro, cinco, seis o más
dimensiones.
my_vector = [Link](['este', 'es', 'un', 'vector'])
my_matrix = [[1, 2, 3],[4, 5, 6],[7, 8, 9]]
[Link](my_matrix)
5 23
Métodos
Arange
Toma dos números y devuelve un arreglo de números
enteros que son mayores o iguales a (>=) el primer número y
menores que (<) el segundo número.
También puedes incluir una tercera variable en el método
arange que proporciona un tamaño de paso para que la
función regrese.
[Link](0,5)
#Devuevle array([0, 1, 2, 3, 4])
[Link](1,11,2)
#Devuelve array([1, 3, 5, 7, 9])
6 23
Arreglos de ceros y unos
De vez en cuando es necesario crear arreglos de unos o
ceros.
Podemos crear arreglos de ceros utilizando el método zeros.
Le pasas el número de enteros que quisieras crear como el
argumento de la función.
También puedes hacer algo similar utilizando matrices de
dos o más dimensiones.
Podemos crear arreglos de unos usando un método similar
llamado ones.
[Link](4)
#Devuelve array([0, 0, 0, 0])
[Link](5)
#Devuelve array([1, 1, 1, 1, 1])
[Link](5,5) # ¿Qué devuelve?
7 23
División uniforme de rangos
El método linspace de NumPy está diseñado para dividir
rangos de manera uniforme.
Tiene tres argumentos:
I El inicio del intervalo.
I El fin del intervalo.
I El número de subintervalos en los que deseas que se divida
el intervalo.
[Link](0, 1, 10)
#Devuelve array([0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7
8 23
Arreglo identidad
Es un arreglo cuadrada cuyos valores diagonales son todos 1.
[Link](1)
#Devuelve un arreglo identidad de 1x1
[Link](2)
#Devuelve un arreglo identidad de 2x2
[Link](50)
#Devuelve un arreglo identidad de 50x50
9 23
Creación de números aleatorios
Existens varios métodos integrados que te permiten crear
matrices de números aleatorios.
Cada uno de estos métodos comienza con random.
[Link](sample_size) Devuelve una muestra de
números aleatorios entre 0 y 1. El tamaño de la muestra
puede ser un número entero (para un arreglo
unidimensional) o dos enteros separados por comas (para
un arreglo bidimensional).
[Link](sample_size) Devuelve una muestra de
números aleatorios entre 0 y 1, siguiendo la distribución
normal. El tamaño de la muestra puede ser un número
entero (para un arreglo unidimensional) o dos enteros
separados por comas (para un arreglo bidimensional).
[Link](low, high, sample_size) Devuelve una
muestra de números enteros que son mayores o iguales que
’low’ y menores que ’high’.
10 23
Remodelar arreglos
Tomar un arreglo con ciertas dimensiones y transformar ese
arreglo en una forma diferente.
El arreglo original debe tener la misma cantidad de
elementos que el arreglo en el que estás tratando de
remodelarlo.
Se puede determinar la forma actual de un arreglo
utilizando el atributo shape.
arr = [Link]([0,1,2,3,4,5])
[Link](2,3)
#Salida
array([[0, 1, 2],
[3, 4, 5]])
11 23
Remodelar arreglos
arr = [Link]([0,1,2,3,4,5])
[Link]
#Devuelve (6,), es un arreglo unidimensional
arr = [Link](2,3)
[Link]
#Devuelve (2,3)
12 23
Máximos y mínimos
El método max se usa para encontrar el máximo valor de un
arreglo.
El método argmax se usa para encontrar el índice del
máximo valor dentro de un arreglo.
Los métodos min y argmin para encontrar el valor e índice
del mínimo valor dentro de un arreglo.
simple_array = [1, 2, 3, 4]
simple_array.max()
#Devuelve 4
simple_array.argmax()
#Devuelve 3
simple_array.min()
#Devuelve 1
simple_array.argmin()
#Devuelve 0
13 23
Operaciones aritméticas
arr = [Link](4) # 0,1,2,3
2 + arr
#Devuelve array([2, 3, 4, 5])
arr + arr
#Devuelve array([0, 2, 4, 6])
arr - 10
#Devuelve array([-10, -9, -8, -7])
arr - arr
#Devuelve array([0, 0, 0, 0])
6 * arr
#Devuelve array([ 0, 6, 12, 18])
arr * arr
#Devuelve array([0, 1, 4, 9])
arr / 2
#Devuelve array([0. , 0.5, 1. , 1.5])
arr / arr
#Devuelve array([nan, 1., 1., 1.])
14 23
Operaciones especiales
[Link](arr) # Raíz cuadrada.
#Devuelve array([0., 1., 1.41421356, 1.73205081])
[Link](arr)
#Devuelve e ^ elemento para cada elemento del arreglo
[Link](arr)
#Calcula el seno trigonométrico de cada valor en el arreglo
[Link](arr)
#Calcula el coseno trigonométrico de cada valor en el arreglo
[Link](arr)
#Calcula el logaritmo en base diez de cada valor en el arreglo
[Link](arr, n)
#Redondea a n cifras decimales cada elemento del arreglo
15 23
Indexación
arr = [Link](5)
# Consideremos esta salida: array([0.69292946, 0.9365295 , 0.656
arr = [Link](arr, 2)
# Devuelve array([0.69, 0.94, 0.66, 0.73, 0.83])
arr[0]
#Devuelve 0.69
arr[:]
#Retorna el arreglo completo: array([0.69, 0.94, 0.66, 0.73, 0.8
arr[1:]
#Devuelve array([0.94, 0.66, 0.73, 0.83])
arr[1:4]
#Devuelve array([0.94, 0.66, 0.73])
16 23
Asignación
array([0.12, 0.94, 0.66, 0.73, 0.83])
#Devuelve array([0.12, 0.94, 0.66, 0.73, 0.83])
arr[:] = 0
#Devuelve array([0., 0., 0., 0., 0.])
arr[2:5] = 0.5
#Devuelve array([0. , 0. , 0.5, 0.5, 0.5])
17 23
Referenciación
NumPy no crea un arreglo adicional cuando hace referencia
a una parte del arreglo original usando el operador de
asignación =.
Simplemente apunta la nueva variable a la anterior, lo que
permite que la segunda variable realice modificaciones en la
variable original.
El propósito de la referencia de arreglos es conservar poder
computacional. Al trabajar con grandes conjuntos de datos,
rápidamente te quedarías sin memoria si crearas un nuevo
arreglo cada vez que quisieras trabajar con una porción de
él.
Si se requieren hacar copias explícitas de un arreglo se usa
el método copy.
Mostremos esto con ejemplos.
18 23
Ejemplo de referenciación
new_array = [Link]([6, 7, 8, 9])
second_new_array = new_array[0:2]
#Devuelve array([6, 7])
second_new_array[1] = 4
#Devuelve array([6, 4]), como se esperaba
new_array
#Devuelve array([6, 4, 8, 9])
#que es DIFERENTE de su valor original de array([6, 7, 8, 9])
#¿Que ha pasado?
19 23
Ejemplo de copia
array_to_copy = [Link]([1, 2, 3])
copied_array = array_to_copy.copy()
#Devuelve array([1, 2, 3])
copied_array[0] = 9
#Devuelve array([9, 2, 3])
array_to_copy
#Devuelve array([1, 2, 3])
20 23
Indexación de arreglos de dos dimesiones
Hay dos formas de indexar un arreglo NumPy de dos
dimensiones:
I nombre_arreglo[fila, columna]
I nombre_arreglo[fila][colulma]
mat = [Link]([[5, 10, 15],[20, 25, 30],[35, 40, 45]
"""
Devuelve:
array([[ 5, 10, 15],
[20, 25, 30],
[35, 40, 45]])
"""
21 23
Ejemplo indexación de dos dimensiones
#Primero, vamos a conseguir la primera fila:
mat[0]
# Devuelve array([ 5, 10, 15])
#Luego, obtengamos el último elemento de la primera fila:
mat[0][-1]
# Devuelve 15.
mat[1:][:]
"""
Devuelve:
array([[20, 25, 30],
[35, 40, 45]])
"""
mat[1:, :2]
"""
Devuelve:
array([[20, 25],
[35, 40]])
"""
22 23
Selección condicional
arr = [Link]([0.69, 0.94, 0.66, 0.73, 0.83])
arr > 0.7
#Devuelve array([False, True, False, True, True])
arr[arr > 0.7]
#Devuelve array([0.94, 0.73, 0.83])
23 / 23
¡Gracias! ¿Preguntas?