Creando arrays

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

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

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

Lo que conocemos cómo función eye() es lo que nosotros algebriacamente conocemos cómo matriz identidad y es muy útil en algunos métodos numéricos para soluciones de problemas reales, ya sea lineales o no lineales.

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

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!

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

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

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.

MIS APUNTES #6 (NOTION + NOTAS CORNELL)

Información resumida de esta clase
#EstudiantesDePlatzi

• NumPy me ayuda creando nuestros arrays

• Utilizando el método np.arange puedo generar mis arrays con la cantidad de datos que desee

• Con el método np.zeros puedo crear una array de solo ceros y esto se utiliza mucho en las ciencias de datos

• Con el método np.ones igualmente puedo crear un array o una matriz con solemente valores en 1

• Con el método np.eye puedo crear una matriz con la diagonal principal en 1

• Es importante que aprendamos álgebra

• Con el método random puedo obtener un número aleatorio

• Es importante ir practicando todo esto

numpy.linspace => Devuelve números espaciados uniformemente en un intervalo específico.
.
Básicamente una función lineal y no distribución normal que comenta el video, para aclarar esa parte. 😃

Podemos crear arrays mediante diferentes formas, la primera sera atreves de un range, con numpy usaremos .arange

np.arange(0,20,2)

Otra forma es con .zeros, esta sera especialmente util en ciencia de datos, lo que nos permitira crear un esquema previo de un esquema de datos que usaremos

np.zeros((10,10))

'''
Entrega
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.]])

'''

De una manera similar podemos usar .ones, para crear una estructura con 1

np.ones((10,10))

'''
Entrega
array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])
'''

También una funcionalidad muy importante es crear matrices con linea principal de 1, algo muy importante en algebra lineal, para ello, se usara la funcion .eye( )

np.eye(4)

'''
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])
'''

Para generar un valor aleatorio podemos usar np.random.rand

• Un array lo podemos crear con np.random.rand(4)
• Una matriz np.random.rand(4,4)

Para agregar un estrutura usaremos:

np.random.randint(1,100,(10,10))
’’‘
Entrega
array([[54, 15, 57, 40, 90, 66, 21, 11, 68, 62],
[30, 35, 50, 87, 81, 15, 37, 96, 48, 82],
[89, 64, 81, 70, 18, 78, 5, 68, 83, 74],
[86, 23, 9, 93, 70, 94, 31, 74, 29, 16],
[52, 48, 40, 91, 79, 38, 84, 82, 69, 87],
[97, 42, 82, 83, 59, 45, 45, 98, 96, 56],
[77, 78, 33, 7, 2, 52, 94, 13, 59, 1],
[36, 48, 43, 67, 36, 94, 81, 25, 89, 64],
[69, 78, 96, 1, 39, 58, 3, 67, 4, 62],
[59, 6, 69, 63, 75, 36, 84, 91, 61, 34]])
’’’

Creando Arrays desde Numpy

• np.arange(inicio, final, pasos): arange puede recibir hasta 3 parametros: incio, final y pasos. Los pasos serían la cantidad de saltos que dejará entre los valores.
• np.zeros(valor): Define una estructura matricial flotante con valores en 0.
• np.ones(valor): Define una estructura matricial flotante con valores en 1.
• np.linspace(desde, hasta, cantidad): Genera una distribución normalizada recibiendo los siguientes parámetros: desde, hasta, cantidad
• np.eye(value): Crea una matriz de datos con la diagonal principal en 1 y los demás valores en 0.
• np.random.rand(n, m): Crea valores aleatorios, o si queremos, vectores o matrices de valores aleatorios.
• np.random.randint(n, m, (n, m)): Genera un número entero aleatorio entre un rango numérico, también podemos generar una estructura completa si así deseamos

****Convertir secuencias de Python en NumPy Arrays ****

• Las matrices NumPy se pueden definir utilizando secuencias de Python, como listas y tuplas. Las listas y tuplas se definen usando […]y (…), respectivamente.

• Las listas y tuplas pueden definir la creación de ndarray:

• una lista de números creará una matriz 1D,

• una lista de listas creará una matriz 2D,

• más listas anidadas crearán matrices de mayor dimensión. En general, cualquier objeto de matriz se denomina ndarray en NumPy.

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

• Cuando usa numpy.arraypara definir una nueva matriz, debe considerar el dtype de los elementos en la matriz, que se puede especificar explícitamente. Esta característica le brinda más control sobre las estructuras de datos subyacentes y cómo se manejan los elementos en las funciones de C/C++. Si no tiene cuidado con las dtype asignaciones, puede obtener un desbordamiento no deseado, como tal

a = np.array([127, 128, 129], dtype=np.int8)
a
array([ 127, -128, -127], dtype=int8)

• Un entero de 8 bits con signo representa números enteros de -128 a 127. La asignación de la int8matriz a números enteros fuera de este rango da como resultado un desbordamiento. Esta característica a menudo se puede malinterpretar. Si realiza cálculos con desajustes dtypes, puede obtener resultados no deseados, por ejemplo:

a = np.array([2, 3, 4], dtype=np.uint32)
b = np.array([5, 6, 7], dtype=np.uint32)
c_unsigned32 = a - b

print('unsigned c:', c_unsigned32, c_unsigned32.dtype)
unsigned c: [4294967293 4294967293 4294967293] uint32
c_signed32 = a - b.astype(np.int32)
print('signed c:', c_signed32, c_signed32.dtype)
signed c: [-3 -3 -3] int64

Métodos para crear Arrays

numpy.arange()

El método numpy.arange() se emplea similar al método range() definido para Python, diferenciándose en el tipo de objeto que devuelve. Es posible establecer un único valor de entrada (preferiblemente un valor mayor a cero) o establecer un intervalo semiabierto [p, q) donde p sea menor a q. Si solo se le proporciona un único valor de entrada, el método tomará como valor de p el cero y q será el valor de entrada.

import numpy as np

a = np.arange(5)
print(a)  # array([0, 1, 2, 3, 4])

b = np.arange(3, 10)
print(b)  # array([3, 4, 5, 6, 7, 8, 9])

Opcionalmente, se puede establecer un tercer argumento de entrada, el cuál definirá los pasos a tomar hasta llegar al final de la secuencia. Sino se especifica, el valor por defecto tomado por el método será 1.

import numpy as np

c = np.arange(12, 153, 13)
print(c)  # [ 12, 25, 38, 51, 64, 77, 90, 103, 116, 129, 142]

d = np.arange(1, 2, 0.1)
print(d)  # [1. , 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9]

e = np.arange(0, 1, 1/10)
print(e)
# [0. , 0.09090909, 0.18181818, 0.27272727, 0.36363636,
#  0.45454545, 0.54545455, 0.63636364, 0.72727273,
#  0.81818182, 0.90909091]

numpy.linspace()

Similar al método numpy.arange(), el método numpy.linspace() se emplea para crear Arrays unidimensionales de reales entre dos valores entregados. Como argumentos de entrada espera dos números reales (R), retornando un Array con 50 valores normalmente distribuidos entre el intervalo cerrado [p, q] proporcionado. Es posible entregar un tercer valor para indicar la cantidad de valores que retornará el método.

import numpy as np

a = np.linspace(-99, 99, 10)
print(a)  # [-99. -77. -55. -33. -11.  11.  33.  55.  77.  99.]

numpy.identity()

El método numpy.identity() se emplea para conseguir una matriz identidad de tamaño n x n . Como argumento recibe un valor entero positivo.

import numpy as np

i = np.identity(5)
print(i)
# [[1. 0. 0. 0. 0.]
#  [0. 1. 0. 0. 0.]
#  [0. 0. 1. 0. 0.]
#  [0. 0. 0. 1. 0.]
#  [0. 0. 0. 0. 1.]]

numpy.eye()

Similar al método numpy.identity(), el método numpy.eye() es empleado para crear Arrays de 2 dimensiones (matrices) con unos en una diagonal y ceros en las posiciones restantes. Como argumentos de entrada recibe un entero positivo que representa las

Crea una matriz identidad (cuya diagonal principal está rellena de 1)
recibe como entrada en un solo entero positivo que indica el tamaño n de la matriz (n x n)
es posible establecer un segundo argumento numérico para el número de las columnas

import numpy as np

a = np.eye(5, 7)
print(a)
# [[1. 0. 0. 0. 0. 0. 0.]
#  [0. 1. 0. 0. 0. 0. 0.]
#  [0. 0. 1. 0. 0. 0. 0.]
#  [0. 0. 0. 1. 0. 0. 0.]
#  [0. 0. 0. 0. 1. 0. 0.]]

numpy.zeros()

Similar al método numpy.ones(), el método numpy.zeros() se emplea para crear Arrays rellenos de ceros. Como argumento de entrada el método espera bien un entero positivo, para retornar una arreglo unidimensional o una tupla (o lista) de enteros positivos para crear arreglos de más dimensiones. Por defecto el tipo de dato retornado será float64.

import numpy as np

f = np.zeros((2, 3, 4))
print(f)
# [[[0. 0. 0. 0.]
#   [0. 0. 0. 0.]
#   [0. 0. 0. 0.]]
#
#  [[0. 0. 0. 0.]
#   [0. 0. 0. 0.]
#   [0. 0. 0. 0.]]]

Note que las últimas dos posiciones de la tupla entregada hacen referencia a las filas y las columnas de cada matriz en el tensor. Los valores iniciales representarán las dimensiones el Array devuelto.

numpy.ones()

Similar a numpy.zeros(), el método numpy.zeros() se emplea para crear Arrays rellenos de 1. Como argumento de entrada el método espera bien un entero positivo, para retornar una arreglo unidimensional o una tupla (o lista) de enteros positivos para crear arreglos de más dimensiones. Por defecto el tipo de dato retornado será float64.

import numpy as np

g = np.ones([2, 3, 6])
print(g)
# [[[1. 1. 1. 1. 1. 1.]
#   [1. 1. 1. 1. 1. 1.]
#   [1. 1. 1. 1. 1. 1.]]
#
#  [[1. 1. 1. 1. 1. 1.]
#   [1. 1. 1. 1. 1. 1.]
#   [1. 1. 1. 1. 1. 1.]]]

numpy.random.rand()

El método numpy.random.rand() se emplea para crear Array de múltiples dimensiones de números aleatorios. Si no se especifica un entero positivo el método retornará un valor aleatorio entre 0 y 1.

import numpy as np

a = np.random.rand()
print(a)  # 0.09949237936655553

Entregue la cantidad de valores aleatorios (entre 0 y 1) que desea tener en un Array unidimensional

import numpy as np

a = np.random.rand(7)
print(a)
# [0.76613867 0.8384363  0.68705556 0.49002269
#  0.55534054 0.5092379 0.79798576]

Entregue más valores separados por coma para agregar dimensiones al Array.

import numpy as np

a = np.random.rand(3, 3)
print(a)
# [[0.66258561 0.26968847 0.17829863]
#  [0.21181838 0.67555789 0.94147602]
#  [0.32514578 0.97121012 0.33013361]]

a = np.random.rand(2, 3, 3)
print(a)
# [[[0.8612151  0.04433639 0.97362723]
#   [0.14891428 0.1376205  0.17420777]
#   [0.11034897 0.70877586 0.67758112]]
#
#  [[0.58104574 0.26737466 0.7622661 ]
#   [0.51968648 0.23859014 0.26326622]
#   [0.30713093 0.88088396 0.06286815]]]

numpy.random.randint()

El método numpy.random.randint() se emplea para generar Array de múltiples dimensiones de números aleatorios. Recibe un intervalo semiabierto que identifica el rango del número a escoger de forma aleatoria; opcionalmente recibe una tupla (o lista) como tercer argumento para definir la cantidad o dimensiones para el Array.

import numpy as np

a = np.random.randint(-9, 1000, (2, 2, 3))
print(a)
# [[[ 64 716 371]
#   [394 703 326]]
#
#  [[274 621 169]
#   [573 521 674]]]

Creación automática de arrays
Tenemos algunos métodos en NumPy para crear arrays de manera automática:

• np.arrange(a,b,c) → crea una array que inicia en a finaliza en b (excluyente) y da saltos de c en c (parámetro opcional)
• np.zeros(dims) → crea un array de ceros de acuerdo a las dimensiones dadas
• np.ones(dims) → crea un array de unos de acuerdo a las dimensiones dadas
• np.linspace(a,b,n_datos) → crea un vector que inicia en a finaliza en b y contiene n|_datos
• np.eye(n) → crea una matriz identidad de dimencion n
• np.random.rand(est) → devuelve un array aleatorio con la estructura dada (en tupla)
• np.random.randint(i,f,est) → crea un arreglo aleatorio de números enteros dado i: inicio f: fin y est:estructura en tupla

Un array de numpy y un array normal de python son lo mismo ?

No necesariamente. Un array de NumPy es una estructura de datos que se utiliza para almacenar y manipular datos numéricos de manera eficiente en Python. Los arrays de NumPy son muy similares a los arrays de otros lenguajes de programación, como C o Fortran, y se utilizan ampliamente en el área de la ciencia de datos y el análisis numérico.

Por otro lado, los arrays de Python son una estructura de datos incluida en el lenguaje de programación Python desde su versión 3.3. Los arrays de Python son similares a los arrays de NumPy en términos de estructura y funcionalidad, pero son más limitados en términos de rendimiento y capacidad. Los arrays de Python son adecuados para el almacenamiento y manipulación de datos numéricos de tamaño pequeño a mediano, pero para conjuntos de datos más grandes y tareas más exigentes en términos de rendimiento, es mejor utilizar un array de NumPy.

En resumen, aunque los arrays de NumPy y Python tienen algunas similitudes, hay algunas diferencias importantes en términos de rendimiento y capacidad. Es recomendable utilizar arrays de NumPy para tareas de ciencia de datos y análisis numérico, mientras que los arrays de Python pueden ser adecuados para tareas más simples y de menor escala.

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 

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.

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

Me parece interesante el uso de estos componentes. Seran muy utiles para el desarrollo de nuestro trabajo como profesionales.

import numpy as np

list_arr = np.arange(0,10) #Se puede agregar steps
print(list_arr)

zeros_arr = np.zeros(3) #Crea una matriz de ceros
print(zeros_arr)

ones_arr = np.ones(3) #Crea una matriz de unos
print(ones_arr)

distributed_arr = np.linspace(0, 10, 10) #Crea una matriz con la cantidad que necesitamos
print(distributed_arr)

diagonal_arr = np.eye(10) #Crea una matriz diagonal
print(diagonal_arr)

random_arr = np.random.rand() #Crea un array con datos aleatorios
print(random_arr)

random_int_arr = np.random.randint(0,10) #Genera un escalar aleatorio entre a y b
print(random_int_arr)

random_int_matrix = np.random.randint(0,10,(10,10)) #Genera un array con ints aleatorios de un dimension personalizada
print(random_int_matrix)

✅

Aqui les comparto mis apuntes que tengo, sobre NumPy
https://colab.research.google.com/drive/1c3BKU9GYqDosk9bBpJemceXpYmgQKL2H?usp=sharing

tensor=[[[1,2,3],[4,5,6],[7,9,8]],[[1,2,6],[2,6,7],[9,10,34]],[[42,3,8],[50,10,2],[3,9,10]]]
tensor=np.array(tensor)
tensor.ndim

expansion=np.array(tensor,ndmin=6)#reduccion de dimensiones

reduction=np.squeeze(expansion)
print(reduction)
reduction.ndim
print(expansion)
expansion.ndim

5. Creando arrays

import numpy as np

numeros = list(range(10))

np.arange(0,20,2) # crea un array desde la posicion que yo le indique hasta la que yo quiera con o sin step

np.zeros((10,10)) # define un array compuesto por ceros, util en ds para crear esquemas

np.ones((10,5)) # define lo mismo que zeros pero con unos

np.linspace(0,10,10) # define arrays desde un rango inferior hasta un rango superior

np.eye(4) # crea matriz con parametros diagonales de 1

np.random.rand() # genera un valor aleatorio entre 0 y 1

np.random.rand(4) # array de 4 valores aleatorios entre 0 y 1

np.random.rand(4,4) # array matricial de 4x4

np.random.randint(1,15) # aleatorio entero entre

np.random.randint(1,100,(10,10)) # arrays de la dimension que quiera de enteros según la dimensión que quiera

Vectores mas rapidos:

• Aleatorio:

np.random.randint(1,10,(10)) #Inicio,fin,dimension
np.random.rand(4,4) #Dimension, aleatorio de 0 a 1

• De un valor a otro

np.arange(0,20,2)  #Inicio,fin,pasos
np.linspace(0,10,100) 

Matrizes mas rapidos:

• Aleatorio

np.random.randint(1,10,(10,10)) #Inicio,fin,dimension
np.random.rand(4,4) #Dimension, aleatorio de 0 a 1

CORREGIR: en la descripcion donde dice: “También podemos crear una matriz con una diagonal de 1 y el resto de 9.” en vez de 9 es cero

Que interesante crear arrays en diferentes dimensiones con numeros aleatorios.

este se ve un poco mas practico

Creacion de matriz indentidad con numpy

Explicación de que es np.arange

#crear un entero aleatorio entre el 1 y el 10

np.random.randint(1, 10)

#crear escalar aleatorio

np.random.rand()

#crear array aleatorio con 10 numeros

np.random.rand(10)

#crear matriz aleatoria con 10 x 10 numeros

np.random.rand(10, 10)

#crear una matriz aleatoria de 3x2 con numeros enteros del 1 al 10

np.random.randint(1, 10, (3, 2))

ejercicios:

a = 3
np.random.randint(2,4) # numero entero aleatorio entre 2 y 4
np.random.randint(0,5) # numero entero aleatorio entre 0 y 5
np.random.randint(100,400) # numero entero aleatorio entre 100 y 400
np.random.randint(10,50,15) # 15 numeros enteros aleatorios entre 10 y 50
np.random.randint(0,1000000,50) # 50 numeros enteros aleatorios entre 0 y 1.000.000
np.random.randint(0,100,(10,8)) # 80 numeros aleatorios de 0 a 100 en un array de 10 filas X 8 columnas
np.random.randint(0,2,(20,3)) # 60 numeros enteros aleatorios entre 0 y 2, en un array de 20 filas X 3 columnas
np.random.randint(0,5,(a,4,2)) # 24 numeros enteros aleatorios entre 0 y 5 en 3 array de 4 filas X 2 columnas = 24 numeros (3*4*2)
np.random.randint(0,10,(4,5,a)) # numeros enteros aleatorios entre 0 y 10 en 4 array de 5 filas X 3 columnas = 60 numeros (4*5*3)

Especificando en cada parámetro se lee bonito bonito

np.random.randint(low=1, high=5, size=(3,3), dtype=np.int64)

Resultado

array([[3, 1, 3],
       [3, 4, 4],
       [3, 1, 1]])

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

np.random.randint(0, 500,5) 

rray([ 80, 121, 226, 300, 104])

Me gusto esta clase

Mi nueva religión, es tan bella.

np.eye(n)

Me encanta como se esta organizando este curso, el anterior parecio un poco desordenado y ambiguo al abarcar muchos conceptos sin explicarlos completamente.

En np.linspace existe un parámetro llamado endpoint que modifica ligeramente su comportamiento.

np.linspace(0,10,10, endpoint=False)
[O] array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])

np.linspace(0,10,10, endpoint=True)
[O] array([ 0.        ,  1.11111111,  2.22222222,  3.33333333,  4.44444444,
        5.55555556,  6.66666667,  7.77777778,  8.88888889, 10.        ])

Dejo mis apuntes: aqui es de mi repositorio en Github

Notas que tomé durante la clase, con su documentación.
documentación

De gran ayuda usar estas funciones

Excelente clase!