Creando arrays

5/24
Recursos

Aportes 15

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Les recomiendo experimentar el tomar notas en el mismo código que vas escribiendo mientras ves la clase, al principio puede costar acostumbrarse (sobre todo si como yo estabas acostumbrado a tomar notas aparte en un cuaderno o en el iPad).

Pero la ventaja es que al mismo tiempo que vas tomando notas y comentando el código, vas practicando. Incluso cuando salta algún error puedes revisar la sintaxis y eso va fijando el aprendizaje en tu cerebro de mejor manera.

Ventajas:

  • Practicas desde el momento cero
  • Ahorras tiempo
  • Es más fácil de consultar después
  • Puedes tenerlo disponible en cualquier momento y lugar
  • Es otra forma de consolidar el aprendizaje

Quizás no a todos les vaya a funcionar de la misma manera, pero sin duda vale la pena experimentarlo. Quién sabe, quizás encuentras una forma más óptima de nunca parar de aprender 😉

Te dejo un ejmplo de lo que estoy haciendo en este curso

🔀Creando arrays


Este métodode NumPy nos permite generar arrays sin definir previamente una lista.

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

Un tercer argumento permite definir un tamaño de paso.

np.arange(0,20,2)
----> array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])

np.zeros() nos permite definir estructuras o esquemas.

np.zeros(3)
----> array([0., 0., 0.])
np.zeros((10,5))
----> array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])

De iugal forma tenemos np.ones()

np.ones(3)
----> array([1., 1., 1.])

np.linspace() permite generar una arrary definiendo un incio, un final y cuantas divisiones tendrá.

np.linspace(0, 10 , 10)
---->  array([ 0.,1.11111111,2.22222222,  3.33333333,  4.44444444,
        5.55555556,  6.66666667,  7.77777778,  8.88888889, 10.])

También podemos crear una matriz con una diagonal de 1 y el resto de 9.

np.eye(4)
----> array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])

Otra metódo importante es generar números aleatorios.

np.random.rand()
----> 0.37185218178880153

También se pueden generar vectores.

np.random.rand(4)
----> array([0.77923054, 0.90495575, 0.12949965, 0.55974303])

Y a su vez generar matrices.

np.random.rand(4,4)
----> array([[0.26920153, 0.24873544, 0.02278515, 0.08250538],
       [0.16755087, 0.59570639, 0.83604996, 0.57717126],
       [0.00161574, 0.27857138, 0.33982786, 0.19693596],
       [0.69474123, 0.01208492, 0.38613157, 0.609117  ]])

NumPy nos permite tambien generar números enteros.
En este caso números enteros entre el 1 y 14

np.random.randint(1,15)
----> 4

También podemos llevarlos a una estructura definida.

np.random.randint(1,15, (3,3))
----> array([[ 8,  2,  6],
       [ 7,  1,  8],
       [11, 14,  4]])

Creando Arrays

1 ✅ np.arange (Start,Ens,Steps) → es como el list( range(0,10)) pero como arrange
2 ✅ np.zeros(n)
3 ✅ np.ones(n)
4 ✅ np.linspace(Start, End, Cant n de Start a End)
5 ✅ np.eye(n) ·· Matriz identidad

Arrays con numeros randoms

☑️ np.random.rand(Columnas, Filas, mas dimensiones ) ·· Ambos con numeros randoms
☑️ np.random.randint(Start, End, Dimensiones) ·· N random entre Start y End y tupla dims

Para tener una matriz con un numero predeterminado

matriz= np.full((3,3),7)
matriz
array([[7, 7, 7],
       [7, 7, 7],
       [7, 7, 7]])

Hasta el momento, mucho mejor que el otro curso de manipulación de datos, se entiende 1000% mejor, y hasta me divierto mucho. Una mejora muy grande del contenido de esta carrera!

Random choice genera un numeros aleatorios de un set de numeros definidos.
Para este ejemplo el set de datos es: 1,3,5,7 y 9.

mtz_rand = np.random.choice([1,3,5,7,9], size=(3, 5))
print(mtz_rand) 

[[3 7 1 3 1]
[7 7 3 7 1]
[3 7 5 1 9]]

Sin duda que esta clase lo que hace es VOLARTE la cabeza.
Voy llevando un Deepnote con apuntes de todo el curso.
Miren y díganme qué les parece: https://deepnote.com/project/Curso-de-Pandas-y-Numpy-kSDlYzFzQfujhpV18QWx2g/%2Fnotebook.ipynb

Crear array con un iterador


Puedes usar la misma función de np.array pasándoles un iterador. Así estos dos comandos son equivalentes
´´´
np.arange(2,15,2)
np.array(range(2,15,2))
´´´
Esto abre la posibilidad de pasar iteradores que iteren sobre cosas diferentes a enteros.

La funcionalidad de np.linspace (linearspace) es super útil cuando vas a graficar, aumentando el número de los samples puedes aumentar la resolución de la gráfica.

zeros_like


Hay veces que no tienes claro cúal va a ser la dimension del array pero sí sabes que tendrá la misma dimensión que otro array. En estos casos puedes usar la función zeros_like que recibe un array como argumento y te retorna un array de las mismas dimeniones pero de puros ceros.

´´´
a = np.array([1,2,3,4,5])
b = np.zeros_like(a)
print(b) # Out: array([0,0,0,0,0])
´´´

Muy buena clase! sobretodo como generar números y matrices con componentes aleatorios! Será muy útil más adelantes seguro!

Anteriormente hemos creado Array convirtiendo listas pero numpy tiene mútiples formas para crear Arrays

Para crear un array con un rango
• np.arange(0,20,2) -> np.arange(inial,stop,step)

Crear un array compuesto de “0”
• np.zeros(3)
• np.zeros((10,10)) =
array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])

	
	• np.ones((10,10))=matriz 10*10 con elementos 1
	• np.linspace(0,10,10) -> np.linspace(inicio,fin,saltos)
	• np.eye(4) -> matriz con diagonal de unos 
		array([[1., 0., 0., 0.],
		       [0., 1., 0., 0.],
		       [0., 0., 1., 0.],
		       [0., 0., 0., 1.]])
	• np.random.rand()-> genera un valor aleatorio de 0 a 1 
	• np.random.rand(4)-> array de 4 elementos aleatorios 
	• np.random.rand(4,4)
		array([[0.01897705, 0.91650084, 0.17557255, 0.32269687],
		       [0.3589862 , 0.176873  , 0.73445476, 0.25795953],
		       [0.65750148, 0.69028643, 0.89486994, 0.56272176],
		       [0.72915255, 0.77849035, 0.31982782, 0.09211508]])
	• np.random.randint(1,15)-> definir un número aleatorio dentro del rango indicado 

De gran ayuda usar estas funciones

Cuando vimos la primera clase de arrays, el profe explicó que podíamos usar slices para obtener ciertos elementos de dichos arrays ( ejemplo: arr[::-1] para cambiar el orden en que se imprime el array)
Acabo de probar si estos slicers también funcionan para los arrays creados directamente con “np.arange” y también funciona!
Aunque obvio creo que es emocionante : )

Excelente clase!