NumPy Array

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]])

Mi aporte
Una matriz de mas dimensiones(específicamente de 3 dimensiones) se pueden realizar las mismas operaciones, la única diferencia es que se debe agregar una “,” extra debido a que hay una dimensión nueva. El sistema es el mismo que la matriz, si se entiende como manejar los datos de una matriz normal, será sencillo comprenderlo de mas dimensiones

Vi a muchas personas con dudas sobre cómo hacer 1 matriz de 3 dimensiones, así qué cree un tutorial para explicarlo detalladamente, espero que sirva.

👾

En NumPy y Pandas existen varías maneras de acceder a los valores de un array:

1. Indexing: un escalar con la posición del valor que quieres obtener.

vector = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
vector[0] #Retornará 1

1. Slicing: dos números [start:stop] o tres números [start:stop:step] indicando desde y hasta que posición deseas obtener tus valores. El intervalo entre ellos (step) es opcional.

vector = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
vector[0:5] #Retornará [1, 2, 3, 4, 5]
# El primer valor del slice (0) es inclusivo, el segundo (5) es exclusivo por lo tanto el último elemento será el de index 4.

1. Masking: una condición que evaluará algunos valores como True y otros como False devolviendo aquellos valores que se consideren True.

vector = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
vector[vector > 5] #Retornará [6, 7, 8, 9] 

1. Fancy Indexing: consiste básicamente en pasar una lista de escalares indicando cada uno de ellos una posición distinta de elementos que quieres obtener.

vector = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
vector[[0, -1] #Retornará [1, 9] 

Mi matriz 3D:

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

Operaciones con esta matriz

matrix3D[0,0,0] 
# Out: 1

matriz 0 (la de adelante), primera fila, primera columna

matrix3D[:,0,0]
# Out: array([1, 5])

Todas las matrices, primera fila, primera columna

Esto es lo que entendí como matriz de tres dimensiones y me imagino que esta correcto:

D3Matriz = [[10,11,12],[13,14,15],[16,17,18]]
D3Matriz = np.array(D3Matriz)
D3Matriz

Comparto la practica que realice de la clase en Deepnote:
[https://deepnote.com/project/El-arrayipynb-rWjkZyxVSZW5rqA7-H6lAw/%2Fnotebook.ipynb]

Hola!
Les dejo el Resumen explicado del código, espero les sirva 😃
les dejo el link del nootbook explicado también (estoy poniendo en práctica la recomendación de tomar apuntes/notas en el mismo código)

import numpy as np

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

np.array(lista1)
# Esto permite llevar esa lista (python) a NumPy
# Puedo guardarlo en una variable

arr_01= np.array(lista1)
arr_01

#Puedo construir matrices y tb guardarlas en variables al pasarlas a NumPy
matriz= [[1,2,3],[4,5,6],[7,8,9]]

matriz = np.array(matriz)
matriz

#Acceder a un valor a través de su "index"
arr_01[2]

#Ahora con las matrices
matriz[0]
#En este caso accedo al array dentro de esa matriz

#más especifico
matriz[0,2] #[fila, columna]

#Acceder a más de un valor (slicing)
arr_01[0:3] #Esto quiere decir: desde la posición o índex 0 hasta la posición 3 (esta última no la toma)

arr_01[:3] #extrae desde el comienzo (0) hasta antes del index 3


arr_01[3:] #Extrae desde el indice 3 hasta el final del array

arr_01[::3] #Extrae el primer valor y los siguientes cada 3, es decir, se salta 2 y extrae el tercero

arr_01[-1] #toma el primer valor, pero desde final

arr_01[-3:] #toma los valores desde el tercero antes final, hasta el final del array

#Ahora con matriz
matriz

matriz[1:] #Sigue el mismo funcionamiento de los array (desde el array de index 1 hasta el último array dentro de la matriz)

matriz[1:,0:2] #Puedo dar inidcaciones para las columnas y para las filas (por separado)

mi intento de matriz 3d y busqueda del numero en el medio

## MATRIZ 3D

matriz_3D = [[1,2,3],[4,5,6],[7,8,9],[10,11,12],[13,14,15],[16,17,18]]

matriz_3D = np.array(matriz_3D)

matriz_3D

array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12],
       [13, 14, 15],
       [16, 17, 18]])

matriz_3D[2:3,1:2]

array([[8]])

Para que puedan ingresar a la documentación de numpy
https://numpy.org/doc/stable/

Para acceder a una matriz por fila y columna también se puede hacer poniendo la fila en un primer par de corchetes y la columna en un segundo par de corchetes.

Por ej así:

matriz[0][2] 

Hasta aquí la unica diferencia con las listas es que para una matriz puedes usar la notación
´´´
matriz[i,j]
´´´
mietras que con listasdebes hacer
´´´
matriz[i][j]
´´´
todo lo demás se puede hacer con listas, inténtalo. Pero numpy tiene mas utilidades que seguro veremos en clases más adelante.

Aca mi practica de un array de 3 dimensiones:

#NeverStopLearning

El array XD

Resumen de clase

# Numpy Array

Importar el módulo numpy
"""

import numpy as np

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


"""Convertir una lista de python a un obejeto de array




"""

array = np.array(lista)

type(array)

matriz = [[1,2,3],[4,5,6],[7,8,9]]
matriz = np.array(matriz)
matriz

"""Indexado de array -> matriz[posición filas,posición columnas] , tener en cuenta que las posiciones se referencian inciando en 0"""

array[0] + array[5]

matriz[0,2]

"""SLICING EN MATRICES -> Acceder a varios valores matriz[start:end] la posición final no es considerada """

array[0:3]

array[2:]

#Podemos indicar los saltos con el tercer parámetro
array[::3]

# Cuando el valor es negativo va desde el final al inicial 
array[-3]

matriz[1:]

# Matriz[Filas Inicio: Fila Fin  , Columna Inicio: Columna Fin]
matriz[1:,1:]

• Array: Es la estructura central de Numpy, representa datos de una manera estructurada, es indexado y tiene acceso a uno o muchos elementos.

Creo que hice una matriz de 4 dimensiones.

matrix = [[[[1,2,3], [4,5,6]], [[7,8,9], [10,11,12]], [[13, 14, 15],[16,17,18]]], [[[1,2,3], [4,5,6]], [[7,8,9], [10,11,12]], [[13, 14, 15],[16,17,18]]]]
mat4 = np.array(matrix)
mat4

array([[[[ 1,  2,  3],
         [ 4,  5,  6]],

        [[ 7,  8,  9],
         [10, 11, 12]],

        [[13, 14, 15],
         [16, 17, 18]]],


       [[[ 1,  2,  3],
         [ 4,  5,  6]],

        [[ 7,  8,  9],
         [10, 11, 12]],

        [[13, 14, 15],
         [16, 17, 18]]]])

Saludos.

Acá les dejo una manita para pilotearla con la matriz 3D enlace

Hola, por acá mi aporte, aplicando slicing para llegar a las dos filas de en medio y a la última columna:

matriz = [[24,25,26],[45,46,47],[75,76,77],[85,86,87]]
matriz = np.array(matriz)

matriz[1:3]
matriz[1:3:2]

Matriz NUMPY de 3x3x3 (no uso el 10 y 20 como elementos apróposito para se puedan comparar los elementos entre matrices).

mtrz_3D =np.array([[[1,2,3], [4,5,6], [7,8,9]],[[11,12,13], [14,15,16],[17,18,19]],[[21,22,23], [24,25,26],[27,28,29]]])
mtrz_3D

array([[[ 1, 2, 3],
[ 4, 5, 6],
[ 7, 8, 9]],
[[11, 12, 13],
[14, 15, 16],
[17, 18, 19]],
[[21, 22, 23],
[24, 25, 26],
[27, 28, 29]]])

Elementos de la segunda matriz.

mtrz_3D[1]  

array([[11, 12, 13],
[14, 15, 16],
[17, 18, 19]])

Elementos de las terceras filas de la segunda y tercera matriz.

mtrz_3D[1:,2] 

array([[17, 18, 19],
[27, 28, 29]])

Elementos que pertenecen a las primeras columnas, de las primeras y segundas filas, de la segunda y tercera matriz.

mtrz_3D[1:,:2,0] 

array([[11, 14],
[21, 24]])

Pude hacer lo gracias a un comentario del video GRACIAS!

import numpy as np
import pandas as pd

#haciendo una matriz de tres dimensiones
D3Matriz = [[[10,11,12],
            [13,14,15]],

            [[16,17,18],
            [19,20,21]],

            [[22,23,24],
            [25,26,27]]]
matriz = np.array(D3Matriz)

matriz[2,0:2,1]

Mi array de 3 dimensiones 😄

matrix = [[0.1, 0.2, 0.3, 0.4], [1, 2, 3, 4], [10, 20, 30, 40], [100, 200, 300, 400]]
matrix = np.array(matrix)
matrix[0: 2, 2: 4] * 2

Para seleccionar un objeto específicamente de un array de más dimensiones que 1 se lo hacer con la coma

Ejemplo:

matriz2 = [[[1,2,3],[1,2,3]],[[1,2,3],[1,2,3]]]
matriz2 = np.array(matriz2)
matriz2

matriz2[0,0,1]

Me retorna: 2.

tensor = [[[1,2,3],[4,5,6]],[[7,8,9],[1,2,3]],[[4,5,6],[7,8,9]]]
tensor = np.array(tensor)

tensor[::-1,::-1,::-1]

Mi aporte:

#matriz 3D
matriz3D = [[[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]]]

#volvemos la matriz un array de Numpy
matriz3D = np.array(matriz3D)
>>>  [[[ 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]]]

#accede a un elemento especifico de la matriz
matriz3D[2,0,0]
>>>  19
matriz3D[0,1]
>>>  [4 5 6]

#Slicing
#toma las dos primeras matrices, invierte la posicion de los elementos
#y solamente selecciona las dos primeras columnas de cada matriz
matriz3D[:2,::-1,:2]
>>>  array([[[ 7,  8],
             [ 4,  5],
             [ 1,  2]],

            [[16, 17],
             [13, 14],
             [10, 11]]])

Slicing aka: “Python Matlab Library”

Se puede crear objetos de múltiples dimensiones. En este caso para no tener que escribir todos los números se pueden hacer listas con rangos!
matriz = [list(range(10)),list(range(10,20)), list(range(20,30))]
matriz = np.array(matriz)
matriz

mtz3D = [
          [
	#profundidad  1	
            ['02A1','02B1','02C1'],
            ['02A2','02B2','02C2'],
            ['02A3','02B3','02C3']  
          ],
          [
	#profundidad  2
            ['06A1','06B1','06C1'],
            ['06A2','06B2','06C2'],
            ['06A3','06B3','06C3']
          ],
          [
	#profundidad  3
            ['08A1','08B1','08C1'],
            ['08A2','08B2','08C2'],
            ['08A3','08B3','08C3']
          ]
        ]
mtz3D = np.array(mtz3D)

En este Slicing de una matriz de tres dimensiones, la profundidad mostrara la posición 2 y la columna 3.

mtz3D[1:2,::,2]

Resultados

array([['06C1', '06C2', '06C3']], dtype='<U4')

Slicing hace referencia a la extracción de uno o varios elementos de un array

Utilizando Numpy, saque los valores de X, Y para calcular Euclidean distance.

import numpy as np

p = [[0,11], [-7,1], [-5,-3]] 
print(type(p))
p = np.array(p)

a = (p[0:,0:1]) 
b = (p[0:,1:2])

print(p)
print(type(p))
print(f"\n")

print (f'a: {a} \n \n b: {b}')

dist =np.linalg.norm(a-b)
print(dist)```

NumPy Array Características:

• Principal objeto con el que trabaja la librería.

• Deja un array de forma ordenada y fácil de acceder.

• Capacidad de tener millones de datos accediendo a ellos de forma sencilla(Indexado).

cona matriz de 3 se puede acceder a un montón de info!

Hola, conteo con slicing.

.

Reto:
En lugar de usar slicing iteré en la matriz de 3 dimensiones con un eje z de 2:
El output son todas las columnas en el eje z o altura de mi matriz 3d

import numpy as np

matriz3d = [
    [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
    [[11, 12, 13], [14, 15, 16], [17, 18, 19]]
]

matriz3d = np.array(matriz3d)


def ejeZMatriz(matriz, posX, posY):
    return matriz[0, posX, posY], matriz[1, posX, posY]

def main():
    for i in range(3):
        for j in range(3):
            print(ejeZMatriz(matriz3d, i, j))

if __name__ == '__main__':
    main()

Si el slicing se realiza sobre un a matriz de 3 dimensiones el orden es diferente como se muestra a continuación segun mi perspectiva 👽.

#Creamos x = 2 rows, y = 4 cols, z = 2
a_3d_array = np.array([[[1,2,3,4],[2,3,4,5]],[[43,21,56,7],[2,1,3,5]]])

#Slicing a_3d_array
#a_3d_array[0] ->[[1,2,3,4],[2,3,4,5]] Profundidad o Eje Z
#a_3d_array[0,1] -> [2,3,4,5] Altura Eje Y
#a_3d_array[0,1,3] -> 5 Ancho Eje X

a_3d_array[0:,0:,2:]
# 1. Tomar ambas matrices de 2X4 Eje Z
# 2. Tomar tanto rows como cols de ambas matrices Eje Z
# 3. Tomar de la col3 a col4 de ambas matrices Eje X

#Output
array([[[ 3,  4],
        [ 4,  5]],

       [[56,  7],
        [ 3,  5]]])