No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Creando arrays

5/24
Recursos

Numpy nos da varios m茅todos muy eficientes para poder crear arrays desde 0.

Este m茅todo de 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 igual manera, tenemos np.ones()

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

np.linspace() Permite generar una array definiendo un inicio, 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.]])

Otro m茅todo 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 tambi茅n generar n煤meros enteros.
En este caso n煤meros enteros entre el 1 y 14

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

Tambi茅n podemos llevarlos a una estructura definida.

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

Contribuci贸n creada por: Edward Giraldo.

Aportes 44

Preguntas 6

Ordenar por:

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

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

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!

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

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

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.

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

MIS APUNTES #6 (NOTION + NOTAS CORNELL)


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. 馃槂

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!

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: 鈥淭ambi茅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 鈥渘p.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.        ])

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

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!