NumPy Array

2/24
Recursos
Transcripci贸n

El array es el principal objeto de la librer铆a. Representa datos de manera estructurada y se puede acceder a ellos a trav茅s 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]

Volvemos nuestra lista, un array

arr = np.array(lista)
arr
---> [1, 2, 3, 4, 5, 6, 7, 8, 9]

Una matriz son varios Vectores o listas agrupadas una encima de la otra, es como una tabla de Excel

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 empiezan a contar desde 0.

arr[0]
---> 1
Index 0 1 2 3 4 5 6 7 8
0 1 2 3 4 5 6 7 8 9

Es posible operar directamente con los elementos.

arr[0] + arr[5]
---> 7
0 + 5
1 6

En el caso de las matrices, al indexar una posici贸n se regresa el array de dicha posici贸n.

matriz[0]
---> array([1, 2, 3])
Index 0 1 2
0 1 2 3
1 4 5 6
2 7 8 9

Para seleccionar un solo elemento de la matriz se especifica la posici贸n del elemento separada por comas.

Nota: El primer elemento selecciona las filas, el segundo elemento las columnas

matriz[0, 2]
---> 3

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.

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

Si no se ingresa el valor de inicio, se toma el inicio como la posici贸n 0.

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

En cambio, si no se le da una posici贸n final, 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])
Index 0 3 7
0 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])
1 2 3 4 5 6 7 8 9

Para el caso de las matrices, sucede algo similar.
Para acceder a los valores entre filas.

matriz[1:]
---> array([[4, 5, 6],
       	   [7, 8, 9]])

Para acceder a los valores entre filas y columnas.

matriz[1:, 0:2]
---> array([[4, 5],
            [7, 8]])

Reto

Crea una matriz de 3 dimensiones y cu茅ntanos:

  • 驴Qu茅 pudiste hacer?
  • 驴C贸mo hacer un Slicing de los datos?

Contribuci贸n creada por: Edward Giraldo.

Aportes 126

Preguntas 17

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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] 

Me genero un poco de curiosidad del porque deber铆a de convertir de 鈥渕atriz鈥 a una 鈥渘darray鈥, 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. 馃槃

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

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.

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

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.

creo que hay un problema de edici贸n al final del video

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]

12:34 No entiendo por que el escribe 0:2 y el array devuelve 4,5 ,7,8 si la posicion 0 son 4 y 7 (hasta ahi todo bien) pero la posici贸n 2 son 8 y9 no 7 y 8

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]

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.

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)


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 馃挌

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

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 鈥渁rray鈥 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.

Algo interesante de lo que muestra el tutorial como "indexaci贸n" es que **busca un dato!** debido al espa帽ol, la gente usa la palabra *indexar* de forma similar a *anexar* (sumar, a帽adir, agregar, etc). PD. No me baso en un diccionario ni nada por el estilo, solo en mi propia experiencia.

No me hagan caso, estoy equivocado :v
En la actualidad con Python >3.8 y NumPy en su versi贸n mas actualizada, el acceso por 铆ndices para una matriz cambi贸. Luego de ejecutar `matriz[0:3]` arroja error Actualmente la sintaxis adecuada es: `matriz[0:3][0]`
En la actualidad con Python >3.8 y NumPy en su versi贸n mas actualizada, el acceso por 铆ndices para una matriz cambi贸. Luego de ejecutar `matriz[0,2]` arroja error Actualmente la sintaxis adecuada es: `matriz[0][2]`
Yo hice la siguiente matriz 3D y seleccione un valor especifico y un conjunto de valores: `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)` Seleccionar un valor: `matriz3d[1,0,2]` Seleccionar un conjunto de valores: `matriz3d[::2,:2,1:]` ![](https://static.platzi.com/media/user_upload/Captura%20de%20pantalla%202023-10-04%20a%20la%28s%29%2011.33.02%E2%80%AFa.%C2%A0m.-bd5693ec-972f-4a0f-a8a2-63441d8311c8.jpg)
![](https://static.platzi.com/media/user_upload/newplot-6b3b327b-6210-45ac-bbc4-8ae54f3ab830.jpg)![](file:///D:/CODING/newplot.png)
import plotly.graph\_objects as goimport numpy as np \# Create a 3D matrixmatrix\_3d = 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]]]) \# Create meshgrid for the coordinatescoords = np.array(np.meshgrid(np.arange(matrix\_3d.shape\[2]), 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 np.arange(matrix\_3d.shape\[1]), 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 np.arange(matrix\_3d.shape\[0]))) \# Reshape the coordinates arraysx = coords\[2].flatten()y = coords\[1].flatten()z = coords\[0].flatten() \# Flatten the matrix to get the values for the color scalevalues = matrix\_3d.flatten() \# Create the interactive 3D scatter plotfig = go.Figure(data=\[go.Scatter3d(x=x, y=y, z=z,聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽mode='markers',聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽marker=dict(size=10,聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽color=values, 聽# Set color to matrix values聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽colorscale='Viridis',聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽opacity=0.8,聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽showscale=True))]) \# Update layout for better appearancefig.update\_layout(scene=dict(xaxis\_title='Column X',聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽yaxis\_title='Row Y',聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽zaxis\_title='Depth Z'),聽 聽 聽 聽 聽 聽 聽 聽 聽 title='Interactive 3D Matrix Visualization',聽 聽 聽 聽 聽 聽 聽 聽 聽 margin=dict(l=0, r=0, b=0, t=40)) fig.show()
de lo que va el curso, haz aprendido. 1. que es numpy y para que lo usamos. 2. que es un array y como declararlo. 3. indexado y sus propiedades[start,end,steps] 4. c贸mo manipular arrays con dimensiones. posdata: + dimensiones + ceros. los ceros te ayudar谩n a filtrar m谩s las dimensiones. imag铆nate esto: arr = np.array([[[[[[[1,2,3],[4,5,6]]]]]]]) c贸mo har铆as para ingresar al 6? bueno, debes filtrar las dimensiones. usando el cero puedes ir reduciendo dimensiones. arr(0,0,0,0,0,0,1,2) int茅ntalo.

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 鈥渃apa鈥

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) [鈥楪鈥,鈥楬鈥,鈥業鈥橾.

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 鈥榥鈥 elementos tiene una dimensi贸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 鈥淒ark鈥 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 鈥渃apas鈥 o 鈥渘iveles鈥, 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 鈥渃鈥 o 鈥渂鈥, tambi茅n modifica 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(鈥渘 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鈥檙eis

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.

Apuntes:

  • Array de tres dimensiones
    • slicing:
    matriz3[dim3,dim2,dim1]
    matriz3[z,y,x]
    matriz3[start:stop:step, start:stop:step, start:stop:step]

Nota: en una matriz de una dimension que es lo mismo a un vector-> sus elementos son n煤meros
Nota: En una matriz de dos dimensiones -> sus elementos son vectores
Nota: En una matriz de tres dimensiones -> sus elementos son matrices de 2 dimensiones
鈥

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

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

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

matriz3 = np.array(matriz3)

matriz3[0,1,0]
-> 4

matriz3[0:3:2,0,1:3]
-> array([[ 2,  3],
          [14, 15]])

Cuando trabajamos con listas y slices (slices en espa帽ol significa rebanada) debemos tener en cuenta algo muy importante, si colocamos lista[0:6] los valores que rebanar谩 (de ah铆 el concepto de slice) ser谩n los ubicados en las posiciones del 0 al 5, pero, 驴por qu茅 no me toma la posici贸n 6? Sencillo, porque los slices tienen algo que se llama end not inclusive (final no inclusivo).

Para resumir, tengan en cuenta siempre que trabajen con slices que la posici贸n que asignen al final de la rebanada (0:6) no ser谩 incluido como parte de la sub-lista que se genera al rebanar 馃槃.

Mi ejemplos:

import numpy as np

# Arrays
x = [0,1,2,3,4]
np_array = np.array(x)
print(np_array)
print('Add 26', np_array+26)
print('Multiplies by 10', np_array*10)
print('Inverts the positions', np_array[::-1])
print('Jumping two by two', np_array[::2])
print('The last value', np_array[-1])
print('The last three values', np_array[-3:])
print(type(np_array))

# Matrix
y = [[1,2,3],[4,5,6],[7,8,9]]
np_matrix = np.array(y)
print(np_matrix)
print('Add 26\n', np_matrix+26)
print('Multiplies by 10\n', np_matrix*10)
print('Inverts the positions\n', np_matrix[::-1])
print('Inverts all positions\n', np_matrix[::-1, ::-1])
print('Jumping two by two\n', np_matrix[::2])
print('Jumping all two by two\n', np_matrix[:, ::2])
print(type(np_matrix))


Yo probe crear una matriz de 4 dimensiones. Las dos primeras de 10 x 10 y las dos segundas 3 x 3. Como un gran tablero de dama y dentro de cada casillero un tablero de ta te ti. Los casilleros del borde todos en blanco (llenos de cero) el resto todos con unos y los centrales con numeros del 1 al 9. Con eso fui probando acceder a cada talbero interno y a cada casilla. Lo que me encontre es que con la matriz creada con python no podia usar slicing (me devolvia una matriz vacia). Es decir, consultando una linea ([2])uno en especial ([4][5]) me devolvia la matriz interna y slicing podia usar solo en el primer nivel ([4:6]) pero si queria hacer en dos niveles ([4:6][4:6]) me devolvia vacio. Ese mismo array pasado a otra variable con numpy si podia hacerlo para obtener los 4 tableros (matrices) centrales.

matriz[1:,0:2]
array([[4, 5],
       [7, 8]])

matematicas

import numpy as np
x = [0,1,2,3,4]
y = np.array(x)+2
print(y)
[2,3,4,5,6]

Esta es la Matriz 3D que gener茅:

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

matriz3d

RESULTADO

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

Una vez que se gener贸, estaba teniendo problemas porque se me olvid贸 convertirla a lista de Numpy, pero una vez que la convert铆, pude hacer los experimentos sin problema.

matriz3d = np.array(matriz3d)
type(matriz3d)

Este c贸digo es solo para mostrar la primera fila de cada capa

matriz3d[:, :1, :]

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

       [[11, 12, 13]],

       [[21, 22, 23]]])

Espero mi aporte ayude a otros ^^/

reto cumplido

matriz3 = [[23,45,56,78,],[34,56,90,12],[00,90,12,46]] 
[[[[2,4,6,7],[32,19,21,67],[71,27,33,49]]]]
matriz3 = np.array(matriz3)
array([[23, 45, 56, 78],
       [34, 56, 90, 12],
       [ 0, 90, 12, 46]])
matriz3
array([[23, 45, 56, 78],
       [34, 56, 90, 12],
       [ 0, 90, 12, 46]]) 
arr[-3:]
#ingresar a los ultimos valores de una lista 
array([[34, 56, 90, 12],
       [ 0, 90, 12, 46]])

matriz3[1:]
#para ingresar a mas de un valor de la matriz
array([[34, 56, 90, 12],
       [ 0, 90, 12, 46]])

matriz3[1:,0:2]
#matrices a nivel de columnas 
array([[34, 56],
       [ 0, 90]])


Array, Principal Objeto de Numpy Estructura indexada, encabezados, identificar objeto, acceder a datos y conjuntos de datos

Con numpy tambi茅n es posible usar random, de la sigiente forma:

numpy.random.randint(low, high = None, size = None, dtype = 'l')

el argumento low es el n煤mero menor que se a帽adir谩 a los datos, si high es None entonces ser谩 el mayor. size, recibe una tupla de valores (m, n, k) donde va extraer m * n * k muestras, si no se especifica ser谩 un array de una dimensi贸n, para dos dimensiones, como la creada en la clase size = (3, 3) y para el ejercicio size = (3, 3, 3).

As铆 para generear una matriz de tres dimensiones con n煤meros aleaotorios entre el 90 y el 100 el c贸digo ser铆a:

matriz = np.random.randint(90, 100, size = (3, 3, 3))

Las coordenadas de los indices est谩n en orden
X. Numero de la matriz
Y.Fila de la matriz
Z.Columna de la matriz

import numpy as np

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

print(m3D)
m3D[0,2,1]

Hola, como podr铆a solucionar este error? Gracias 馃槂

import numpy as np

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

TypeError: list indices must be integers or slices, not tuple

Compa帽eros buenas tardes, a continuaci贸n mi aporte:
Creaci贸n de una matriz de 3 dimensiones:

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

Como acceder a la primera columna de todas las dimensiones:

matriz3d[:,:,0]

En mi casi opt茅 por crear el array 3D y realizar una operaci贸n de comparaci贸n entre los valores a los cuales acced铆.

M谩s o menos as铆.

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

**Mi aporte ** se pueden dar la vuelta a las matrices y arreglos como lo ense帽an en el curso b谩sico de Python, 煤nicamente poniendo en el caso del arreglo

arr[::-1]

y en el de la matriz

matriz[::-1]