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.

👾

Me genero un poco de curiosidad del porque debería de convertir de “matriz” a una “ndarray”, y en medio de mi investigación para resolver mi duda encontré una respuesta que me dejo bastante satisfecho y me gustaría compartirla con ustedes.

La principal diferencia entre convertir una matriz a un ndarray de NumPy y no convertirla es que los ndarray tienen métodos y atributos adicionales que NO están disponibles en las listas regulares de Python. Esto hace que sea más fácil y eficiente realizar cálculos y operaciones matemáticas con arrays.

Por ejemplo, los ndarray tienen métodos para realizar operaciones como suma, multiplicación y transposición, que pueden ser complicados de implementar utilizando solo listas regulares de Python. Además, los ndarray tienen un tamaño fijo, lo que los hace más eficientes en términos de tiempo y memoria que las listas regulares.

Otra ventaja de los ndarray es que pueden tener más de una dimensión, mientras que las listas regulares solo tienen una dimensión. Esto significa que los ndarray se pueden usar para representar matrices, imágenes y otros datos multidimensionales, mientras que las listas regulares no son adecuadas para estos usos.

En resumen, convertir una matriz a un ndarray de NumPy tiene muchas ventajas en términos de funcionalidad, eficiencia y versatilidad. Por lo tanto, es una buena práctica convertir matrices a ndarray en la mayoría de los casos.

Aquí está un ejemplo de código que ilustra la diferencia entre una matriz y un ndarray de NumPy:

import  numpy as np

# Creamos una matriz usando una lista de listas (como en el ejemplo del tutor):
matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Luego, convertimos esta matriz a un ndarray de NumPy:

ndarray = np.array(matriz)

# Ahora, podemos realizar operaciones matemáticas con el ndarray de manera muy sencilla.
# Por ejemplo, aquí multiplicamos cada elemento del ndarray por 2:

ndarray = ndarray * 2

# La salida seria esta:

array([[ 2,  4,  6],
       [ 8, 10, 12],
       [14, 16, 18]])

Por otro lado, si intentamos multiplicar cada elemento de la matriz por 2, sin utilizar el ndarray de NumPy tendríamos que implementar un bucle para recorrer cada elemento y multiplicarlo por 2:

for i in range(len(matriz)):
    for j in range(len(matriz[i])):
        matriz[i][j] *= 2

Como puedes ver, la sintaxis es más compleja y requiere más líneas de código que con un ndarray de NumPy. Además, las operaciones con ndarray son más eficientes en términos de tiempo y memoria.

Espero les sea de utilidad esta información. 😄

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

Aquí dejo mi aporte relacionado con la selección de un elemento de una matriz de 3 dimensiones.

import numpy as np

# Array inicial con números del 1 al 27.
x = np.array([i for i in range(1,28)]) 

# Creación de matriz 3x3 reordenando la lista inicial x.
matriz_3x3 = x.reshape(3,3,3) 

# Output
array([[[ 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]]])

# Selección del número 17
matriz_3x3[1,2,1]

#Output: 17

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.

Slicing

La operación de slicing consiste en acceder a la vez a varios elementos de una secuencia mediante los índices. De forma genérica, en una secuencia en Python la sintaxis para realizar la operación es secuencia[i:j], accediendo a los elementos (i,j). La diferenia principal entre las secuencias es el objeto que devuelve la operación de Slicing. En particular, la gran diferencia reside en los arrays de numpy, ya que estos devuelven una vista de los elementos del array original.

Podemos hacer slice entre índices de la siguiente forma: [start:end]

Y también podemos definir los pasos, así: [start:end:step]
|
Fuente: Algoritmos Genéticos con Python.

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

Indexación

La indexación de matrices se utiliza para acceder a elementos especificando sus índices dentro del array.

arrays: En este tipo de dato todos los elementos tienen que ser del mismo tipo. El tipo se indica mediante el atributo typecode. Están definidas en el módulo nativo de array. El índice de los elementos es numérico y empieza en cero.

ndarray: Son tipos de datos tipo vector definifas en la librería numpy. En estas secuencias todos los elementos deben ser del mismo tipo. El tipo de los objetos se define con el atributo dtype. Si este parámetro no se especifica, por defecto considera el tipo flotante. El índice de los elementos es numérico y empieza en cero.
|
Fuente: Algoritmos Genéticos con Python.

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

Hey, este curso lo imparte el profe desde Google colab, pero vengo del futuro y les recomiendo mucho seguir usando Jupyter Notebooks, pero desde su editor de codigo ya que… si son fan se tomar notas dentro de su notebook despúes de añadir más y más cosas su Jupyther se puede alentar desde Colab, si depsues quieren hacerle una copia, siempre puden subirlo a colab, pero creo que la mejor idea si estás aprendiendo es hacerlo directamente desde tu editor de codigo, yo uso como la mayoria Vs Code, pero en cualquiera se puede, saludos 💚

Index / Indexado

En NumPy, el indexado se refiere a la forma en que se accede a los elementos individuales de un array. Los arrays en NumPy pueden ser indexados de diferentes maneras, incluyendo indexación por enteros, por rebanadas (slices) y por arrays booleanos.

La indexación por enteros implica proporcionar un índice entero o un conjunto de índices enteros para acceder a un elemento específico o un subconjunto de elementos en un array. Por ejemplo, para acceder al segundo elemento de un array unidimensional, se puede usar el índice 1:

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr[1]) # Imprime 2

La indexación por rebanadas implica proporcionar un objeto de rebanada que especifica un rango de elementos a acceder. Por ejemplo, para acceder a los elementos del segundo al cuarto en un array unidimensional, se puede usar la rebanada arr[1:4]:

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr[1:4]) # Imprime [2 3 4]

La indexación por arrays booleanos implica proporcionar un array de valores booleanos que indican qué elementos deben ser accedidos. Por ejemplo, para acceder a los elementos de un array que son mayores que 2, se puede usar la indexación booleana arr[arr > 2]:

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr[arr > 2]) # Imprime [3 4 5]

Esto me ayudo a entender el

Slicing con Matrices 😵‍💫

matriz[inicio : fin : salto , inicio : fin : salto]

Es decir:

Se aplica un slicing por cada dimensión de la matriz

matriz[ slicing_Filas, Slicing_Columnas ]

Para llegar al numero 8
dimension3 = [[[1,2],[3,4]], [[5,6], [7,8]], [[9,10], [11,12]]]
dimension3 = np.array(dimension3)
print(dimension3[1,1,1])

Este es mi aporte.
Lo hice usando list comprenhension para practicar lo aprendido en los otros cursos.

<import numpy as np

def numpy_array():
  # 3D MATRIX WITH LIST COMPREHENSION
    array_b1: list[int] =    [[[x for x in range(10) ] ,  [x**2 for x in range(10) ],[x*3 for x in range(10) ]]
                            ,[[x*2 for x in range(10) ] , [x**2 for x in range(10) ],[x*3 for x in range(10) ]]
                            ,[[x for x in range(10) ] ,  [x**2 for x in range(10) ],[x*3 for x in range(10) ]]]
    arr=np.array(array_b1)  
    print(array_b1)
    print(arr[:,:,:5])
 
    return

if __name__ == '__main__':
    numpy_array()
> 

NumPy

• NumPy trabaja principalmente con arrays, que es la estructura central de NumPy.
• Un array representa los datos de manera estructurada mediante índices (indexada), así podemos identificar fácilmente cada objeto del array
• Los podemos declarar desde una lista; ejemplo

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

• Para acceder a los valores del array, basta con colocar las coordenadas de este valor, por ejemplo en el caso de una matriz my_matrix[a,b] donde a es la fila (inicia en 0) de la matriz y b representa la columna de la matriz.
• También podemos seleccionar parte del array con slice notatio, de manera similar a las listas, por ejemplo:
  my_vect(a:b:c) donde a es el valor inicial, b el valor final (no está incluido) y c representa el salto de valores; este valor es opcional

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/

Información resumida de esta clase
#EstudiantesDePlatzi

• El array de Numpy es el principal objeto que tenemos en la librería

• Este objeto me ayuda a ordenar mis datos de una manera estructurada

• Los arrays a nivel de indexado, empiezan desde “0”

• Cuando navego en la matriz el primer valor es de filas y el segundo de columnas

• El Slicing me ayuda a traer varios elementos de mi array o matriz, para esto utilizo los dos puntos

Matriz 3D y slicing:

Matriz 3D:
 [[[1 2 3]
  [4 5 6]
  [7 8 9]]

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

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

... Haciendo Slicng

matriz3d[0,0]:
 [1 2 3]

 matriz3d[0,:,:]:
 [[1 2 3]
 [4 5 6]
 [7 8 9]]

 matriz3d[:,2,:]:
 [[7 8 9]
 [1 2 3]
 [7 8 9]]

 matriz3d[:,0,:]:
 [[1 2 3]
 [7 8 9]
 [4 5 6]]

 matriz3d[:,:,0]:
 [[1 4 7]
 [7 4 1]
 [4 1 7]]

 matriz3d[:,:,2]:
 [[3 6 9]
 [9 6 3]
 [6 3 9]]

Mis apuntes #3 (Notion + Notas de Cornell)

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)

La extracciones de valor de NumPy son practicamente las mismas que en list; pero la diferencia se empieza a notar en matrices de dos dimensiones en adelante.

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

Es interesante saber como funciona slice con arrays usando numpy. La verdad si hace el procedimiento mas sencillo. Es lo bueno de usar estas librerias te ahorran un monton de problemas. Aqui esta mi reto:
![](

# Crear un numpy.ndarray unidimensional (vector)
#import numpy as np

VECTOR = np.array([1, 2, 3, 4, 5])

# Crear un numpy.ndarray bidimensional (matriz)
MATRIZ = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Crear un numpy.ndarray tridimensional (tensor)
TENSOR = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

# Imprimir los numpy.ndarray
print("Vector:")
print(VECTOR)

print("\nMatriz:")
print(MATRIZ)

print("\nTensor:")
print(TENSOR)

numpy.ndarray

Es un tipo de dato específico proporcionado por la biblioteca NumPy. ndarray significa “array multidimensional” en NumPy, y es una estructura de datos que representa matrices multidimensionales o tensores.
El tipo numpy.ndarray es extremadamente útil para realizar operaciones numéricas eficientes en matrices, ya que NumPy está optimizado para ejecutar operaciones vectorizadas, lo que significa que puede realizar operaciones en matrices enteras de una vez, sin necesidad de bucles explícitos.

De que me sirven los arrays en python?
Los arrays en Python, especialmente cuando se trabajan con la biblioteca NumPy, ofrecen varias ventajas y funcionalidades que los hacen muy útiles en diversas aplicaciones. Aquí hay algunas razones para usar arrays en Python:

1. Eficiencia en Operaciones Numéricas:

   • NumPy está optimizado para operaciones numéricas y proporciona implementaciones eficientes de operaciones matriciales y de álgebra lineal. Esto mejora significativamente la velocidad de cálculos numéricos en comparación con las listas estándar de Python.

2. Manipulación Eficiente de Datos:

   • Los arrays permiten la manipulación eficiente de grandes conjuntos de datos numéricos. Puedes realizar operaciones a nivel de array, evitando bucles explícitos y mejorando la velocidad de ejecución.

3. Indexación y Slicing Potentes:

   • NumPy proporciona una potente funcionalidad de indexación y slicing, lo que facilita la extracción y manipulación de porciones específicas de datos en arrays multidimensionales.

4. Soporte para Elementos Homogéneos:

   • A diferencia de las listas de Python, los arrays de NumPy deben contener elementos del mismo tipo, lo que permite una implementación más eficiente y rápida de las operaciones.

5. Operaciones Matemáticas y Estadísticas:

   • NumPy ofrece una amplia gama de funciones matemáticas y estadísticas incorporadas que se pueden aplicar a arrays, facilitando el análisis de datos y la implementación de algoritmos.

6. Integración con Bibliotecas Científicas:

   • NumPy se utiliza como base para muchas otras bibliotecas científicas y de análisis de datos en Python, como SciPy, pandas y scikit-learn. Esto proporciona una integración fluida y una interoperabilidad entre diferentes herramientas.

7. Programación Vectorizada:

   • NumPy fomenta la programación vectorizada, donde las operaciones se aplican a todo el array de una vez, evitando la necesidad de bucles explícitos y mejorando la legibilidad del código.

8. Soporte para Broadcasting:

   • NumPy tiene un poderoso mecanismo de broadcasting que permite operaciones eficientes entre arrays de diferentes formas y tamaños sin la necesidad de realizar copias de datos.

9. Manipulación de Imágenes y Señales:

   • Los arrays son fundamentales en el procesamiento de imágenes y señales, ya que permiten representar eficientemente datos bidimensionales o tridimensionales.

10. Implementación de Modelos Numéricos y Simulaciones:

    • En ciencia e ingeniería, los arrays son esenciales para la implementación de modelos numéricos y simulaciones, ya que permiten representar y manipular datos de manera eficiente.

En resumen, los arrays en Python, especialmente con la biblioteca NumPy, son una herramienta poderosa y eficiente para trabajar con datos numéricos, realizar cálculos científicos y facilitar el desarrollo de aplicaciones en diversos campos.

En NumPy, el término “array” se refiere a un objeto multidimensional que contiene elementos del mismo tipo. Estos arrays pueden tener una o más dimensiones y proporcionan una forma eficiente de almacenar y manipular datos numéricos en Python. NumPy es una biblioteca fundamental para computación científica en Python y proporciona funciones y operaciones optimizadas para trabajar con arrays.

✅

Comparto mi archivo de Jupyter Notebook hecho en VSC y compartido desde Google Colab, con lo aprendido en la clase.
.

Este es mi aporte al reto:

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

b = a.reshape(3,3)
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])

Quiero saber cuál es el número ubicado en la tercera fila(posición 2 del array b que reordené en una matriz de 3 x 3) ubicado en la primera columna de dicha fila:

b[2:,0:1]

Resultado:
array([[6]])

Ai quisiera conocer todos los datos de esa fila:
b[2:,0:3]

Resultado:
array([[6, 7, 8]])

Hola, aquí mis resultados al utilizar un tensor tridimensional

Podemos imaginar a un tensor tridimensional como dos matrices bidimensionales colocadas una sobre la otra y a cada una de estas matrices bidimensionales le llamamos “capa”

0	matrix = [
1	    [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
2	    [['A','B','C'], ['D','E','F'], ['G','H','I']],
3	]
4	matrix = np.array(matrix)
5	print(matrix[1,2,::-1])
6	
7	# Resultado ['I' 'H' 'G']

En la línea 5, con el valor 1, estamos accediendo a la capa 1 del tensor (recordemos que el índice de capas comienza en cero) es decir a la que contiene letras.

matrix[ 1 , 2, ::-1])

con el valor 2, estamos accediendo dentro de la capa 1 a la fila con índice 2 (la última en este caso) [‘G’,‘H’,‘I’].

matrix[ 1, 2 , ::-1])

con el valor ::-1, y al ser el -1 el único valor dentro del slicing obtengo el array invertido.

matrix[ 1, 2 , ::-1])

Va mi aporte para que se entienda como manejar los slicing en arrays y matrices:

<code> import numpy as np

# armado de Array
lista = [1,2,3,4,5,6,7,8,9]
lista_arr = np.array(lista)
print("Asi se ve una lista:")
print(lista)
print ("")

print("Asi se ve un array:")
print(lista_arr)
print ("")
# armado de matriz
matriz = [[1,2,3],[4,5,6],[7,8,9]]
matriz = np.array(matriz)
print("Asi se ve un array:")
print(matriz)
print ("")

# manejo de array
print("Asi se operan array")
print(f'lista_arr[0] + lista_arr[5] = {lista_arr[0]} + {lista_arr[5]} = {lista_arr[0] + lista_arr[0]}')
print ("")

# manejo de matriz
print("Asi opero una matriz:")
print(f'matriz[0,1] + matriz [2,0] = {matriz[0,1]} + {matriz [2,0]} = {matriz[0,1] + matriz [2,0]}')
print("")

# slicing array ==> ":" para traer mas de un valor, ver ejemplos debajo:
print("Asi opera el Slicing")
print(f'Parte: lista_arr[0:3] = {lista_arr[0:3]}')
print(f'Cada 3 valores: lista_arr[::3] = {lista_arr[::3]}')
print(f'Invertir array: lista_arr[::-1] = {lista_arr[::-1]}')
print("")

# slicing matriz de 3 dimensiones
matriz3d = np.array([[[1,2,3],[4,5,6],[7,8,9]],[[10,11,12],[13,14,15],[16,17,18]]])
print(f'El tamaño de la matriz es de: {matriz3d.shape}')
print(matriz3d)
print("")
print("Slicing:")
print(f'Una matriz 2D: matriz3d[1] = \n {matriz3d[1]}')
print(f'Una linea de la matriz: matriz3d[1,2] = {matriz3d[1,2]}')
print(f'Un numero de la matriz: matriz3d[0,1,1] = {matriz3d[0,1,1]}')
print(f'Invierto matriz2D: matriz3d[::-1] = \n {matriz3d[::-1]}')

Se parece a un Left, Right o Mid

Matriz de nxnxn:

n = 3
vector1 = [i for i in range(n)]
vector2 = [vector1 for i in range(n)]
matriz = [vector2 for i in range(n) ]
matriz = np.array(matriz)
print(matriz)

Resultado:

[[[0 1 2]
  [0 1 2]
  [0 1 2]]

 [[0 1 2]
  [0 1 2]
  [0 1 2]]

 [[0 1 2]
  [0 1 2]
  [0 1 2]]]

Para acceder a diferentes dimensiones de un array es necesario separa por coma cada dimensión y si quiere todos, basta con colocar :
Lo hice así:
d3 = [ [[[1,2,3]]],[[[11,12,13]]] ]
npD3 = np.array(d3)
npD3.ndim
npD3[1:,:,:,:2]

En realidad una lista de ‘n’ elementos tiene una dimensión ‘n’.
En el vídeo menciona que es una dimensión pero creo que hay que ser certeros en la explicación.

Hola, si etas usando Google Colab y quieres cambiar el tema que tare por default, te reomiendo poner el “Dark” ya que hace más sencillo estar en esta interfaz
Para cambiarlo simplemente.

• Da click en el boton a un lado de tu foto (El engrane) y te aparecerá el sig menú, ahi simplemnete selecciona el tema deseado y listo, ya estas ready pa la guerra ;3
  ![](
  

2. NumPy Array

Array

• La estructura central de NumPy
• Representa datos de una manera estructurada
• Indexado
• Acceso a uno o a muchos elementos

El array

import numpy as np
lista = [1, 2, 3, 4, 5, 6,7,8,9]
lista
arr = np.array(lista)
type(arr)

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

arr[1] + arr[5]

matriz[0,2]

arr

arr[2:]

arr[-3:]

matriz

matriz[1:,0:2]

import numpy as np
a = np.array([1, 2, 3])
array([1, 2, 3])
Array
1
2
3

Para el tema del arreglo para acordarme siempre intento recordar que el lado izquierdo es inclusivo y derecho exclusivo.

Si no me equivoco, matriz de tres dimensiones:
.

Slicing

El slicing es una técnica de indexación en NumPy que permite acceder a subarrays de un array NumPy. La notación de slicing en NumPy es similar a la notación de slicing en Python y se utiliza para acceder a un rango de elementos de un array NumPy. La sintaxis general para slicing en NumPy es:

arr[inicio:fin:paso]

donde:

• arr es el array NumPy que se va a slice.
• inicio es el índice de inicio para el slice (inclusive).
• fin es el índice final para el slice (no inclusivo).
• paso es el tamaño del paso entre elementos.

Los argumentos inicio, fin y paso son opcionales. Si se omite el argumento inicio, se utiliza el índice 0 como valor predeterminado. Si se omite el argumento fin, se utiliza la longitud del array como valor predeterminado. Si se omite el argumento paso, se utiliza el valor 1 como valor predeterminado.

matriz_3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
matriz_3d

matriz_3d[1:,:,1:]

array([[[ 8, 9],
[11, 12]]])

Matriz de 3 dimensiones

En este ejemplo hemos creado una matriz de 3 dimensiones, que consiste en 3 capas, cada una de las cuales contiene 2 filas y 3 columnas.
Luego, hemos utilizado el slicing para seleccionar elementos individuales de la matriz y también para seleccionar rangos de elementos en las diferentes dimensiones de la matriz.
El slicing funciona de la misma manera que en los arreglos de una y dos dimensiones, utilizando la sintaxis start:stop:step
en cada dimensión de la matriz.

import numpy as np

# Creamos una matriz de 3 dimensiones
arr = np.array([
  [[1, 2, 3], [4, 5, 6]],
  [[7, 8, 9], [10, 11, 12]],
  [[13, 14, 15], [16, 17, 18]]
])

# Mostramos la matriz
print(arr)

# Seleccionamos el elemento en la posición [1, 0, 2]
print(arr[1, 0, 2])

# Seleccionamos la primera dimensión (capa) completa
print(arr[0, :, :])

# Seleccionamos la segunda dimensión (fila) completa
print(arr[:, 1, :])

# Seleccionamos la tercera dimensión (columna) completa
print(arr[:, :, 2])

# Seleccionamos un rango de elementos de la segunda dimensión (fila) y la tercera dimensión (columna)
print(arr[0, 0:2, 1:3])

La salida de este código será:

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

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

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

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

[[ 4  5  6]
 [10 11 12]
 [16 17 18]]

[[ 3  6]
 [ 9 12]
 [15 18]]

[[2 3]
 [5 6]]

El slicing es una técnica que se utiliza para seleccionar una parte específica de un arreglo o matriz NumPy.

Con el slicing, podemos seleccionar elementos individuales o rangos de elementos en una dimensión específica de un arreglo o matriz NumPy.

Para realizar el slicing en un arreglo o matriz NumPy, utilizamos el operador de corchetes [] y el formato start:stop:step, donde start es el índice de inicio, stop es el índice de finalización y step es el tamaño del paso.

import numpy as np

# Creamos un arreglo NumPy de 1 dimensión con 10 elementos
arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

# Seleccionamos el segundo elemento del arreglo
print(arr[1])

# Seleccionamos los elementos desde el segundo hasta el quinto
print(arr[1:5])

# Seleccionamos los elementos desde el segundo hasta el final
print(arr[1:])

# Seleccionamos los elementos desde el inicio hasta el quinto
print(arr[:5])

# Seleccionamos los elementos con saltos de dos en dos
print(arr[::2])

# Invertimos el orden del arreglo
print(arr[::-1])

La salida de este código será:

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

Matriz de tamaño 2x3x3 (Esto significa que tiene dos “capas” o “niveles”, cada una con 3 filas y 3 columnas):

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

Luego la envío a numpy:

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

Cada elemento de la matriz se puede acceder usando tres índices (capa(0 ó 1), fila(0, 1, ó 2), columna(0, 1 ó 2)):

matriz_3D[1,2,1]
>>17

Así mismo, se puede acceder a un arreglo de números, indicando el slicing para la capa, la fila y la columna, cada uno separado por una coma:

matriz_3D[0,1:3, 1:2]
>>array([[5],
       [8]])

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

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

   [[7, 8, 9],
    [4, 5, 6]]])

matriz[:,1:2,1:-1]

array([[[5]],

   [[5]]])

Aquí mi matriz de 3 X 3.

1. creación:

mi_matriz =[[[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]]]

1. Convertirlo a un objeto de tipo Numpy:

mi_matriz = np.array(mi_matriz)
print(mi_matriz) #Mostrando Matriz 3x3.

array([[[ 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]]])

1. Accediendo a los valores, por ejemplo al número 15.

print(mi_matriz[1, 1, 2])

15

Deben tener cuidado con cómo se maneja cada estructura de datos. El slicing en listas y arrays se comporta de forma muy diferente.
.
Ejemplo: Para listas

a = [1,2,3,4,5]
b = a[:]
c = a[2:]

b[1] = 100
c[1] = 100

print(a) #Devuelve [1, 2, 3, 4, 5]
print(b) #Devuelve [1, 100, 3, 4, 5]
print(c) #Devuelve [3, 100, 5]

print(id(a)) #Devuelve 2638545285440
print(id(b)) #Devuelve 2638545406400
print(id(c)) #Devuelve 2638545285632

Todo normal, cada nueva sublista creada por slicing tiene diferente ubicación de memoria y modificar uno no altera los demás. Nada nuevo.
.
Pero en los arrays (aume que ya importé numpy):

a = np.array([1,2,3,4,5])
b = a[:]
c = a[2:]
b[1]=100
c[1]=100

print(a) #Devuelve [1 100 3 100 5]
print(b) #Devuelve [1 100 3 100 5]
print(c) #Devuelve [3 100 5]

print(id(a)) #Devuelve 1724076733136
print(id(b)) #Devuelve 1724077075664
print(id(c)) #Devuelve 1724081973136 

Diferente ubicación en memoria, pero sorpresa, modificar “c” o “b”, también modifica a “a”, esto ocurre porque el subarreglo es una vista, diferente a una copia. Y modificará la referencia exacta del dato. El slicing [:], hace lo mismo que la función .view(), para crear copias que no modifican es con .copy() o con la sintaxis de slicing por doble corchete

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

matriz3[0]

array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])

matriz3[0,2]

array([7, 8, 9])

matriz3[0:2,0:2:]

array([[[2]],

   [[8]]])

Reto

Crear una matriz de 3 dimensiones y explicar:

• ¿Qué hemos podido hacer?
• ¿Cómo hacer un slicing de los datos?

Matrices de tres dimensiones

En nuestro caso construiremos una matriz de 3x3 dimensiones

Si, a su vez, los elementos de segundo nivel son listas de elementos, nos encontramos ante una matriz de tres dimensiones:

m=np.array([[[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]]])
m
m[2] # retorna la tercera matriz

--> array([[19, 20, 21],
       [22, 23, 24],
       [25, 26, 27]])

Es como poner varias matrices juntas

[[1,2,3],[4,5,6],[7,8,9]] 			← Primera matriz  
[[10,11,12],[13,14,15],[16,17,18]] 	← Segunda matriz  
[[19,20,21],[22,23,24],[25,26,27]] 	← Tercera matriz  

Slicing

• Dimensión 1: completa
• Dimensión 2: completa
• Dimensión 3: completa

m[:,:,: ]

--> array([[[ 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]]])

• Dimensión 1: completa
• Dimensión 2: 1,2
• Dimensión 3: completa

m[:,:2,:]

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

       [[10, 11, 12],
        [13, 14, 15]],

       [[19, 20, 21],
        [22, 23, 24]]])

• Dimensión 1: completa
• Dimensión 2: 1,2
• Dimensión 3: 2,3

m[:,:2,2:3 ]

--> array([[[ 3],
        [ 6]],

       [[12],
        [15]],

       [[21],
        [24]]])

Hola!

Les comparto mi ejercicio con la matriz de 3 dimensiones.

matriz = np.array([i for i in range (1, 56) if i % 2 == 0])
matriz = matriz.reshape(3, 3, 3)
matriz

array([[[ 2,  4,  6],
        [ 8, 10, 12],
        [14, 16, 18]],

       [[20, 22, 24],
        [26, 28, 30],
        [32, 34, 36]],

       [[38, 40, 42],
        [44, 46, 48],
        [50, 52, 54]]])

matriz[2]

array([[38, 40, 42],
       [44, 46, 48],
       [50, 52, 54]])

matriz[2, 1] # Matriz en la posición 2 fila 1

array([44, 46, 48])

matriz[2, 1, 2]

48

matriz[1, 1:]

array([[26, 28, 30],
       [32, 34, 36]])

matriz[::-1] # Matriz invertida

array([[[38, 40, 42],
        [44, 46, 48],
        [50, 52, 54]],

       [[20, 22, 24],
        [26, 28, 30],
        [32, 34, 36]],

       [[ 2,  4,  6],
        [ 8, 10, 12],
        [14, 16, 18]]])

m = [[[1],[2]], [[3],[4]]]
print(m)
print("="*7)
m = np.array(m)
print(m)
print("="*7)
print(“n dimensiones =>”,m.ndim)

[[[1], [2]], [[3], [4]]]

[[[1]
[2]]

[[3]
[4]]]

n dimensiones => 3

Tambien vi que des esta forma se puede acceder

array_matriz[0][0]
array_matriz[0][2]

array_matriz[0,2]

Para aquellos que tuvieron este error:

IndexError Traceback (most recent call last)
<ipython-input-36-fea98b13ac62> in <module>
----> 1 matriz[0,1]

IndexError: too many indices for array: array is 1-dimensional, but 2 were indexed

al poner el;
matriz[0,2]

les recomiendo que revisen la matriz creada ya que si no es igual, ósea que la lista 1 tenga cuatro números y las otras tres o algo parecido será una lista desigual y eso ya es otro tema.

espero ayudar con esto, la verdad me sucedió porque normalmente me gusta estar experimentando.

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]]]
matriz3d = np.array(matriz3d)
matriz3d
array([[[ 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]]])

Búsqueda indexada

matriz3d[1,1,2]
15

matriz3d[1, :, -1]
array([12, 15, 18])

Que interesante la libreria numpy, y muy util es usar el notebook de Google colab.

Les comparto mi notebook de esta clase:
clase2_numpy_array

d3_matrix = np.array([
  [[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]]
])
# matriz de 3 x 3
print(d3_matrix)
print('**********************************')
print(d3_matrix[1:2, 1:2, 1:2]) # imprime el valor 14 (en este caso justo el que está en el centro)

matriz_d = [[[1,2,3],[1,1,1],[4,5,6]], [[7,8,9],[2,2,2],[10,11,12]] ]
matriz_d = np.array(matriz_d)
matriz_d[0,1]
Resultado : array([1, 1, 1])
matriz_d[0,2,1]
Resultado : 5

Les comparto este video para los que utilizan visual code, puedan instalar las librerías, ya que tuve algunas dificultades para que funcionaran, así que les comparto la solución para que no tengan que investigar este inconveniente que me sucedió.

Los grupos por visibilidad los reduje de 2 en 2 para ser mas claro…

Una breve explicacion de slicing, matriz de 3 dimensiones, fue un apunte hecho con los comentarios más un poco de internet pero creo que quedo bien
https://colab.research.google.com/drive/1iw8BISgNhhvkgpjdjcxPkmiQQ2rcaT5A?usp=sharing

Array de 4 dimensiones
Tuve curiosidad sobre si se podría hacer un array de 4 dimensiones así que lo intenté 😄. Y funciona!

Imagina un cubo 2 por 2, tenemos 2 de esos. Ese es el primer índice. En cada cubo existen 2 capas, el segundo índice. Cada uno con 2 filas, tercer índice, y finalmente cada fila tiene 2 números, el útilmo indice.

Existen en total 2 x 2 x 2 x 2 elementos.

dimension4 = [
      

      [
      [[0,1],[2,3]],
      [[4,5],[6,7]],
      ]
      ,
      [
      [[8,9],[10,11]],
      [[12,13],[14,15]],
      ]
      

      ]
d4 = np.array(dimension4)
d4       

El resultado se vería así: ( espero se entienda )

array([  [ [[ 0,  1],
            [ 2,  3]],

           [[ 4,  5],
            [ 6,  7]] ],


     	   [ [[ 8,  9],
            [10, 11]],

           [[12, 13],
            [14, 15]] ]  ])

Para verificar la cantidad de dimensiones usamos la función “.ndim”.

print(d4.ndim)
4

Si escogemos el segundo cubo, la primera capa, la segunda fila y el primer número el código sería así:

d4[1,0,1,0]
//La respuesta es 10

Aunque no tenga una utilidad tan común es interesante que puedas hacer un array de más de 3 dimensiones. No llegué a un límite de dimensiones pero no creo que necesites más de 3 en realidad😂.
Gracias por leer y recuerda ¡Nunca pares de aprender!

tensor = np.array([[[55, 38, 4, 18, 79, 85, 52],
[80, 43, 32, 12, 94, 66, 38],
[17, 89, 74, 35, 90, 96, 31],
[56, 25, 95, 11, 96, 40, 27],
[23, 32, 66, 59, 73, 95, 65],
[21, 53, 36, 53, 71, 65, 75],
[20, 57, 67, 74, 6, 82, 4]],
[[77, 3, 70, 71, 93, 57, 8],
[2, 63, 52, 79, 83, 13, 27],
[100, 55, 5, 97, 3, 45, 21],
[2, 51, 2, 85, 86, 41, 7],
[3, 23, 73, 44, 44, 34, 78],
[97, 66, 13, 34, 49, 7, 75],
[83, 19, 50, 60, 3, 51, 31]],
[[8, 78, 3, 52, 88, 19, 99],
[28, 96, 84, 74, 93, 89, 21],
[94, 30, 21, 98, 13, 82, 75],
[75, 14, 73, 39, 72, 99, 85],
[58, 91, 28, 9, 51, 18, 95],
[4, 93, 35, 90, 53, 33, 8],
[82, 87, 37, 60, 52, 78, 90]]])
print(tensor[1:, 2:5, :4])

En la práctica que realicé, pude comprobar que se puede realizar en las matrices de tres dimensiones todos lo aplicado en esta clase…

Aquí les dejo una manera de crear un tensor y acceder a sus elementos:

Cacharreando con todas las formas posibles

import numpy as np

arr_a=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,10,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40]

arr_a=np.array(arr_a)

a = 1
b = 2
c = 3
d = 4

# borrar el numera(#) de la opción a probar ya que jupyter solo ejecuta la ultima linea

#arr_a[1:10]        # desde 1 hasta10
#arr_a[10:20]       # desde 10 hasta 20
#arr_a[-20]         # desde el -20 hasta el final (no tiene en cuenta el 20)
#arr_a[-20:-10]     # desde -20 hasta -10
#arr_a[-20:-10:2]   # desde el -20 hasta el -10, de 2 en 2
#arr_a[-41:]        # desde el inicio al fin
#arr_a[10::3]       # desde inicio hasta fin, de 3 en 3
#arr_a[:20:2]       # desde inicio hasta 20, de 2 en 2
#arr_a[::4]         # desde inicio hasta fin, de 4 en 4 
#arr_a[::1+2]       # desde inicio hasta fin, de 4 en 4 (1+2 =3)
#arr_a[4*0:2**5:100//50] #desde 0(4*0)    hasta 32(2 elevado a la 5),     de 2 en 2 (100 dividido en 50)
#arr_a[a:d**2:d//b]   # desde 1   hasta 16,   de 2 en 2

Yo cree esta matriz de tres dimensiones como esta:

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

y realice esta operación:

cube[:1,1:,:1]

y me arrojo como resultado esto:

array([[[3]]])

y llego a la conclución de que praticamente se pueden hacer las mismas operaciones que con una matriz de dos dimesiones y de una, solo que al aumentar las dimensiones, estas se vuelven más dificiles de manejar.

Truchas con la pronunciación de arrays: ar’reis

solo valores especificos

Esta fue mi Matriz principal de 3D para hacer mis hallazgos:

matrix3D = [[9,5,8],[5,5,7],[8,3,0]]
matrix3D = np.array(matrix3D)
matrix3D

array([[9, 5, 8],
       [5, 5, 7],
       [8, 3, 0]])

No se que tan básicos sean mis hallazgos/insights, pero con el slicing pude detectar que puedo crear matrices de otras dimensiones menores al de 3 x 3. Ejemplo:

matrix3D [0:,1]

array([5, 5, 3])

**Y: **

matrix3D [0:3,1:3]

array([[5, 8],
       [5, 7],
       [3, 0]])

Puedo sacar matrices de 2 dimensiones desde cualquier coordenada comprendida entre las posiciones 0 y 2, tanto en filas como columnas.