NumPy Array

El array es el principal objeto de la librería. Representa datos de manera estructurada y se

puede acceder a ellos a traves del indexado, a un dato específico o un grupo de muchos datos
específicos.
lista = [1, 2 , 3, 4, 5, 6, 7, 8, 9]
lista
---> [1, 2, 3, 4, 5, 6, 7, 8, 9]

arr = np.array(lista)
type(arr)
---> numpy.ndarray

matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

matriz = np.array(matriz)
matriz
---> array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
El indexado nos permite acceder a los elementos de los array y matrices
Los elementos se emepiezan a contar desde 0.
arr[0]
---> 1
Es posible operar directamente con los elementos.
arr[0] + arr[5]
---> 7
En el caso de las matrices al indezar una posición se regresa el array de dicha posición.
matriz[0]
---> array([1, 2, 3])
Para seleccionar un solo elemento de la matriz se especifica la posición del elemento
separada por comas.
matriz[0, 2]
---> 3
El slicing nos permite extraer varios datos, tiene un comienzo y un final.
En este ejemplo se está extrayendo datos desde la posición 1 hasta la 5. [1:6].
arr[1:6]
---> array([2, 3, 4, 5, 6])
Si no se ingresa el valor de Start se toma el incio como la posición 0.
arr[:6]
---> array([1, 2, 3, 4, 5, 6])
En cambio si no se le da una posción de End se regresan todos los elementos hasta el final del
array.
arr[2:]
---> array([3, 4, 5, 6, 7, 8, 9])
También se puede trabajar por pasos.
En este ejemplo de 3 en 3.
Regresa la posición 0, 0 + 3, 3 + 3 y como no hay posición 6 + 3, no se regrese nada.
arr[::3]

---> array([1, 4, 7])

Cuando se le asigna un valor negativo se regresan los valores comenzando desde la última
posición del array.
arr[-1]
---> 9
arr[-3:]
---> array([7, 8, 9])
Para el caso de las matrices sucede algo similar.
Para acceder a los valores a nivel de filas.
matriz[1:]
---> array([[4, 5, 6],
[7, 8, 9]])
Para acceder a los valores a nivel de filas y columnas.
matriz[1:, 0:2]
---> array([[4, 5],
[7, 8]])

Tipos de datos
Los arrays de NumPy solo pueden contener un tipo de dato, ya que esto es lo que le confiere
las ventajas de la optimización de memoria.
Podemos conocer el tipo de datos del array consultando la propiedad .dtype.
arr = np.array([1, 2, 3, 4])
arr.dtype
---> dtype('int64')
Si queremos usar otro tipo de dato lo podemos definir en la declaración del array.
arr = np.array([1, 2, 3, 4], dtype = 'float64')
arr.dtype
---> dtype('float64')
Ahora vemos que los valores están con punto decimal.
arr
---> array([1., 2., 3., 4.])
Si ya se tiene el array definido se usa el método .astype() para convertir el tipo de dato.
arr = np.array([1, 2, 3, 4])
arr = arr.astype(np.float64)
arr
---> array([1., 2., 3., 4.])
También se puede cambiar a tipo booleano recordando que los números diferentes de 0 se
convierten en True.
arr = np.array([0, 1, 2, 3, 4])
arr = arr.astype(np.bool_)
arr
---> array([False, True, True, True, True])
También podemos convertir los datos en tipo string.
arr = np.array([0, 1, 2, 3, 4])
arr = arr.astype(np.string_)
arr
---> array([b'0', b'1', b'2', b'3', b'4'], dtype='|S21')
De igual forma se puede pasar de string a numero.
arr = np.array(['0', '1', '2', '3', '4'])
arr = arr.astype(np.int8)
arr
---> array([0, 1, 2, 3, 4], dtype=int8)
Si un elemento no es de tipo número el método falla.
arr = np.array(['hola','0', '1', '2', '3', '4'])
arr = arr.astype(np.int8)
arr
----------------------------------------------------------------------
-----
ValueError Traceback (most recent call
last)
<ipython-input-30-b9bb95861c7b> in <module>()
1 # DSi un elemento no es de tipo número el método falla.
2 arr = np.array(['hola','0', '1', '2', '3', '4'])
----> 3 arr = arr.astype(np.int8)
4 arr

ValueError: invalid literal for int() with base 10: 'hola'

Para crear un array con un rango de datos podemos usar el método arange
np.arange(0,10)

Dimensiones

 scalar: dim = 0 Un solo dato o valor

 vector: dim = 1 Listas de Python
 matriz: dim = 2 Hoja de cálculo
 tensor: dim > 3 Series de tiempo o Imágenes
Declarando un escalar.
scalar = np.array(42)
print(scalar) ----> 42
scalar.ndim ----> 0
Declarando un vector.
vector = np.array([1, 2, 3])
print(vector) ----> [1 2 3]
vector.ndim ----> 1
Declarando una matriz.
matriz = np.array([[1, 2, 3], [4, 5, 6]])
print(matriz)
matriz.ndim
---->[[1 2 3]
[4 5 6]]
----> 2
Declarando un tensor.
tensor = np.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]],
[[13, 13, 15], [16, 17, 18], [19, 20, 21], [22, 23, 24]]])
print(tensor)
tensor.ndim
----> [[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]

[[13 13 15]
[16 17 18]
[19 20 21]
[22 23 24]]]
----> 3
Agregar o eliminar dimensiones
Se puede definir el número de dimensiones desde la declaración del array
vector = np.array([1, 2, 3], ndmin = 10)
print(vector) ----> [[[[[[[[[[1 2 3]]]]]]]]]]
vector.ndim ----> 10
Se pueden expandir dimensiones a los array ya existentes.
Axis = 0 hace refencia a las filas, mientras que axis = 1 a las columnas.
expand = np.expand_dims(np.array([1, 2, 3]), axis = 0)
print(expand) ----> [[1 2 3]]
expand.ndim ----> 2
Remover/comprimir las dimensiones que no están siendo usadas.
print(vector, vector.ndim) ----> [[[[[[[[[[1 2 3]]]]]]]]]] 10
vector_2 = np.squeeze(vector)
print(vector_2, vector_2.ndim) ----> [1 2 3] 1
Reto
1. Definir un tensor de 5 dimensiones
2. Sumar una dimensión en algún eje
3. Borrar dimensiones que no se usen
1.
tensor5 = np.array([[[[1, 2],[3, 4]], [[5, 6],[7, 8]]], [[[1, 2],[3,
4]], [[5, 6],[7, 8]]]], ndmin = 5)
print(tensor5, tensor5.ndim)
[[[[[1 2]
[3 4]]

[[5 6]
[7 8]]]

[[[1 2]
[3 4]]

[[5 6]
[7 8]]]]] 5
1.
expand5 = np.expand_dims(tensor5, axis=1)
print(expand5, expand5.ndim)
[[[[[[1 2]
[3 4]]

[[5 6]
[7 8]]]
 [[[1 2]
[3 4]]

[[5 6]
[7 8]]]]]] 6
1.
print(expand5, expand5.ndim)
reduced5 = np.squeeze(expand5)
print(reduced5, reduced5.ndim)
[[[[[[1 2]
[3 4]]

[[5 6]
[7 8]]]

[[[1 2]
[3 4]]

[[5 6]
[7 8]]]]]] 6
[[[[1 2]
[3 4]]

[[5 6]
[7 8]]]

[[[1 2]
[3 4]]

[[5 6]
[7 8]]]] 4

Creando Arrays
1 ✅ np.arange  (Start,Ens,Steps) → es como el list( range(0,10)) pero como arrange
2 ✅ np.zeros(n)
3 ✅ np.ones(n)
4 ✅ np.linspace(Start, End, Cant n de Start a End)
5 ✅ np.eye(n) ·· Matriz identidad
Arrays con numeros randoms
☑️np.random.rand(Filas,Columnas,  mas dimensiones  ) ·· Ambos con numeros randoms
☑️np.random.randint(Start, End,  Dimensiones) ·· N random entre Start y End y tupla dims

🟦🔹Shape y Reshape
Shape me indica la forma del arreglo
Reshape transforma el arreglo mientras se mantengan los elementos.
arr = np.random.randint(1,10,(3,2))
arr.shape
----> (3, 2)
arr
----> array([[4, 2],
[4, 8],
[4, 3]])
arr.reshape(1,6)
----> array([[4, 2, 4, 8, 4, 3]])
arr.reshape(2,3)
----> array([[4, 2, 4],
[8, 4, 3]])
np.reshape(arr,(1,6))
----> array([[4, 2, 4, 8, 4, 3]])
Se puede hacer un reshape como lo haría C.
np.reshape(arr,(2,3), 'C')
----> array([[4, 2, 4],
[8, 4, 3]])
También se puede hacer reshape a como lo haría Fortran.
np.reshape(arr,(2,3), 'F')
----> array([[4, 4, 8],
[4, 2, 3]])
Además existe la opción de hacer reshape según como esté optimizado nuestro computador.
En este caso es como en C.
np.reshape(arr,(2,3), 'A')
----> array([[4, 2, 4],
[8, 4, 3]])
Reto
Crear un array de cualquier dimesnión y cambiar sus dimensiones
Intentar cambiar el array de forma que no respete la estructura original
1.

array_original = np.random.randint(0,10, (3,3))

array_original
----> array([[5, 2, 6],
[6, 3, 6],
[6, 2, 8]])
array_original.reshape(1,9)
----> array([[5, 2, 6, 6, 3, 6, 6, 2, 8]])
1.
array_original.reshape(2,4)
----------------------------------------------------------------------
-----
ValueError Traceback (most recent call
last)
<ipython-input-126-cdad9318378a> in <module>()
----> 1 array_original.reshape(2,4)

ValueError: cannot reshape array of size 9 into shape (2,4)

Una forma de ver lo que hace el Reshape según el argumento “C” o “F” es:
 Cuando apilamos los valores a través de Fortran, apilamos mediante columnas:

Cuando apilamos los valores mediante el lenguaje C, apilamos mediante filas:

No puedes cambiar la "forma" a la "forma" original del array, si tienes un (3,3) no lo puedes pasar
a (4,2).

No respeta los 9 elementos del array original

RETO SHAPE Y RESHAPE

#1 Crear un tensor / array con cualq dimensionalidad

#2 Intercambiar valores de array

#3 Crear un valor que no respete los valores originales

print('Generando la matriz...')

arr_reto = np.random.randint(1,100,(4,6))

print(f'La matriz es esta\n{arr_reto}\ntiene {arr_reto.ndim}')

print()
print('Intercambiando las dimensiones + ajuste dimensiones')

print('A')

arr_reto_dims = np.squeeze(arr_reto.reshape(1,24)) #Concatenando Squeeze con el reshape

print(f'La matriz es esta\n{arr_reto_dims}\ntiene {arr_reto_dims.ndim}')

print()

print('B')

arr_reto_dims = np.squeeze(arr_reto.reshape(8,3)) #Concatenando Squeeze con el reshape

print(f'La matriz es esta\n{arr_reto_dims}\ntiene {arr_reto_dims.ndim}')

print()

print('Generando un fallo intencional por incoherencia de dimensiones')

print('arr_reto.reshape(4,10) --> le paso 40 elementos y son 24')

OTRO EJEMPLO DE LAS NOTAS

arr = np.random.randint(1,10,(4,3))

# np.reshape(objeto_NumPy,(filas,columnas))

print("Este es el Array original 4X3: ","\n",arr,"\n")

arr_tipo_c = np.reshape(arr,(3,4),"C")

print("el objeto modificado 3X4 de forma del lenguje C es:","\n",arr_tipo_c,"\n")

arr_tipo_f = np.reshape(arr,(3,4),"F")
print("el objeto modificado 3X4 de forma del lenguje Fortran es:","\n",arr_tipo_f,"\n")

arr_tipo_optimizacion = np.reshape(arr,(3,4),"A")

print("el objeto modificado 3X4 optimizado es:","\n",arr_tipo_optimizacion,"\n")

RETO CUMPLIDO!

 Crear un array de cualquier dimension y cambie sus dimensiones

array = np.random.randint(0,100,(2,6))
array
----> array([[10, 90, 33, 94, 24, 4],
[90, 39, 67, 46, 53, 45]])

array.reshape(4,3)
----> array([[10, 90, 33],
[94, 24, 4],
[90, 39, 67],
[46, 53, 45]])

array.reshape(3,4)
----> array([[10, 90, 33, 94],
[24, 4, 90, 39],
[67, 46, 53, 45]])

-Cambie las dimensiones del array de manera que sobrepase el numero de elementos que
contiene

array.reshape(4,4)
-----> ValueError: cannot reshape array of size 12 into shape (4,4)

🧮Funciones principales de NumPy

arr = np.random.randint(1, 20, 10)
matriz = arr.reshape(2,5)
matriz
----> array([[18, 8, 3, 11, 1],
[15, 10, 13, 9, 15]])
arr
----> array([18, 8, 3, 11, 1, 15, 10, 13, 9, 15])
arr.max() ----> 18
matriz.max() ----> 18
Podemos regresar los máximos de cada fila o columna especificando el eje.
matriz.max(1) ----> array([18, 15])
matriz.max(0) ---->array([18, 10, 13, 11, 15])
Tambien tenemos .argmax() que nos devuelve la posición del elemento
arr.argmax() ----> 0
matriz.argmax(0) ----> array([0, 1, 1, 0, 1])
De forma análoga tenemos .min()
arr.min() ----> 1
arr.argmin() ----> 4
matriz.min(0) ----> array([15, 8, 3, 9, 1])
matriz.argmin(1) ----> array([4, 3])
Podemos saber la diferencia de valor más bajo con el más alto.
arr.ptp() # 18 - 1 ----> 17
matriz.ptp(0) ----> array([ 3, 2, 10, 2, 14])
Para hacer análisis estádistico se tienen la siguientes funciones.
Ordenar los elementos:
arr.sort() ----> array([1, 3, 8, 9,10, 11,13, 15,15,18])
Obtener un percentil:
np.percentile(arr, 0) ----> 1.0
Mediana:
np.median(arr) ----> 10.5
Desviación estándar:
np.std(arr) ----> 5.080354
Varianza:
np.var(arr) ----> 25.81000
Promedio
np.mean(arr) ----> 10.3
Lo mismo aplica para las matrices.
np.median(matriz, 1) ----> array([ 8., 15.])
Se pueden unir dos arrays por medio de la concatenación
a = np.array([[1,2], [3,4]])
b= np.array([5, 6])
np.concatenate((a,b), axis = 0)
----------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-213-97c6fb2c6837> in <module>()
----> 1 np.concatenate((a,b), axis = 0)

<__array_function__ internals> in concatenate(*args, **kwargs)

ValueError: all the input arrays must have same number of dimensions,
but the array at index 0 has 2 dimension(s) and the array at index 1
has 1 dimension(s)
El error anterior es debido a a tiene 2 dimensiones mientras que b tiene 1.
print(a.ndim) ----> 2
b.ndim ----> 1
b = np.expand_dims(b, axis = 0)
np.concatenate((a,b), axis = 0)
----> array([[1, 2],
[3, 4],
[5, 6]])
De igual forma podemos agregarlo en el otro eje
np.concatenate((a,b), axis = 1)
-----------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-217-3ae7237876ab> in <module>()
1 # De igual forma podemos agregarlo en el otro eje
----> 2 np.concatenate((a,b), axis = 1)

<__array_function__ internals> in concatenate(*args, **kwargs)

ValueError: all the input array dimensions for the concatenation axis
must match exactly, but along dimension 0, the array at index 0 has
size 2 and the array at index 1 has size 1
Como b es una fila y no una columna, no se puede concatenar a menos que se aplique la
transpuesta.
np.concatenate((a,b.T), axis = 1)
----> array([[1, 2, 5],
[3, 4, 6]])