Num Py

Librerı́a NumPy
Big Data I: Programación y arquitectura de bases de datos

Master Propio en Big Data
25 de noviembre de 2020
(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 1 / 122

Índice
1 Introducción
2 Arrays
3 Índices
4 Funciones
5 Broadcasting
6 Más funciones... y SciPy
7 RETOS

Índice
1 Introducción
2 Arrays
3 Índices
4 Funciones
5 Broadcasting
7 RETOS

Introducción
NumPy es un acrónimo de ”Numerical Python”.
Es un módulo de extensión open source, el cuál provee de

funciones precompiladas rápidas para rutinas matemáticas.
Más allá, NumPy enriquece el lenguaje de programación Python

con poderosas estructuras de datos para computación eficiente
de arrays multidimensionales y matrices.

Introducción
La implementación es ideal para enormes matrices y arrays.
Además incluye una gran cantidad de funciones para operar con

funciones matemáticas.

Introducción
SciPy (Scientific Python) es nombrado, a veces, junto con NumPy.
SciPy extiende las capacidades de NumPy con funciones útiles

para minimización, regresión, transformadas de Fourier y muchas
otras cosas.

Instalación
NumPy y SciPy no suelen venir instaladas por defecto.
NumPy se tiene que instalar antes de SciPy.

Instalación
Desde pip
sudo pip install numpy

sudo pip install scipy

Comparación con MatLab
Python puede usarse como alternativa a Matlab, en combinación

con ‘NumPy‘, ‘SciPy‘ y ‘MatPlotlib‘
• Alternativa libre
• A pesar de que MATLAB tiene un gran número de cajas de

herramientas adicionales disponibles,
• NumPy tiene la ventaja de que Python tiene una comunidad

inmensa de usuarios que, al ser de código abierto, están
constantemente generando y actualizando librerı́as.

Comparación con MatLab
SciPy agrega aún más funcionalidades (tipo MATLAB) a Python.
Python se completa con el módulo de matplotlib, que proporciona

funcionalidad similar al trazado de gráficos de MatLab.
[https://docs.scipy.org/doc/numpy-dev/user/numpy-for-matlab-users.html]

Un ejemplo simple
Antes de poder utilizar NumPy tendremos que importarlo.

Tiene que ser importados como cualquier otro módulo:
1 import numpy
Pero casi nunca ver esto. Numpy generalmente se cambió el

nombre a np:
1 import numpy as np

Un ejemplo simple
Tenemos una lista con valores, por ejemplo, de temperaturas en

grados Celsius:
1 cvalues = [ 2 5 . 3 , 24.8 , 26.9 , 23.9]
Vamos a convertir esto en una matriz unidimensional numpy:

1 C = np . a r r a y ( c v a l u e s )
2 p r i n t (C)
El código anterior devolverá el siguiente resultado:

[25.3 24.8 26.9 23.9]

Un ejemplo simple
Vamos a suponer, queremos convertir los valores en grados

Fahrenheit.
En Python ”normal”:
1 X= [ ]
2 f o r cc i n c v a l u e s :
3 X . append ( cc * 9 / 5 + 32)
4 print (X)
o tambien...
1 X = [ cc * 9 / 5 + 32 f o r cc i n c v a l u e s ]
2 print (X)

Un ejemplo simple
Esto es muy fácil de lograr con una matriz NumPy.
La solución a nuestro problema se puede conseguir por simple

multiplicación escalar:
1 p r i n t (C * 9 / 5 + 32)
El código anterior devolverá el siguiente resultado:

[77.54, 76.64, 80.42, 75.02]

Ventajas
Una de las principales ventajas de NumPy es su ventaja en el

tiempo de ejecución.
1 def puro ( ) :
2 t1 = time . time ( )
3 X = range ( s i z e o f v e c )
4 Y = range ( s i z e o f v e c )
5 Z = []
6 f o r i i n range ( len (X ) ) :
7 Z . append (X [ i ] + Y [ i ] )
8 return time . time ( ) − t1
1 def l i b r e r i a ( ) :
2 t1 = time . time ( )
3 X = np . arange ( s i z e o f v e c )
4 Y = np . arange ( s i z e o f v e c )
5 Z = X + Y
6 return time . time ( ) − t1

Ventajas
Vamos ahora a ejecutarlas y ver el resultado:

1 t 1 = puro ( )
2 t2 = l i b r e r i a ( )
3 p r i n t ( t1 , t 2 )
4 p r i n t ( "Numpy en este ejemplo es " + s t r ( t 1 / t 2 ) + " más rápido!" )
0.1024632453918457 0.0010013580322265625
Numpy en este ejemplo es 102.32428571428571 más rápido!

Índice
1 Introducción
2 Arrays
3 Índices
4 Funciones
5 Broadcasting
7 RETOS

Arrays
En NumPy TODO son matrices(arrays).
Los escalares son arrays de dimensión cero.
Es posible crear arrays multidimensionales.

Arrays
En el siguiente ejemplo, vamos a crear el escalar 42.

1 x = np . a r r a y ( 4 2 )
El método ndim nos da la dimensión de la matriz.

1 p r i n t ( np . ndim ( x ) )
También podemos ver de qué tipo es:

1 p r i n t ( type ( x ) )
<class ’numpy.ndarray’>

Vectores: Arrays Uni-dimensionales
Tenemos arrays unidimensionales en nuestro ejemplo: Vectores.
En NumPy se asume que todos los elementos de arrays son del

mismo tipo.
El tipo homogéneo de un array se puede preguntar con dtype.

Vectores: Arrays Uni-dimensionales
Podemos ver este ejemplo:

1 F = np . a r r a y ( [ 1 , 1 , 2 , 3 , 5 , 8 , 13 , 2 1 ] )
2 V = np . a r r a y ( [ 3 . 4 , 6 . 9 , 9 9 . 8 , 1 2 . 8 ] )
3 p r i n t ( F . dtype )
4 p r i n t ( V . dtype )
5 p r i n t ( np . ndim ( F ) )
6 p r i n t ( np . ndim ( V ) )
Ejecutando:
int32
float64
1
1

Arrays Multidimensionales
Las matrices en NumPy pueden ser de cualquier dimesión
Las creamos pasándoles listas o tuplas anidadas al método array

1 A = np . a r r a y ( [ [ 3 . 4 , 8 . 7 , 9 . 9 ] ,
2 [ 1 . 1 , −7.8 , − 0 . 7 ] ,
3 [ 4 . 1 , 12.3 , 4 . 8 ] ] )
4 print (A)
5 p r i n t ( A . ndim )
[[ 3.4 8.7 9.9]

[ 1.1 -7.8 -0.7]
[ 4.1 12.3 4.8]]
2
*¿2?*

Otro ejemplo
1 B = np . a r r a y ( [ [ [ 1 1 1 , 1 1 2 ] , [ 1 2 1 , 1 2 2 ] ] ,
2 [[211 , 212] , [221 , 222]] ,
3 [[311 , 312] , [321 , 322]] ] )
4 print (B)
5 p r i n t ( B . ndim )
[[[111 112]
[121 122]]
[[211 212]
[221 222]]
[[311 312]
[321 322]]]
3
¿Qué pasa?

Shape
La función shape devuelve la ”forma”del array.
La forma es una tupla de números enteros.
Estos números son las longitudes de las dimensiones del array.

Shape
En nuestro ejemplo, la forma es (6,3), es decir, 6 lı́neas y 3 columnas.

1 x = np . a r r a y ( [ [ 6 7 , 63 , 87] ,
2 [77 , 69 , 59] ,
3 [85 , 87 , 99] ,
4 [79 , 72 , 71] ,
5 [63 , 89 , 93] ,
6 [68 , 92 , 78]])
7 p r i n t ( np . shape ( x ) )
(6, 3)

Propiedad SHAPE
shape también se puede usar como propiedad, no sólo como

método.
1 p r i n t ( x . shape )
(6, 3)

Propiedad SHAPE
shape se puede usar también para cambiar la forma del array. x

1 x . shape = ( 3 , 6 )
2 print ( x )
[[67 63 87 77 69 59]
[85 87 99 79 72 71]
[63 89 93 68 92 78]]

Propiedad SHAPE
Cambiamos ahora de otra forma:

1 x . shape = ( 2 , 9 )
2 print ( x )
[[67 63 87 77 69 59 85 87 99]
[79 72 71 63 89 93 68 92 78]]
La dimension de un array nos indica cómo van a ser procesados

los ı́ndices:
• las filas primero, luego las columnas y luego el resto de

dimensiones.

Propiedad SHAPE
Para cambiar a un array de forma, origen y destino tienen que

tener el mismo número de elementos
En caso contrario, se lanza una excepción:

1 x . shape = ( 4 , 4 )
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-22-ce5e4e78d80b> in <module>
----> 1 x.shape = (4, 4)
ValueError: cannot reshape array of size 18 into shape (4,4)

Propiedad SHAPE
Más ejemplos:
El shape de un escalar es una tupla vacı́a:

1 x1 = np . a r r a y ( 1 1 )
2 p r i n t ( np . shape ( x1 ) )
()
En una multidimensional
1 B = np . a r r a y ( [ [ [ 1 1 1 , 1 1 2 ] , [ 1 2 1 , 1 2 2 ] ] ,
2 [[211 , 212] , [221 , 222]] ,
3 [[311 , 312] , [321 , 322]] ] )
4 p r i n t ( B . shape )
(3, 2, 2)

Re-Shape
Si utilizamos la función reshape con el valor -1, la dimensión de

este parámetro se ajusta automáticamente como necesite.
1 x . reshape ( 3 , − 1 )
array([[67, 63, 87, 77, 69, 59],

[85, 87, 99, 79, 72, 71],
[63, 89, 93, 68, 92, 78]])

CREACION DE ARRAYS
Hay otras funciones que nos sirven para crear arrays éspeciales’.
Son bastente útiles para evitar cálculos tediosos.

UNOS y CEROS
Hay dos formas de inicializar arrays con Ceros y Unos.
El método *ones(t)* recibe una tupla con la forma del array y lo

rellena de unos.
1 E = np . ones ( ( 2 , 3 ) )
2 print (E)
[[1. 1. 1.]
[1. 1. 1.]]

UNOS y CEROS
Por defecto, se rellenan los arrays con números de tipo float
Si quieres rellenarlos con números enteros, usamos el parámetro

opcional dtype
1 F = np . ones ( ( 3 , 4 ) , dtype= i n t )
2 print (F)
[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]

UNOS y CEROS
Todo lo que hemos dicho sobre el metodo *ones()* es válido para

el método zeros():
1 Z = np . zeros ( ( 2 , 4 ) )
2 print (Z)
[[0. 0. 0. 0.]
[0. 0. 0. 0.]]

UNOS y CEROS
Hay otra forma interesante de crear un array con unos o ceros,

con la misma forma de otro array:
tenemos los métodos np.ones like(x) y np.zeros like(x)

1 x2 = np . a r r a y ( [ 2 , 5 , 1 8 , 1 4 , 4 ] )
2 E = np . o n e s l i k e ( x2 )
3 print (E)
[1 1 1 1 1]
1 Z = np . z e r o s l i k e ( x )
2 print (Z)
[[0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0]]

EMPTY
La función empty crea una array cuyo contenido inicial es

aleatorio
El tipo por defecto es *float64*

1 np . empty ( ( 2 , 3 ) )
array([[1., 1., 1.],

[1., 1., 1.]])

Matriz Identidad
Una matriz identidad es una matriz cuadrada con únosén su

diagonal principal.
Hay dos formas de crear esa matriz:
• np.identity
• np.eye

Matriz Identidad
Podemos crear la matriz identidad con la función identity:

1 np . i d e n t i t y ( n , dtype=None )
Parámetros:
• n: Número de filas y columnas de la matriz
• dtype: Opcional. Tipo de dato de la matriz. Defecto: float

Matriz Identidad
Ejemplo de la Matriz:
1 np . i d e n t i t y ( 4 )
array([[1., 0., 0., 0.],

[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])
1 # e q u i v a l e n t e a np . i d e n t i t y ( 4 , i n t )
2 np . i d e n t i t y ( 4 , dtype= i n t )
array([[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])

La función EYE
Otra forma de crear una matriz ı́dentidadés con la función eye().
Devuelve una matriz 2D con unos en la diagonal y ceros en el

resto.

La función EYE
1 eye (N, M=None , k =0 , dtype = f l o a t )
N: Número de filas de la salida
M: Número de columnas de la salida. Opcional. Por defecto es

igual a *N*
k: Define el desplazamiento de la diagonal. 0 hace referencia a la

diagonal principal. Por defecto es 0.
dtype: Tipo de dato. Opcional

La función EYE
Ejemplo:
1 np . eye ( 5 , 8 , k =1 , dtype = i n t )
array([[0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0]])

Secuencias de números
Para crear secuencias de números tenemos una función similar

que Python.
Función: arange(inicio, fin, step)

1 np . arange ( 10 , 30 , 5 )
array([10, 15, 20, 25])
it accepts float arguments

1 np . arange ( 0 , 2 , 0 . 3 )
array([0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])

Si queremos generar un cierto número de números dentro de un

intervalo usaremos la función:
• linspace(inicio, final, cantidadelementos)
1 np . l i n s p a c e ( 0 , 2 , 9 )
array([0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ])
1 x = np . l i n s p a c e ( 0 , 2 * np . p i , 100 )
2 f = np . s i n ( x )

Representamos f:
1 import m a t p l o t l i b . p y p l o t as p l t
2 %m a t p l o t l i b i n l i n e
3 plt . plot ( f )
4 p l t . show ( )

Otra forma interesante es generar una matriz “Como” otra.
Es decir, generar una matriz con la misma forma y rellena de

algún número.
• zeros like(array),
• ones like(array),
• empty like(array)
Tienen más parámetros, como dtype, pero funciona como en los

demás casos.

Generación de Aleatorios
Algo bastante necesario en la computación cientı́fica o de datos,

es la generación de números aleatorios.
Hay que importar numpy.random
• random([size]) : Devuelve un array de floats con números

entre [0.0, 1.0) (semiabierto)
• rand(d0, d1, ..., dn): Devuelve un array de floats aleatorios la

forma d0, d1, ..., dn
• randn(d0, d1, ..., dn): Devuelve el array cumpliendo una

distribución ”normal”
• choice(a[, size, replace, p]): Genera un array cogiendo

elementos al azar de un array 1D

Generación de Aleatorios
randint(low[, high, size, dtype]),
random integers(low[, high, size]),
random sample([size]),
ranf([size]),
sample([size]),
bytes(length)

Lectura de ficheros
Por último se pueden crear arrays directamente desde ficheros de

texto o csv.
Usaremos la función numpy.genfromtxt
• numpy.genfromtxt(file[, delimiter, skip header])

Índice
1 Introducción
2 Arrays
3 Índices
4 Funciones
5 Broadcasting
7 RETOS

Índices
Cambiar o Acceder a los elementos de un array es similar a

cualquier otro tipo de datos secuenciales (listas, tuplas, etc...) en
Python
NumPy ofrece algunas opciones que lo hace más potente.

Índices
Como ejemplo inicial:

1 F = np . a r r a y ( [ 1 , 1 , 2 , 3 , 5 , 8 , 13 , 2 1 ] )
Imprimir el primer elemento

1 print (F [ 0 ] )
Imprimir el último elemento

1 print (F[ −1])
21

Índices
Acceder a un elemento concreto
1 B = np . a r r a y ( [ [ [ 1 1 1 , 1 1 2 ] , [ 1 2 1 , 1 2 2 ] ] ,
2 [[211 , 212] , [221 , 222]] ,
3 [[311 , 312] , [321 , 322]] ] )
4 print (B [ 0 ] [ 1 ] [ 0 ] )
121
1 A = np . a r r a y ( [ [ 3 . 4 , 8 . 7 , 9 . 9 ] ,
2 [ 1 . 1 , −7.8 , − 0 . 7 ] ,
3 [ 4 . 1 , 12.3 , 4 . 8 ] ] )
4 print (A [ 1 ] [ 0 ] )
1.1

Índices
Accedemos a los elementos de la misma forma que las listas

anidadas de Python.
Hay otra forma de acceder a los elementos: lista de ı́ndices

separados por coma.
1 print (A[ 1 , 0 ] )
1.1
Esta segunda forma es más eficiente

Slicing
(No sé cuál serı́a el nombre en español más adecuado)
La sintáxis general de ”slicing”para un array unidimensional es de

la forma:
1 A[ s t a r t : stop : step ]
Funciona como en Python (y Matlab)

Slicing
Algunos ejemplos:
1 S = np . a r r a y ( [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] )
2 print (S [ 2 : 5 ] )
3 print (S [ : 4 ] )
4 print (S [ 6 : ] )
5 print (S [ : ] )
[2 3 4]
[0 1 2 3]
[6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]

Slicing
En multidimensional:
1 A = np . a r r a y ( [
2 [11 ,12 ,13 ,14 ,15] ,
3 [21 ,22 ,23 ,24 ,25] ,
4 [31 ,32 ,33 ,34 ,35] ,
5 [41 ,42 ,43 ,44 ,45] ,
6 [51 ,52 ,53 ,54 ,55]])
7
8 print (A [ : 3 , 2 : ] )
[[13 14 15]
[23 24 25]
[33 34 35]]

Slicing
Más:
1 print (A [ 3 : , : ] )
[[41 42 43 44 45]
[51 52 53 54 55]]
1 print (A [ : , 4 : ] )
[[15]
[25]
[35]
[45]
[55]]

Slicing
La función *np.arange* es similar a *range* de Python
La función *np.reshape* construye un array bi-dimensional

1 X = np . arange ( 2 8 ) . reshape ( 4 , 7 )
2 print (X)
[[ 0 1 2 3 4 5 6]
[ 7 8 9 10 11 12 13]
[14 15 16 17 18 19 20]
[21 22 23 24 25 26 27]]
y usando el parámetro step

1 print (X [ : : 2 , ::3])
[[ 0 3 6]
[14 17 20]]

Memoria
Cuando hacemos una operación de “slicing” con listas o tuplas de

Python creamos un objeto nuevo con la selección
Si lo hacemos con arrays de NumPy, creamos una vista
• Por tanto, si modificamos la vista, modificamos el original

Memoria
1 A = np . a r r a y ( [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] )
2 S = A[2:6]
3
4 S [ 0 ] = 22
5 S [ 1 ] = 23
6
7 p r i n t (A )
[ 0 1 22 23 4 5 6 7 8 9]

Memoria
Si hacemos lo mismo con listas puras de Python...

1 l s t = [0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9]
2 lst2 = lst [2:6]
3
4 l s t 2 [ 0 ] = 22
5 l s t 2 [ 1 ] = 23
6
7 print ( l s t )
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Memoria
Para comprobar si dos arrays comparten la misma zona de

memoria (y se pueden modificar la una a la otra)
1 np . may share memory ( A , B)
La función calcula las zonas de memoria que ocupan y devuelve

True si las zonas solapan
1 np . may share memory ( A , S)
True

Memoria
Si partimos de estas variables:

1 A = np . arange ( 1 2 )
2 B = A . reshape ( 3 , 4 )
3 A [ 0 ] = 42
4 print (B)
[[42 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
Sabemos que A y B comparten la zona de memoria

Memoria
Los arrays tienen el atributo data que es la dirección de memoria

del inicio del array.
Si comparamos los data de A y de B obtenemos:

1 p r i n t ( A . data == B . data )
False
Si comparamos los arrays

1 p r i n t ( A == B )
False
**DeprecationWarning**

Memoria
Esto tiene sentido, porque la zona de memoria es la misma, sin

embargo la forma de los arrays son diferentes
1 print (A)
2 print (B)
[42 1 2 3 4 5 6 7 8 9 10 11]
[[42 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]

Índice
1 Introducción
2 Arrays
3 Índices
4 Funciones
5 Broadcasting
7 RETOS

Matemáticas
Vamos a describir funciones matemáticas básicas para operar

con arrays y sus elementos.
La mayorı́a están descritos como funciones y/o operadores

sobrecargados

SUMA
Hay muchas operaciones que se realizan “elemento a elemento”

1 x = np . a r r a y ( [ [ 1 , 2 ] , [ 3 , 4 ] ] , dtype =np . f l o a t 6 4 )
2 y = np . a r r a y ( [ [ 5 , 6 ] , [ 7 , 8 ] ] , dtype =np . f l o a t 6 4 )
3 print ( x + y )
[[ 6. 8.]
[10. 12.]]
1 p r i n t ( np . add ( x , y ) )
[[ 6. 8.]
[ 10. 12.]]

RESTA
1 print ( x − y )
2 p r i n t ( np . s u b t r a c t ( x , y ) )
[[-4. -4.]
[-4. -4.]]
[[-4. -4.]
[-4. -4.]]

MULTIPLICACION
A diferencia de MATLAB, ’*és una multiplicación “elemento a

elemento” y no multiplicación de matrices
1 print ( x * y )
2 p r i n t ( np . m u l t i p l y ( x , y ) )
[[ 5. 12.]
[ 21. 32.]]
[[ 5. 12.]
[ 21. 32.]]

MULTIPLICACIÓN
NumPy usa la función dot para calcular el producto interior de

vectores, un vector por una matriz y multiplicación de matrices.
dot está disponible como función y como método de array

MULTIPLICACIÓN
Partiendo de estos arrays:

1 v = np . a r r a y ( [ 9 , 1 0 ] )
2 w = np . a r r a y ( [ 1 1 , 1 2 ] )
Producto interno (o escalar)

1 p r i n t ( v . d o t (w ) )
2 p r i n t ( np . d o t ( v , w ) )
219
219

MULTIPLICACIÓN
Matriz x vector
1 print ( x . dot ( v ) )
[29. 67.]
1 print ( x . dot ( y ) )
[[19. 22.]
[43. 50.]]

Más...
1 print ( x / y )
2 p r i n t ( np . d i v i d e ( x , y ) )
[[0.2 0.33333333]
[0.42857143 0.5 ]]
[[0.2 0.33333333]
[0.42857143 0.5 ]]
1 p r i n t ( np . s q r t ( x ) )
[[1. 1.41421356]
[1.73205081 2. ]]

Más...
Funciones de manipulación de arrays:
Traspuesta: Simplemente se usa el atributo T del array

1 x3 = np . a r r a y ( [ [ 1 , 2 ] , [ 3 , 4 ] ] )
2 p r i n t ( x3 )
3 p r i n t ( x3 . T )
[[1 2]
[3 4]]
[[1 3]
[2 4]]
La traspuesta de un vector no tiene efecto

1 v = np . a r r a y ( [ 1 , 2 , 3 ] )
2 print ( v .T)
[1 2 3]

Más...
Otra función útil es sum

1 x4 = np . a r r a y ( [ [ 1 , 2 ] ,
2 [3 ,4]])
3 p r i n t ( np .sum( x4 ) )
10
1 p r i n t ( np .sum( x4 , a x i s = 0 ) ) # En v e r t i c a l
[4 6]
1 p r i n t ( np .sum( x4 , a x i s = 1 ) ) # En h o r i z o n t a l
[3 7]

Histogramas
NumPy tiene una función para la creación de histogramas.
Aplicados a arrays, devuelve un par de vectores:
• El histograma del array, y
• El vector de las divisiones.

Histogramas
Por ejemplo: Construimos un vector v de 10000 elementos aleatorios

de distribucion normal:
1 mu, sigma = 2 , 0 . 5
2 v = np . random . normal (mu, sigma ,100000)
Calculamos su histograma
1 ( n , b i n s ) = np . h i s t o g r a m ( v , b i n s =50)

Histogramas
Ahora a pintarlo
1 p l t . p l o t ( . 5 * ( bins [ 1 : ] + bins [ : − 1 ] ) , n )
2 p l t . show ( )

Mas...
Se puede encontrar una lista completa de funciones en la

documentación de NumPy
[https://docs.scipy.org/doc/]

Índice
1 Introducción
2 Arrays
3 Índices
4 Funciones
5 Broadcasting
7 RETOS

Broadcasting
El término broadcasting describe cómo Numpy trata las

operaciones de arrays con diferentes dimensiones.
Generalmente, y *teniendo en cuenta algunas restricciones*, el

array más pequeño es ”broadcasted”(agrandado) hasta hacerlo
*compatible* con el tamaño del mayor.
Esto permite vectorizar muchas operaciones en lugar de hacer

bucles que serı́an más costosos computacionalmente.
Además se realiza sin tener que hacer copias innecesarias de

datos.

Broadcasting
También hay casos en los que el broadcasting es mala idea

porque puede ser más ineficiente que la versión *manual*
Vamos a ver cómo usarlo y como evitar hacer uso de él cuando
no conviene

Broadcasting
Como hemos visto, generalmente, las operaciones aritméticas en

Numpy se realizan elemento a elemento
Esto requiere que los dos arrays tengan el mismo tamaño (forma)
1 a = np . a r r a y ( [ 1 . 0 , 2 . 0 , 3 . 0 ] )
2 b = np . a r r a y ( [ 2 . 0 , 2 . 0 , 2 . 0 ] )
3 a * b
array([2., 4., 6.])

Broadcasting
El broadcasting relaja esa restricción bajo algunas condiciones.
La versión más simple es cuando combinamos un array con un

escalar
El ejemplo anterior, gracias al broadcasting, se podrı́a hacer:

1 a = np . a r r a y ( [ 1 . 0 , 2 . 0 , 3 . 0 ] )
2 b = 2.0 # tambi én podr ı́ a s e r : np . a r r a y ( 2 . 0 )
3 a * b
array([2., 4., 6.])

Broadcasting
Podemos pensar que el escalar (0d array) se puede agrandar

hasta tener la misma forma de a para realizar la operación.
Se agranda simplemente copiando el valor existente en las

copias nuevas.

Broadcasting
En realidad, el *agrandado* es solamente conceptual.
Numpy optimiza el uso sin tener que ocupar más memoria

Reglas
La regla del broadcasting consiste en:
• El tamaño de cada uno de los ı́ndices de ambos arrays

deben de ser del mismo tamaño o uno de ellos debe ser
uno.
• Cada eje/dimensión se valora por separado
• El tamaño del resultado es el máximo de cada eje de los dos

arrays.
• La regla no dice nada sobre que los arrays necesitan tener el

mismo número de dimensiones.

Reglas
Tenemos una imagen RGB en una matriz de 256x256x3. Es decir,

tamaño 256x256 con los 3 canales RGB
Queremos multiplicar cada uno de los canales por un número

distinto. Nos hace falta un vector de longitud 3
De acuerdo a las leyes obtendremos
Image (3d array): 256 x 256 x 3

Scale (1d array): 3
Result (3d array): 256 x 256 x 3

Reglas
En un ejemplo algo más complejo estudiamos el resultado: En el

ejemplo, A y B tienen ejes con dimensión 1, que son expandidos al
A (4d array): 8 x 1 x 6 x 1
tamaño mayor B (3d array): 7x1x5
Result (4d array): 8x7x6x5

Reglas
Ejemplo de suma de arrays

1 a = np . a r r a y ( [ [ 0 . 0 , 0 . 0 , 0 . 0 ] ,
2 [10.0 ,10.0 ,10.0] ,
3 [20.0 ,20.0 ,20.0] ,
4 [30.0 ,30.0 ,30.0]])
5 b = np . a r r a y ( [ 1 . 0 , 2 . 0 , 3 . 0 ] )
6 a + b
array([[ 1., 2., 3.],

[11., 12., 13.],
[21., 22., 23.],
[31., 32., 33.]])

Reglas
La operación se explica según la siguiente figura.

Índice
1 Introducción
2 Arrays
3 Índices
4 Funciones
5 Broadcasting
7 RETOS

Operaciones Básicas
Las operaciones de arrays se realizan elemento a elemento y

por tanto...
Estos ejemplos:
1 a = np . a r r a y ( [ 2 0 , 3 0 , 4 0 , 5 0 ] )
2 10 * np . s i n ( a )
array([ 9.12945251, -9.88031624, 7.4511316 , -2.62374854])
1 a<35
array([ True, True, False, False])

Operaciones Básicas
Operador “+=” y “*=” funcionan sin necesidad de crear arrays

nuevos.
1 a = np . ones ( ( 2 , 3 ) , dtype= i n t )
2 b = np . random . random ( ( 2 , 3 ) )
3 a *= 3
4 a
array([[3, 3, 3],
[3, 3, 3]])

Más...
1 b += a
2 b
array([[3.45601371, 3.20746186, 3.57922178],

[3.74299607, 3.3790752 , 3.66107905]])
1 # a += b
2 a = a + b
3 a
array([[6.29996994, 6.18522668, 6.5689844 ],

[6.55445221, 6.26076093, 6.39457967]])

Más...
Suma de elementos, Mı́nimo y máximo de una matriz
1 p r i n t ( a .sum ( ) )
2 p r i n t ( a . min ( ) )
3 p r i n t ( a . max ( ) )
38.263973832073674
6.185226677768423
6.568984400231365

Más
También se puede aplicar POR EJES
1 b = np . arange ( 1 2 ) . reshape ( 3 , 4 )
2 b
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
1 b .sum( a x i s =0) # suma v e r t i c a l
array([12, 15, 18, 21])
1 b . min ( a x i s =1) # mı́ nimo h o r i z o n t a l
array([0, 4, 8])
1 b . cumsum ( a x i s =1 # suma acumulada h o r i z o n t a l
array([[ 0, 1, 3, 6],
[ 4, 9, 15, 22],
[ 8, 17, 27, 38]], dtype=int32)

Más Forma...
Más formas de cambiar la forma de un array..
Aplanar un array
1 a . ravel ()
array([9.45601371, 9.20746186, 9.57922178, 9.74299607, 9.3790752 ,

9.66107905])
Traspuesta
1 a . t r a n s p o se ( )
array([[9.45601371, 9.74299607],
[9.20746186, 9.3790752 ],
[9.57922178, 9.66107905]])
1 >>> a . T
array([[ 7., 9., 7., 7., 6., 3.],

[ 5., 3., 2., 8., 8., 2.]])

Más preguntas...
all: Chequea si todos los elementos del array son *True*
any: Chequea si algún elemento del array es *True*
nonzero: devuelve los ı́ndices de los elementos que son distintos

de cero.
Es una tupla con dos arrays, el primero son las valores de fila y el
segundo de columnas.

Más orden...
sort: Ordena el array
argsort: Devuelve la lista de ı́ndices de forma que el array estarı́a

ordenado
argmax, argmin: Índices del elemento Mı́nimo y Máximo.
ptp: Rango de valores (max-min) a lo largo de los ejes

Más estadı́stica
Algunas funciones de estadı́stica básica, que no hace falta explicar:

cov, mean, std, var

Álgebra Lineal
Se tiene que importar el subpaquete numpy.linalg
Incluye más funciones algebraicas
Documentación completa en:

[https://docs.scipy.org/doc/numpy/reference/routines.linalg.html]

Álgebra Lineal
cross: Producto vectorial
dot y vdot: Producto de vectores y matrices
inv: Inversa de una matriz
trace: Traza de una matriz

Sistemas de ecuaciones
Podemos resolver sistemas de ecuaciones lineales con una

simple instrucción:
3x+y=9
x+2y=8
1 mat = np . a r r a y ( [ [ 3 , 1 ] , [ 1 , 2 ] ] )
2 vec = np . a r r a y ( [ 9 , 8 ] )
3 p r i n t ( np . l i n a l g . s o l v e ( mat , vec ) )
[2. 3.]

Autovalores y Autovectores
Devuelve una tupla con todos los autovalores y los autovectores

1 j = np . random . random ( ( 3 , 3 ) )
2 np . l i n a l g . e i g ( j )
(array([ 1.43764188+0.j , -0.21289639+0.32920799j,

-0.21289639-0.32920799j]),
array([[ 0.70561273+0.j , 0.30966883+0.28685089j,
0.30966883-0.28685089j],
[ 0.42208324+0.j , -0.72868369+0.j ,
-0.72868369-0.j ],
[ 0.56917169+0.j , 0.15808354-0.51560786j,
0.15808354+0.51560786j]]))

La clase MATRIX
Hay una clase especial para tratamiento de matrices: La clase

Matrix
Es clase de NumPy
1 A = np . m a t r i x ( ’1.0 2.0; 3.0 4.0’ )

2 A
matrix([[1., 2.],
[3., 4.]])
1 type ( A )
numpy.matrix

Operaciones de Matrix
Transpuesta
1 A.T
matrix([[1., 3.],
[2., 4.]])
Multiplicación de matrices
1 A * A.T
matrix([[ 5., 11.],

[11., 25.]])
Inversa
1 A. I
matrix([[-2. , 1. ],
[ 1.5, -0.5]])
1 p r i n t ( np . l i n a l g . s o l v e ( mat , vec ) )
[2. 3.]
Scipy
SciPy está dirigido a tareas numéricas de más alto nivel. Por ejemplo:
Integrales numéricas
Ecuaciones diferenciales,
Optimización
y Matrices en general

Una sesión inicial
Vamos a pintar el máximo de una función de Bessel.

1 from s c i p y import s p e c i a l , o p t i m i z e
2
3 f = lambda x : − s p e c i a l . j v ( 3 , x )
4 s o l = o p t i m i z e . minimize ( f , 1 . 0 )
5 x = np . l i n s p a c e ( 0 , 10 , 5000)
6 print ( x )
7
8 p l t . p l o t ( x , s p e c i a l . j v ( 3 , x ) , ’-’ , s o l . x , − s o l . fun , ’o’ )
9 p l t . show ( )
[0.00000000e+00 2.00040008e-03 4.00080016e-03 ... 9.99599920e+00

9.99799960e+00 1.00000000e+01]

Una sesión inicial

Polinomios
Existe la clase poly1d para representar polinomios.
Acepta los coeficientes del polinomio o sus raı́ces.
• poly1d(c or r, r=0, variable=None)
El polinomio puede ser manipulado algebraicamente, integrado,

derivado, etc...

Polinomios
Creación e Impresión
1 p = np . poly1d ( [ 3 , 4 , 5 ] )
2 print (p)
2
3 x + 4 x + 5
Evaluación
1 print (p ( 4 ) )
2 print (p ([4 , 5 ] ) )
69
[ 69 100]

Polinomios
Integración
1 print ( p . integ ( k =6))
3 2
1 x + 2 x + 5 x + 6
Derivación
1 print (p . deriv ( ) )
6 x + 4

Integración y EDO’s
Tenemos el subpaquete scipy.integrate que nos da técnicas de

integración, incluyendo ecuaciones diferenciales ordinarias
Para ver más sobre este módulo:

1 >>> help ( s c i p y . i n t e g r a t e )

Optimización
Un paquete bastante completo es el de Optimización:

scipy.optimize
La explicación de la optimización queda fuera de nuestro ámbito
La información detallada está en:

[http://docs.scipy.org/doc/scipy/reference/tutorial/optimize.html]

Miscelánea
Hay también un paquete de cosas varias: scipy.misc.
Aquı́ hay funciones para computar el factorial, combinatorias,

aritmética entera, procesamiento de imágenes, etc...

Índice
1 Introducción
2 Arrays
3 Índices
4 Funciones
5 Broadcasting
7 RETOS

Reto 1
Las derivadas se pueden calcular numéricamente mediante el método

de diferencias finitas:
Construir un array 1D que contenga los valores de xi en el

intervalo [0,π/2] con un espaciado ∆x=0.1.
Evalúa numéricamente la derivada del seno en este intervalo

(salvo los extremos) usando la fórmula anterior.Evitar usar
bucles
Comparar los resultados con la función coseno en el mismo

intervalo.

Reto 2
Una forma simple de evaluar integrales numéricas mediante la suma

media de Riemann:
donde x’i = (xi + xi-1)/2.
Para la función coseno, usar el intervalo [0,π/2] e investiga cuanto

difiere la suma media de Riemann del valor de la integral.Evitar
bucles
Cómo se calcula la suma de Riemann y multiplicar el valor por 4.

¿Cuánto se diferencia de pi?
Investigar cómo varı́an los resultados cambiando ∆x.

Num Py

Cargado por

Copyright:

Formatos disponibles

Num Py

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Num Py

Cargado por

Copyright:

Formatos disponibles

Librerı́a NumPy

Big Data I: Programación y arquitectura de bases de datos

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 1 / 122

6 Más funciones... y SciPy

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 2 / 122

6 Más funciones... y SciPy

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 3 / 122

NumPy es un acrónimo de ”Numerical Python”.

Es un módulo de extensión open source, el cuál provee de

Más allá, NumPy enriquece el lenguaje de programación Python

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 4 / 122

La implementación es ideal para enormes matrices y arrays.

Además incluye una gran cantidad de funciones para operar con

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 5 / 122

SciPy (Scientific Python) es nombrado, a veces, junto con NumPy.

SciPy extiende las capacidades de NumPy con funciones útiles

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 6 / 122

NumPy y SciPy no suelen venir instaladas por defecto.

NumPy se tiene que instalar antes de SciPy.

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 7 / 122

sudo pip install numpy

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 8 / 122

Python puede usarse como alternativa a Matlab, en combinación

• A pesar de que MATLAB tiene un gran número de cajas de

• NumPy tiene la ventaja de que Python tiene una comunidad

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 9 / 122

SciPy agrega aún más funcionalidades (tipo MATLAB) a Python.

Python se completa con el módulo de matplotlib, que proporciona

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 10 / 122

Antes de poder utilizar NumPy tendremos que importarlo.

Pero casi nunca ver esto. Numpy generalmente se cambió el

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 11 / 122

Tenemos una lista con valores, por ejemplo, de temperaturas en

Vamos a convertir esto en una matriz unidimensional numpy:

El código anterior devolverá el siguiente resultado:

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 12 / 122

Vamos a suponer, queremos convertir los valores en grados

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 13 / 122

Esto es muy fácil de lograr con una matriz NumPy.

La solución a nuestro problema se puede conseguir por simple

El código anterior devolverá el siguiente resultado:

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 14 / 122

Una de las principales ventajas de NumPy es su ventaja en el

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 15 / 122

Vamos ahora a ejecutarlas y ver el resultado:

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 16 / 122

6 Más funciones... y SciPy

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 17 / 122

En NumPy TODO son matrices(arrays).

Los escalares son arrays de dimensión cero.

Es posible crear arrays multidimensionales.

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 18 / 122

En el siguiente ejemplo, vamos a crear el escalar 42.

El método ndim nos da la dimensión de la matriz.

También podemos ver de qué tipo es:

(Universidad Internacional de Andalucı́a) Big Data I 25 de noviembre de 2020 19 / 122

Tenemos arrays unidimensionales en nuestro ejemplo: Vectores.

En NumPy se asume que todos los elementos de arrays son del

El tipo homogéneo de un array se puede preguntar con dtype.

El método ones(t) recibe una tupla con la forma del array y lo

Todo lo que hemos dicho sobre el metodo ones() es válido para

El tipo por defecto es float64