CPG1001

Fundamentos de Programación
Unidad 5 – Arreglos N-Dimensioanles (NUMPY)
Agenda
5.1 Propiedades
5.2 Indexación básica.
5.3 Indexación con arreglos.
5.4 Indexación boleana.
5.5 Slicing
5.6 Operaciones aritméticas, estadísticas y de ordenamiento.
5.7 Broadcasting (no entra dentro del primer parcial)
Objetivos
• Identificar las propiedades de los arreglos Ndimensionales como
herramienta de agrupación de datos.
• Aplicar técnicas de indexación y slicing para la manipulación de datos
representados como arreglos Ndimensionales.
• Utilizar las operaciones aritméticas, estadísticas y la técnica de
broadcasting para la resolución de problemas.
Numpy
Numpy
• Numpy es una librería de Python que contiene objetos y funciones
especializadas para computación científica.

• Provee al lenguaje con herramientas como arreglos n-

dimensionales, matrices, funciones de álgebra lineal, transformadas
de Fourier, números aleatorios y más.
Instalar Numpy

• Numpy no es es parte de las librerías estándares de python por lo que

primero hay que instalar.

• Revisar video de instalación de numpy.

• https://www.youtube.com/watch?v=-I_EutcMH18, a partir de segundo 41 se
indica como instalar numpy desde pycharm.
Importar Numpy
• Dado que numpy es una librería externa, es necesario importarla
antes de poder usar los objetos y funciones que posee.

• Para importar la librería usar la siguiente sentencia.

Alias de la librería
Arreglos
Arreglos Numpy
• En Numpy un arreglo es:
• Una colección de elementos que son todos del mismo tipo,
• Que tienen una o más dimensiones
• Que son indexados por una tupla de enteros no negativos.
Creación Arreglos
• Una de las funciones para crear arraglos es array

np.array(lista, tipo)
tipo: el tipo de dato de
los elementos que va a
Alias de la librería lista: cualquier lista
contener el arreglo.
que se quiera
Si no pasamos el tipo de
convertir a arreglo.
dato numpy inferirá el
tipo

Importar la librería antes de usar las funciones en su interior

Ejemplos Creación de Arreglos
>>> a = np.array([1, 4, 5, 8], float)
>>> a
array([ 1., 4., 5., 8.])
>>> type(a)
<type 'numpy.ndarray'>

>>> np.array([1, 4, 5, 8]) No pasamos el tipo de

dato, entonces python lo
array([1, 4, 5, 8]) selecciona por nosotros

>>> a = [1,2,3] Creación a partir

>>> np.array(a) de una lista
array([1, 2, 3])
Manipulación Arreglos una dimensión
• Los elementos de los arreglos pueden ser accesados y manipulados
usando sus índices
>>> a = np.array([1, 4, 5, 8], float)
>>> a
array([ 1., 4., 5., 8.])
>>> a[0]
1.0
>>> a[1] = 13
>>> a
array([ 1., 13., 5., 8.])
Recuerda..
• A diferencia de las listas que pueden almacenar elementos de
diferente tipos, los arreglos solo almacenan elementos del mismo
tipo, generalment numéricos (float, int).
¿Por qué utilizar arreglos?

Los arreglos pueden realizar operaciones con datos numéricos

mucho más rápido y en general son más eficientes que las
listas.
Ejemplo
• El programa consta de dos listas con las calificaciones del primer y
segundo parcial de los estudiantes. Se pide encontrar la calificación
final de los estudiantes. La calificación final de cada estudiante es el
promedio entre la primera y segunda nota.
Solución

CON LISTAS

CON ARREGLOS
Dimensiones de un arreglo
Dimensiones de un arreglo
• Los arreglos pueden tener múltiples dimensiones

• Las dimensiones en el arreglo son llamado ejes (axes). El número de

dimensiones es el rango (rank) del arreglo.
Arreglo 1 Dimensión

Dimensión Ejemplo Terminología

Eje 0

>>> np.array([0,1,2])
array([0,1,2])
Arreglo 2 Dimensiones
Dimensión Ejemplo Terminología

Eje 0

Eje 1

>>> np.array([ [0,1,2], [3,4,5], [6,7,8] ])

array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
Arrgelo 3-dimensiones

Dimensión Ejemplo Terminología

Eje 2

Eje 0

Eje 1
Arreglo N-Dimensiones

Dimensión Ejemplo Terminología

Propiedades de los arreglos

• ndim
• shape
• dtype
• size
Propiedades de los arreglos

Propiedad Acción

ndim Devuelve el número de dimensiones del arreglo. Al número de

dimensiones de un arreglo se demonina rank.

shape Devuelve una tupla con el número de elementos por eje (o axis).
dtype Devuelve el número total de elementos en el arreglo.
size Devuelve le número de elementos en el arreglo.
Ejemplo Propiedades

a = np.array([0,1,2])

a.ndim 1
0 1 2

a.shape (3,)
Eje 0
a.size 3

a.dtype int64
Ejemplo Propiedades
a = np.array([[1.2, 2.1, 3.3],
[4.1, 5.3, 6.1]])

a.ndim 2
1.2 2.1 3.3
Eje 0 a.shape (2,3)
4.1 5.3 6.1

a.size 6
Eje 1
a.dtype float64
 ndim, shape, size y dtype son propiedades de un arreglo de
python, por lo tanto para llamarlas, no se usa paréntesis al final
Otras funciones para creación de Arreglos
• zeros: Crea un arreglo lleno de ceros.
0. 0. 0. 0.
np.zeros((2,4))
0. 0. 0. 0.

Tupla con el número

de elementos por eje.

np.zeros((3,),int) 0 0 0

Note que el tipo de dato por defecto es float. Si queremos cambiar el tipo de
dato debemos pasarlo este como segundo parámetro a al función
Otras funciones para creación de Arreglos
• ones: Crea un arreglo lleno de unos.
1. 1. 1. 1.
np.ones((2,4))
1. 1. 1. 1.

Tupla con el número

de elementos por eje.

np.ones((3,),int) 1 1 1

Note que el tipo de dato por defecto es float. Si queremos cambiar el tipo de
dato debemos pasarlo este como segundo parámetro a al función
Otras funciones para creación de Arreglos
• full: Crea un arreglo lleno con el valor pasado como parámetro.

10. 10. 10.

np.full((2,3),10,int)
10. 10. 10.
Valor por a llenar
Tupla con el número Tipo de dato (sino
de elementos por eje. se incluye es float)

8. 8. 8. 8.
np.full((4),8)
Otras funciones para creación de Arreglos
• arange: Análoga a la función range() , pero devuelve un arreglo de
numpy de una dimensión con una secuencia numérica.

np.arange(5) [0.,1.,2.,3.,4.]

np.arange(1,5,dtype=float) [1.,2.,3.,4.]

np.arange(1,6,2) [1.,3.,5.]

np.arange(1,6,2,dtype=int) [1,3,5]
Creación de arreglos con valores aleatorios
• random.rand: Devuelve un arreglo lleno de números aletorios del 0 al
1 sin incluir.

np.random.rand(d0,d1,..,dn)

número de elementos por

eje separados por comas.
Creación de arreglos con valores aleatorios

>>> np.random.rand(2)
array([ 0.36224194, 0.04741409])
>>>
>>> np.random.rand(2,3)
array([[ 0.22528469, 0.64457002, 0.95773452],
[ 0.04280942, 0.5524413 , 0.81875768]])
Creación de arreglos con valores aleatorios
• random.randint: Devuelve un arreglo con números aletorios enteros
dentro de un rango especificado [desde,hasta).
np.random.randint(desde, hasta, size = (fil,cols))

desde: valor mínimo que puede Tupla con el número de

tener el arreglo aleatorio. Si elementos por eje
hasta no se especifica, desde
toma su valor y su valor inicial será número de elementos por
cero (0) eje separados por comas.
Creación de arreglos con valores aleatorios

>>> np.random.randint(2, size=10)

array([0, 0, 0, 0, 0, 0, 1, 1, 1, 0])
>>>
>>> np.random.randint(5, size=(2, 4))
array([[0, 4, 1, 1],
[4, 2, 3, 0]])
>>>
>>> np.random.randint(1,6, size=(2, 4))
array([[4, 5, 1, 3],
[2, 5, 4, 1]])
reshape
• Devuelve un nuevo arreglo con las dimensionas dadas como
parámetro.
arr.reshape((fil,cols))

Arreglo que vamos a Tupla con el número

modificar sus dimensiones. de elementos por eje.

a = np.arrange(6,int) a -> [0,1,2,3,4,5]

b = a.reshape((2,3)) b -> [[0,1,2],
[3,4,5]]
reshape

Recuerda que reshape no cambia el arreglo original, sino que

devuelve un nuevo arreglo con las dimensisones indicadas.
Funciones Varias

• copy
• tolist
• cast
copy
• Devuelve un nuevo arreglo que es la copia del original.

>>> a = np.array([1, 2, 3], float)

>>> b = a.copy()
>>> b
array([ 1., 2., 3.])
tolist
• Devuleve una lista a partir de un arreglo

>>> a = np.array([1, 2, 3], float)

>>> a
array([ 1., 2., 3.])
>>> b = a.tolist()
>>> b
[1.0, 2.0, 3.0]
cast
• Devuelve un nuevo arrgelo con con el tipo de dato cambiado

>>> a = np.array([1,2,3])
>>> a
array([1, 2, 3])
>>> a = a.astype(np.float)
>>> a
array([ 1., 2., 3.])
⋙ l = [1,2,3,4,5,6,7,8] Creamos el arreglo ‘a’, a
partir de la lista ‘l’
⋙ a = np.array(l, float)
⋙a
array([ 1., 2., 3., 4., 5., 6., 7., 8.,]) Usamos reshape para crear
un nuevo arreglo con con los
⋙ c = a.reshape(2,4) elementos de a, que tiene 2
⋙c elementos eje 0 (filas) y 4
elemento eje 1 (columna)
array([ [ 1., 2., 3.,4.],
[5., 6., 7., 8.])
⋙ tam = c.size 8
⋙ filas = c.shape[0] 2
⋙ cols = c.shape[1]
4
⋙ rank = c.ndim
2
⋙ tipo = c.type()
dtype('float64')
Ejercicios
• Ejecute cada uno de los comandos y observe la salida

⋙ m = 2
⋙ n = 3
⋙ solo_unos = np.ones((m,))
⋙ solo_zeros = np.zeros((n,), dtype=int)
⋙ pasos = np.arange(5, float)
⋙ nuevo = np.arange(0,10,2)
⋙ nuevo_2 = np.arange(0,10,.2)
⋙ nuevo_2.size
5.2 Indexación Básica
Índices en los arreglos
• Los elementos en los arreglos pueden ser consultados y modificados
usando sus índices.
0 1 2 3

1 2 3 4

Eje 0

Recuerda: Los índices inician en 0 como en el caso de las listas.

Acceder elementos en los arreglos - 1
Dimensión
• Entre cochetes ponemos el índice del elemento queremos acceder.
0 1 2 3 4 5 6 7
⋙ notas = np.array([ 4.13 , 3.76, 3.68, 1.62 , 8.77, 8.70, 8.89, 6.75])
⋙ notas[1]
⋙ 3.76
⋙ notas[5]
⋙ 8.77
Slicing
• Entre cochetes ponemos la sección del arreglo a la que queremos
acceder.
0 1 2 3 4 5 6 7
⋙ notas = np.array([ 4.13 , 3.76, 3.68, 1.62 , 8.77, 8.70, 8.89, 6.75])
⋙ notas[1:5] #retorna los elementos del indice 1 al 4
⋙ np.array([3.76,3.68, 1.62,8.77])
⋙ notas[1:5:2] #retorna los elementos del indice 1 al 4, pero cada dos
⋙ np.array([3.76, 1.62])
Cambiar Valores en los arreglos

⋙ notas

array([ 4.13, 3.76, 3.68, 1.62, 8.77, 8.7 , 8.89, 6.75])

⋙ notas[0] = 10 #cambia el valor en el indice 0 por el valor de 10
⋙ notas

array([ 10. , 3.76, 3.68, 1.62, 8.77, 8.7 , 8.89, 6.75])

⋙ notas[:3]=10 #cambia los valores en el indice 0 al 2, por el valor de 10
⋙ notas

array([ 10. , 10. , 10. , 1.62, 8.77, 8.7 , 8.89, 6.75])

Iterar sobre elementos de un arreglo
for para iterar sobre elementos de un arreglo
• Los arreglos se pueden recorrer al igual que las listas.

>>> import numpy as np 0

>>> arreglo1D = np.arange(0,11,2) 4
8
array([ 0, 2, 4, 6, 8, 10])
12
>>> for el in arreglo1D: 16
print(el*2) 20
5.6 Operaciones aritméticas, estadísticas y de
ordenamiento
Operaciones aritméticas con arreglos
Operaciones Aritméticas entre arreglos y
escalares

Las operaciones aritméticas como la suma, resta, potenciación y demás

se efectúan elemento a elemento para los arreglos de numpy, es decir
que multiplicar un entero por un arreglo producirá un nuevo arreglo
con cada uno de los elementos de arreglo original multiplicado por el
entero
Operaciones Aritméticas entre arreglos y
escalares
>>> a = np.arange(6)
>>> a
array([0, 1, 2, 3, 4, 5])

>>> a + 2
array([2, 3, 4, 5, 6, 7])

>>> a * 3
array([ 0, 3, 6, 9, 12, 15])

>>> a ** 2
array([ 0, 1, 4, 9, 16, 25])
Operaciones Aritméticas entre arreglos
• Las operaciones aritméticas entre arreglos también se efectúan
elemento a elemento.
>>> notas_1 = np.array([ 0.13, 8.40, 8.49, 3.58])
>>> notas_2 = np.array([ 0.33, 7.72, 4.20, 8.61])
>>> suma_notas = notas_1 + notas_2
>>> suma_notas
array([ 0.46, 16.12, 12.69, 12.19])
>>> suma_resta = notas_1 - notas_2
>>> suma_resta
array([[ -0.2, 0.68, 4.29, -5.03]])
Funciones matemáticas y estadísticas
Operaciones básicas – Aritméticas.
a = np.array([2, 4, 3], float)

• a.sum() -> calcula la suma entre los elementos del arreglo

• a.prod() -> calcula el producto entre los elementos del arreglo

>>> a = np.array([2, 4, 3], float)

>>> a.sum()
9.0
>>> a.prod()
24.0
Operaciones básicas – Estadísticas.
a = np.array([2, 4, 3], float)

• a.mean() -> calcula la media entre los elementos del arreglo

• a.std() -> calcula la desviación estándar centre los elementos del arreglo
• a.var() -> calcula la varianza los elementos del arreglo
>>> a = np.array([2, 4, 3], float)
>>> a.mean()
3.0
>>> a.std()
0.81649658092772603
>>> a.var()
0.66666666666666663
 Operaciones básicas – Ordenamiento.
a = np.array([2, 1, 9], float)

• a.min() -> retorna el mínimo valor entre los elementos del arreglo.
• a.max() -> retorna el máximo entre los elementos del arreglo.

>>> a = np.array([2, 1, 9], float)

>>> a.min()
1.0
>>> a.max()
9.0
 Operaciones básicas – Ordenamiento.
a = np.array([2, 1, 9], float)

• a.argmax() -> retorna el índice del máximo valor entre los elementos del
arreglo
• a.argmin() -> retorna el índice del mínimo valor entre los elementos del
arreglo.
>>> a = np.array([2, 1, 9], float)
>>> a.argmin()
1
>>> a.argmax()
2
 Operaciones básicas – Ordenamiento.
a = np.array([2, 1, 9], float)

• a.argsort() -> retorna un arreglo con los índices de los elementos ordenados.
• a.sort() -> ordena los elementos del arreglo en orden ascendente.
>>> a = np.array([2, 1, 9], float)
>>> a.argsort()
array([1, 0, 2]
>>> a.sort()
>>> a
array([ 1., 2., 9.])
5.2 Indexación Básica
Índices en los arreglos
• Los elementos en los arreglos pueden ser consultados y modificados
usando sus índices.
0 1 2 3

1 2 3 4

Eje 0

Recuerda: Los índices inician en 0 como en el caso de las listas.

Acceder elementos en los arreglos - 1
Dimensión
• Entre cochetes ponemos el índice del elemento queremos acceder.
0 1 2 3 4 5 6 7
⋙ notas = np.array([ 4.13 , 3.76, 3.68, 1.62 , 8.77, 8.70, 8.89, 6.75])
⋙ notas[1]
⋙ 3.76
⋙ notas[5]
⋙ 8.77
Slicing
• Entre cochetes ponemos la sección del arreglo a la que queremos
acceder.
0 1 2 3 4 5 6 7
⋙ notas = np.array([ 4.13 , 3.76, 3.68, 1.62 , 8.77, 8.70, 8.89, 6.75])
⋙ notas[1:5] #retorna los elementos del indice 1 al 4
⋙ np.array([3.76,3.68, 1.62,8.77])
⋙ notas[1:5:2] #retorna los elementos del indice 1 al 4, pero cada dos
⋙ np.array([3.76, 1.62])
Cambiar Valores en los arreglos

⋙ notas

array([ 4.13, 3.76, 3.68, 1.62, 8.77, 8.7 , 8.89, 6.75])

⋙ notas[0] = 10 #cambia el valor en el indice 0 por el valor de 10
⋙ notas

array([ 10. , 3.76, 3.68, 1.62, 8.77, 8.7 , 8.89, 6.75])

⋙ notas[:3]=10 #cambia los valores en el indice 0 al 2, por el valor de 10
⋙ notas

array([ 10. , 10. , 10. , 1.62, 8.77, 8.7 , 8.89, 6.75])

5.2 Indexación con arreglos
Operadores de comparasión
• Los operadores de comparasión (==,>,<,etc) pueden ser usados para
comparar los elementos de un arreglo
• Contra un escalar
• Contra los elementos de un arreglo de igual tamaño.
• El valor resultante es un arreglo de valores booleanos True / False
Arreglos boleanos

>>> a = np.array([1, 3, 0], float)

>>> b = np.array([0, 3, 2], float)

>>> a > 0 Se compara si cada uno

array([ True, True, False], dtype=bool) de los elementos es
mayor a 0

>>> a > b
array([ True, False, False], dtype=bool) La comparación es
>>> cond = a == b entre los elementos en
>>> cond la misma posición
array([False, True, False], dtype=bool)
Problema: Queremos seleccionar o modificar solo los elementos del
arreglo que cumplen con alguna condición.
Indexamiento booleana - Seleccionar
elementos
• Seleccionar los elementos del arreglo que son mayores que 0

>>> a = np.array([1, 3, 0], float)

>>> a > 0
array([True, True, False], dtype=bool)
>>> a[a > 0]
array([1, 3], dtype=bool) #se retornan solo los valores en
#done el indice el True

Usamos el arreglo booleano como índice para extraer los elementos que
cumplen con la condición
Indexamiento booleana – Reemplazar
elementos
• Cambiar en el arreglo los valores igualaes a 59 por 60.

>>> a = np.array([39,72, 48, 60, 59, 79, 59], float)

>>> cond = a == 59
>>> cond
array([False, False, False, False, True, False, True], dtype=bool)
>>> a[cond]=60
>>> a
np.array([39,72, 48, 60, 60, 79, 60], float)
Otras funciones boleanas

Propiedad Acción

np.all(condición) Retorna True si todos los elementos del arreglo cumplen con
la condición.

np.any(condición) Retorna True si almenos uno de los elementos del arreglo

cumple con la condición.
np.where(condición) Retorna un arreglo con los índices de los elementos que
cumplen con la condición.
Ejemplo

>>> a = np.array([1, 3, 0], float)

>>> np.all(a>0)
False
>>> np.any(a>0)
True
>>> np.where(a>0)
(array([0, 1]),)
Indexamiento con Arreglos
• Nos permite acceder a múltiple valores del array en un sola sentencia.
• Para ello dentro de los corchetes del arreglo, pasamos una lista de
índices de los elementos que queremos acceder
0 1 2 3

>>> a = np.array([2, 4, 6, 8], float)

>>> b = np.array([0, 0, 1, 3, 2, 1], int)
>>> a[b]
array([ 2., 2., 4., 8., 6., 4.])

Tomamos los elementos de a en los índices: 0, 0, 1, 3, 2, 1

Ejercicio
• Se tiene los siguientes arreglos en numpy con información de las
casas en ventas en la ciudad de Guayaquil

codigos = np.array(['001','002','003','004','005','006'])
precios = np.array([75000,80000,90000,85000,120000,110000])
metros = np.array([98,100,110,90,120,160]) #metros cuadrados
sectores = np.array(['norte','sur','centro','norte','centro','norte'])
habitaciones = np.array([2,3,2,2,3,4])
Ejercicio – continuación
• Se pide que encuentre lo siguiente:
• ¿Cuál es el precio promedio de las casas en el sector norte?
• ¿Cuáles son los códigos de las casas de tres o cuatro habitaciones que cuestan
menos de 85000 dólares ?
• Se conctruye un centro comercial en el “centro” y las plusvalia de las casas
aumentan en un 10%. Modifique el precio de las casas para reflejar esto
Ejercicio – continuación
• ¿ Cuál es el precio promedio de las casas en el sector norte?

condsec = sectores=='norte'
preciosn = precios[condsec]
precio_prom_norte = preciosn.mean()
print('Precio promedio de las casas sector norte',precio_prom_norte)
Ejercicio – continuación
• ¿Cuáles son los códigos de las casas de tres o cuatro habitaciones
que cuestan menos de 85000 dólares ?

cond = ( (habitaciones==3) | (habitaciones==4) ) & (precios<85000)

cod_hab_pre = codigos[cond]
print("Condicion habitaciones precios",cod_hab_pre)

El operador or en numpy es |
El operador and en numpy es &
Es importante usar los parentesis para limitar las condiciones
Ejercicio – continuación
• Se conctruye un centro comercial en el “centro” y las plusvalia de las casas
aumentan en un 10%. Modifique el precio de las casas para reflejar esto.

precios[sectores=="centro"] = precios[sectores=="centro"] + precios[sectores=="centro"]*0.10

Arreglos 2 dimensiones
Arreglo 2 Dimensiones
Dimensión Ejemplo Terminología

Eje 0

Eje 1

>>> np.array([ [0,1,2], [3,4,5], [6,7,8] ])

array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
Propiedades de un arreglo
a = np.array([[1.2, 2.1, 3.3],
[4.1, 5.3, 6.1]])

a.ndim 2
1.2 2.1 3.3
Eje 0 a.shape (2,3)
4.1 5.3 6.1

a.size 6
Eje 1
a.dtype float64
Otras funciones para creación de Arreglos
• zeros: Crea un arreglo lleno de ceros.
0. 0. 0. 0.
np.zeros((2,4))
0. 0. 0. 0.

Tupla con el número

de elementos por eje.

np.zeros((3,),int) 0 0 0

Note que el tipo de dato por defecto es float. Si queremos cambiar el tipo de
dato debemos pasarlo este como segundo parámetro a al función
Otras funciones para creación de Arreglos
• ones: Crea un arreglo lleno de unos.
1. 1. 1. 1.
np.ones((2,4))
1. 1. 1. 1.

Tupla con el número

de elementos por eje.

np.ones((3,),int) 1 1 1

Note que el tipo de dato por defecto es float. Si queremos cambiar el tipo de
dato debemos pasarlo este como segundo parámetro a al función
Otras funciones para creación de Arreglos
• full: Crea un arreglo lleno con el valor pasado como parámetro.

10. 10. 10.

np.full((2,3),10,int)
10. 10. 10.
Valor por a llenar
Tupla con el número Tipo de dato (sino
de elementos por eje. se incluye es float)

8. 8. 8. 8.
np.full((4),8)
Otras funciones para creación de Arreglos
• arange: Análoga a la función range() , pero devuelve un arreglo de
numpy de una dimensión con una secuencia numérica.

np.arange(5) [0.,1.,2.,3.,4.]

np.arange(1,5,dtype=float) [1.,2.,3.,4.]

np.arange(1,6,2) [1.,3.,5.]

np.arange(1,6,2,dtype=int) [1,3,5]
Creación de arreglos con valores aleatorios
• random.rand: Devuelve un arreglo lleno de números aletorios del 0 al
1 sin incluir.

np.random.rand(d0,d1,..,dn)

número de elementos por

eje separados por comas.
Creación de arreglos con valores aleatorios

>>> np.random.rand(2)
array([ 0.36224194, 0.04741409])
>>>
>>> np.random.rand(2,3)
array([[ 0.22528469, 0.64457002, 0.95773452],
[ 0.04280942, 0.5524413 , 0.81875768]])
Creación de arreglos con valores aleatorios
• random.randint: Devuelve un arreglo con números aletorios enteros
dentro de un rango especificado [desde,hasta).
np.random.randint(desde, hasta, size = (fil,cols))

desde: valor mínimo que puede Tupla con el número de

tener el arreglo aleatorio. Si elementos por eje
hasta no se especifica, desde
toma su valor y su valor inicial será número de elementos por
cero (0) eje separados por comas.
Creación de arreglos con valores aleatorios

>>> np.random.randint(2, size=10)

array([0, 0, 0, 0, 0, 0, 1, 1, 1, 0])
>>>
>>> np.random.randint(5, size=(2, 4))
array([[0, 4, 1, 1],
[4, 2, 3, 0]])
>>>
>>> np.random.randint(1,6, size=(2, 4))
array([[4, 5, 1, 3],
[2, 5, 4, 1]])
reshape
• Devuelve un nuevo arreglo con las dimensionas dadas como
parámetro.
arr.reshape((fil,cols))

Arreglo que vamos a Tupla con el número

modificar sus dimensiones. de elementos por eje.

a = np.arrange(6,int) a -> [0,1,2,3,4,5]

b = a.reshape((2,3)) b -> [[0,1,2],
[3,4,5]]
reshape

Recuerda que reshape no cambia el arreglo original, sino que

devuelve un nuevo arreglo con las dimensisones indicadas.
Índices en los arreglos
• Los elementos en los arreglos pueden ser consultados y modificados
usando sus índices.
0 1 2
0 1 2 3
0,0 0,1 0,2 0
1 2 3 4
Eje 0
1,0 1,1 1,2 1

Eje 0
Eje 1

Recuerda: Los índices inician en 0 como en el caso de las listas.

Acceder elementos en los arreglos – 2
Dimensiones
• Arreglos 2 dimensiones

⋙ np_2d = np.array([[1.73, 1.68, 1.71, 1.89, 1.79],

[65.4, 59.2, 63.6, 88.4, 68.7]])
⋙ np_2d
array([[ 1.73, 1.68, 1.71, 1.89, 1.79],
[ 65.4 , 59.2 , 63.6 , 88.4 , 68.7 ]])
Acceder elementos en los arreglos – 2
Dimensiones
0 1 2 3 4

array([[ 1.73, 1.68, 1.71, 1.89, 1.79], 0

[ 65.4 , 59.2 , 63.6 , 88.4 , 68.7 ]]) 1

⋙ np_2d[0,2]
1.71
⋙ np_2d[1,4]
68.7
⋙ np_2d[1,0]
65.4
5.5 Slicing
Slincing
0 1 2 3 4

array([[ 1.73, 1.68, 1.71, 1.89, 1.79], 0

[ 65.4 , 59.2 , 63.6 , 88.4 , 68.7 ]]) 1

⋙ np_2d[1,:]
array([65.4,59.2, 63.6, 88.4, 68.7])
Slincing
0 1 2 3 4

array([[ 1.73, 1.68, 1.71, 1.89, 1.79], 0

[ 65.4 , 59.2 , 63.6 , 88.4 , 68.7 ]]) 1

⋙ np_2d[ :0,3]
Array([ 1.89, 88.4])
Slincing
0 1 2 3 4

array([[ 1.73, 1.68, 1.71, 1.89, 1.79], 0

[ 65.4 , 59.2 , 63.6 , 88.4 , 68.7 ]]) 1

⋙ np_2d[:,1:4]
array([[ 1.68, 1.71, 1.89],
[ 59.2 , 63.6 , 88.4 ]])
Cambiar Valores en arreglos de dos
dimensiones

⋙ np_2d

array([[ 1.73, 1.68, 1.71, 1.89, 1.79],

[ 65.4 , 59.2 , 63.6 , 88.4 , 68.7 ]])
⋙ np_2d[1,0] = 0
⋙ np_2d

array([[ 1.73, 1.68, 1.71, 1.89, 1.79],

[ 0. , 59.2 , 63.6 , 88.4 , 68.7 ]])
Cambiar Valores en arreglos dos dimensiones

⋙ np_2d

array([[ 1.73, 1.68, 1.71, 1.89, 1.79],

[ 0., 59.2 , 63.6 , 88.4 , 68.7 ]])
⋙ np_2d[:,1:3] = 10

np_2d
array([[ 1.73, 10. , 10. , 1.89, 1.79],
[ 0. , 10. , 10. , 88.4 , 68.7 ]])
 for para iterar sobre elementos de un arreglo

>>> import numpy as np

>>> arreglo2D = np.array([[1, 2, 3], [4, 5, 6]], float) ('indices', 0, 0, 'valor', 1.0)
array([[ 1., 2., 3.], ('indices', 0, 1, 'valor', 2.0)
('indices', 0, 2, 'valor', 3.0)
[ 4., 5., 6.]])
('indices', 1, 0, 'valor', 4.0)
>>> for x in range(arreglo2D.shape[0]): ('indices', 1, 1, 'valor', 5.0)
for y in range(arreglo2D.shape[1]): ('indices', 1, 2, 'valor', 6.0)
print("indices",x,y,"valor", arreglo2D[x,y] )
Ejercicio
• Reemplazar los elementos del arreglo que son menores que cero por
1.
>>> import numpy as np
>>> arreglo2D = np.array([[-1, 2, -8], [4, -5, 6]], float)
array([[ 1., 2., 3.],
[ 4., 5., 6.]])
>>> for x in range(arreglo2D.shape[0]):
for y in range(arreglo2D.shape[1]):
if arreglo2D[x,y] < 0:
arreglo2D[x,y] = 1
>>> arreglo2D
Operaciones Aritméticas entre arreglos y
escalares
>>> a = np.arange(6).reshape((2,3))
>>> a
array([[0, 1, 2],
[3, 4, 5]])
>>> a + 2
array([[2, 3, 4],
[5, 6, 7]])
>>> a * 3
array([[ 0, 3, 6],
[ 9, 12, 15]])
>>> a ** 2
array([[ 0, 1, 4],
[ 9, 16, 25]])
Operaciones básicas – Arreglos
multidimensionales

• Para arreglos multidimensionales, cada una de las funciones descritas

hasta ahora puede tomar como argumento el axis a lo largo del cuál
se va a realizar la operación.
Ejempli

>>> a = np.array([ [0, 2], [3, -1], [3, 5]], float)

>>> a.mean(axis=0)
array([ 2., 2.])
>>> a.mean(axis=1)
array([ 1., 1., 4.])
>>> a.min(axis=1)
array([ 0., -1., 3.])
>>> a.max(axis=0)
array([ 3., 5.])
Ejercicio
• El administrador de una cadena de tiendas tiene el total de ventas por
cada mes de las tiendas ubicadas en distintos centros comerciales. El
administrador desea tener un reporte consolidado de las ventas y
hallar
• El total vendido entre todas las cadenas por mes.
• El total de ventas entre todas las cadenas al año.
Ejercicio – Notas exámenes
• Escriba un programa que dado un arreglo bidimensional con las notas
de todos los estudiantes registrados en la materia fundamentos de
programación, calcule el promedio de cada paralelo en el examen del
primer parcial materia.
• El profesor del paralelo 1 se equivoco en la nota estudiante1, la nota
real del ser 80, cambie la nota del estudiante.
• Como resultado de un trabajo extra el profesor del paralelo 3 le
aumentará 5 puntos a los estudiantes 1,2 y 3, cambie las notas de los
estudiantes en una sola sentencia
Notas Primer Parcial Fundamentos de
Programación

Paralelo estudiante1 estudiant2 estdiante3 estudiante4

1 98 96 56 20

2 11 53 85 93

3 78 46 34 73

4 70 60 43 100
Solución
5.4 Indexación boleana
Arreglos boleanos
• Operaciones con operadores boleanos (==,>,<,etc) entre arreglos de
numpy producen arreglos con valores boleanos.

>>> h = np.array([[1,3,5],[2,6,7],[3,6,5]])
>>> h
array([[1, 3, 5],
[2, 6, 7],
[3, 6, 5]])
>>> h > 3
array([[False, False, True],
[False, True, True],
[False, True, True]], dtype=bool)
Arreglos boleanos

>>> a = np.array([1, 3, 0], float)

>>> b = np.array([0, 3, 2], float)
>>> a > b
array([ True, False, False], dtype=bool)
La comparación es
entre los elementos en
>>> a == b
la misma posición
array([False, True, False], dtype=bool)
>>> a <= b
array([False, True, True], dtype=bool)
•

Problema: Queremos seleccionar o modificar solo los elementos del

arreglo que cumplen con alguna condición.
Seleccionar elementos
• Seleccionar los elementos del arreglo que son mayores que 2

>>> a = np.array([1, 3, 0], float)

>>> a > 2
array([False, True, False], dtype=bool)
>>> a[a > 2]
3

Usamos el arreglo booleano como índice para extraer los elementos que
cumplen con la condición
Seleccionar elementos
• Seleccionar los elemetos del arreglos que son mayores o iguales que 6
>>> a = np.array([[6, 4], [5, 9]], float)
>>> a >= 6
array([[ True, False], [False, True]], dtype=bool)
>>> a[a >= 6]
array([ 6., 9.])

>>> a = np.array([[6, 4], [5, 9]], float)

>>> sel = (a >= 6)
>>> a[sel]
array([ 6., 9.])
Reemplazar elementos
• Reemplazar los elementos del arreglo que son menores que cero por
1.

>>> z
array([[ 1, 2, -1],
[-3, 4, 5],
[-2, -1, 7]])
>>> z[z<0] = 1
>>> z
array([[1, 2, 1],
[1, 4, 5],
[1, 1, 7]])
Ejercicio
• Cree un arreglo de dos dimensiones de tamaño 5x5 con valores
aleatorios entre cero y seis [0,6) y muestre el resultado.
• Reemplace los elementos del arreglo menores o iguales a 3 por 0 y los
mayores a 3 con 6.
Ejercicio
• Usted tiene un arreglo de dos dimensiones llamado notas, con las
notas de los alumnos de distintos cursos en distintas materias.
materia1 materia2 materia3 materia4
alumno1 13 14 12 20
alumno2 12 18 18 13
alumno3 11 12 19 20

• Un alumno reprueba una materia si tiene 13 o menos puntos. Cree un

arreglo que diga si los alumnos aprueban o reprueban las materias.
Para las materias que aprueba debe mostrarse ´A´ y para que las
reprueban ´R´.
Ejercicio
• Ejemplo de la salida
materia1 materia2 materia3 materia4
alumno1 13 14 12 20
alumno2 12 18 18 13
alumno3 11 12 19 20

materia1 materia2 materia3 materia4

alumno1 ’R’ ‘A’ ‘R’ ‘A’
alumno2 ‘R’ ‘A’ ‘A’ ‘R’
alumno3 ‘R’ ‘R’ ‘A’ ‘A’
Solución
import numpy as np
notas = np.array([[13,14,12,20],
[12,18,18,13],
[11,12,19,20]])

#arreglo que tendra la informacion si el alumno pasa o no pasa en las materias

#creamos un arreglo vacion con las mismas dimensiones que nota y de tipo string
aprobacion = np.empty( (notas.shape[0],notas.shape[1]) ,dtype='str' )
print(aprobacion)

#colocamos A en las celdas que tienen un valor mayor que 13

aprobacion[notas>13] = 'A'
print(aprobacion)

#colocamos R en las celdas que tienen un valor menor 0 igual que 13

aprobacion[notas<=13] = 'P'
print(aprobacion)
Indexamiento Avanzado
• Nos permite acceder a múltiple valores del array en un sola
sentencia.
• Para ello dentro de los corchetes del arreglo, pasamos una lista de
con los índices de la filas y una lista de índices índices de las columnas
de los elementos a los que queremos acceder
Indexamiento Avanzado
Indexamiento Avanzado - Ejercicio
• Use indexamiento avanzado para obtener 7,8 y 4 del arreglo h
Indexamiento Avanzado – Solución
• Observamos que los elementos a los que queremos acceder se
encuentran en los índices [0,2] , [2,0] , [2,2].
• Para acceder a esos tres elementos escribimos:
>>> import numpy as np
>>> h = np.array([[1,2,7],[3,5,9],[8,6,4]])
>>> h
array([ [1, 2, 7],
[3, 5, 9],
[8, 6, 4]])
>>> h[ [0,2,2] , [2,0,2] ]
array([7, 8, 4])
Otras funciones boleanas

Propiedad Acción

np.all(condición) Retorna True si todos los elementos del arreglo cumplen con
la condición.

np.any(condición) Retorna True si almenos uno de los elementos del arreglo

cumple con la condición.
np.where(condición) Retorna un arreglo con los índices de los elementos que
cumplen con la condición.
Ejemplo

>>> a = np.array([1, 3, 0], float)

>>> np.all(a>0)
False
>>> np.any(a>0)
True
>>> np.where(a>0)
(array([0, 1]), )
Ejemplo
• El arreglo vendedores tiene el nombre de los vendedores. El arreglo
ventas tiene la cantidad de ventas por trimestre para un conjunto de
vendedores..

• ¿Cuáles son los vendedores que han vendido más de 1000 dólares
en el año?
Solución
import numpy as np

vendedores = np.array(["jose","maria","pedro","juan","alvaro"])
ventas = np.array([[123,334,837,314,536],
[245,234,456,897,234],
[234,898,678,577,123],
[124,321,154,176,248]])

#encontramos el total de venta anual

total_anual = ventas.sum(axis=0)
print(total_anual)

#obtenemos los indices donde las ventas anuales es mayor a 1000

indices_vendedores = np.where(total_anual>1000)

#usamos esos indices para extraer la informacion de los nombres del arreglo de vendedores
print(vendedores[indices_vendedores])
5.7 Broadcasting
Broadcasting
• El término Broadcasting describe cómo numpy trata arreglos con
diferentes formas durante operaciones aritméticas.

• Para realizar broadcast se tiene dos únicas reglas:

1) Deben tener mismo shape, o
2) O uno de los arreglos tiene una sola dimension
Broadcasting

>>> a = np.array([1,2,3])
a(3) b(1) c(3)
>>> b = np.array([2])
>>> c = a * b 1 2 3 2 2 2 2 4 6
>>> c
stretch
array([2, 4, 6])
Broadcasting

>>> a = np.array([[0,0,0,0], a(4x4) b(4x1) c(4x4)

[10,10,10,10],
[20,20,20,20], 0 0 0 0 1 2 3 4 1 2 3 4
[30,30,30,30]])
>>> b = np.array([1,2,3,4]) 10 10 10 10 1 2 3 4 11 12 13 14
>>> c = a + b
>>> c 20 20 20 20 1 2 3 4 21 22 23 24
array([[ 1, 2, 3, 4],
[11, 12, 13, 14], 30 30 30 30 1 2 3 4 31 32 33 34
[21, 22, 23, 24],
[31, 32, 33, 34]]) stretch
 Broadcasting

a(4x3) b(3x1) c(3x4)

>>> a = np.array([0,10,20,30])
>>> b = np.array([ [1],
0 10 20 30 1 1 1 1 1 11 21 31
[2],
[3] ])
0 10 20 30 2 2 2 2 2 12 22 32
>>> c = a + b
>>> c
0 10 20 30 3 3 3 3 3 13 23 33
array([[ 1, 11, 21, 31],
[ 2, 12, 22, 32], stretch stretch
[ 3, 13, 23, 33]])
 0 1 2 3 4

0 0,0 0,1 0.2 0.3 0.4

5 11 12 90 70
1 1,0 1,1 1,2 1,3 1,4
Eje 0
13 34 15 80 5
2 2,0 2,1 2,2 2,3 2,4

13 34 15 80 5

Eje 1
 //80
0 1 2 3 4

0 0,0 0,1 0.2 0.3 0.4

5 11 12 90 70
1 1,0 1,1 1,2 1,3 1,4
Eje 0
13 34 15 80 5
2 2,0 2,1 2,2 2,3 2,4

13 34 15 80 5

Eje 1
 0 1 2 3 4

0 0,0 0,1 0.2 0.3 0.4

5 11 12 90 70
1 1,0 1,1 1,2 1,3 1,4
Eje 0
13 34 15 80 5
2 2,0 2,1 2,2 2,3 2,4

13 34 15 80 5

Eje 1
En el eje0 estan de 0 al 1 seccion = a[ 0:2 , 1:4 ]
En el eje1 estan de 1 al 3
0 1 2 3 4

0 0,0 0,1 0.2 0.3 0.4

5 11 12 90 70
1 1,0 1,1 1,2 1,3 1,4
Eje 0
13 34 15 80 5
2 2,0 2,1 2,2 2,3 2,4

13 34 15 80 5

Eje 1
 0 1 2 3 4

0 0,0 0,1 0.2 0.3 0.4

5 11 12 90 70
1 1,0 1,1 1,2 1,3 1,4
Eje 0
13 34 15 80 5
2 2,0 2,1 2,2 2,3 2,4

13 34 15 80 5

Eje 1
 0 1 2 3 4

0 0,0 0,1 0.2 0.3 0.4

5 11 12 90 70
1 1,0 1,1 1,2 1,3 1,4
Eje 0
13 34 15 80 5
2 2,0 2,1 2,2 2,3 2,4

13 34 15 80 5

Eje 1
 0 1 2 3 4

0 0,0 0,1 0.2 0.3 0.4

5 11 12 90 70
1 1,0 1,1 1,2 1,3 1,4
Eje 0
13 34 15 80 5
2 2,0 2,1 2,2 2,3 2,4

13 34 15 80 5

Eje 1
 Eje 1

0,0 0,1 0.2 0.3 0.4 188

5 11 12 90 70
1,0 1,1 1,2 1,3 1,4 147

13 34 15 80 5
2,0 2,1 2,2 2,3 2,4 147

13 34 15 80 5
 0,0 0,1 0.2 0.3 0.4

5 11 12 90 70
1,0 1,1 1,2 1,3 1,4

Eje 0
13 34 15 80 5
2,0 2,1 2,2 2,3 2,4

13 34 15 80 5

np.array([31, 79, 42, 250, 80])

 EJERCICIO NOTAS

jose mario juan pedro manuel rosa

0,0 0,1 0.2 0,3 0,4 0,5

Evaluacion 1
34 56 78 50 45 90
1,0 1,1 1,2 1,3 1,4 1,5
Evaluacion 2
Eje 0
13 34 15 80 5 80
Evaluacion 3 2,0 2,1 2,2 2,3 2,4 2,5

13 34 15 80 5 90

Eje 1
 EJERCICIO VENTAS

1 2 3 4 5 6 7 8 9 10 11 12 meses

jose 123 334 837

maria 245 234 456

pedro 234 898 678 587 576 390

juan 124 321 154 925, 528, 1345

alvaro 124 321 154 704 750 800

 EJERCICIO VENTAS

Primer trimestre Segundo trimestre Tercer trimestre Cuarto trimestre

1 2 3 4 5 6 7 8 9 10 11 12

zona1 jose 123 334 837

zona1 maria 245 234 456

zona2 pedro 234 898 678 587 576 390

zona2 juan 124 321 154 925, 528, 1345

zona2 alvaro 124 321 154 704 750 800

0 1 2 3 4 5 6 7 8 9 10 11 indices
 EJERCICIO VENTAS

Primer trimestre Segundo trimestre Tercer trimestre Cuarto trimestre

1 2 3 4 5 6 7 8 9 10 11 12

zona1 jose 123 334 837

zona1 maria 245 234 456

zona2 pedro 234 898 678 587 576 390

zona2 juan 124 321 154 925, 528, 1345

zona2 alvaro 124 321 154 704 750 800