Fundamentos pr谩cticos

1

Aplica Platzidoro en este curso y asegura el 茅xito de tu aprendizaje

2

Los fundamentos de machine learning que aprender谩s

3

Introducci贸n a Numpy

4

Introducci贸n y manipulaci贸n de datos con Pandas

5

Introducci贸n a ScikitLearn

6

Comandos b谩sicos de las librer铆as usadas en el curso (Numpy, Pandas y ScikitLearn)

Regresi贸n Lineal y Log铆stica

7

驴Qu茅 es la predicci贸n de datos?

8

Sobreajuste y subajuste en los datos

9

Regresi贸n lineal simple y regresi贸n lineal m煤ltiple

10

Regresi贸n lineal simple con Scikit-Learn: divisi贸n de los datos

11

Regresi贸n lineal simple con Scikit-Learn: creaci贸n del modelo

12

Regresi贸n log铆stica con Scikit-Learn: definici贸n y divisi贸n de datos

13

Regresi贸n log铆stica con Scikit-Learn: evaluaci贸n del modelo

14

Matriz de confusi贸n

15

PlatziDoro C谩psula 1

脕rboles de decisi贸n

16

驴Qu茅 es un 谩rbol de decisi贸n y c贸mo se divide?

17

Comprendiendo nuestro data set para la creaci贸n de un 谩rbol de decisi贸n

18

Creando un clasificador con Scikit-Learn

19

Entrenamiento del modelo de clasificaci贸n

20

Visualizaci贸n del 谩rbol de decisi贸n

K-Means

21

驴Qu茅 es K-Means?

22

Cargando el data set de Iris

23

Construcci贸n y evaluaci贸n del modelo con K-Means

24

Graficaci贸n del modelo

25

PlatziDoro C谩psula 2

Aprendizaje profundo

26

Introducci贸n al aprendizaje profundo

27

Conceptos b谩sicos de Tensor Flow

28

Red neuronal convolucional

29

Conociendo el set de datos para la creaci贸n de la red neuronal

30

Crea y entrena tu primera red neuronal convolucional con Tensor Flow

31

Evaluaci贸n de la red convolucional

32

PlatziDoro C谩psula 3

Despedida

33

Recomendaciones para analizar correctamente tu problema

34

Siguientes pasos para continuar aprendendiendo de Machine Learning

Introducci贸n a Numpy

3/34
Recursos
Transcripci贸n

Aportes 132

Preguntas 9

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Reg铆strate o inicia sesi贸n para participar.

por si a alguien mas le ocurre, al poner solamente el c贸digo type(ones) me regresa un error, me termino funcionando poniendo:

type(np.ones(()))

Aporte sencillo

headers = [('nombre','S10'), ('edad', int), ('nacionalidad','S100')]
data = [('Amelie',21,'Francesa'), 
         ('Valerie', 30,'Canadiense'),
         ('Valentina',25,'Inglesa'),
         ('Alejandra',22,'Cubana')]
users = np.array(data,dtype=headers)
np.sort(users, order = 'nacionalidad')```

Resultado:



array([(b鈥橵alerie鈥, 30, b鈥機anadiense鈥), (b鈥橝lejandra鈥, 22, b鈥機ubana鈥),
(b鈥橝melie鈥, 21, b鈥橣rancesa鈥), (b鈥橵alentina鈥, 25, b鈥橧nglesa鈥)],
dtype=[(鈥榥ombre鈥, 鈥楽10鈥), (鈥榚dad鈥, 鈥<i8鈥), (鈥榥acionalidad鈥, 鈥楽100鈥)])```

鈥嬧婲umpy (Numerical Python)Biblioteca de Python sencilla de usar y muy r谩pida, adecuada para el manejo de arreglos (谩lgebra lineal).

  • Es necesario tenerla instalada para usarla (en caso de usar Colab este paso ya est谩 hecho)
  • Hay que importar la librer铆a en nuestro c贸digo:
import numpy as np
  • La biblioteca trabaja principalmente con arreglos (vectores, matrices y tensores). Para declarar un arreglo escribimos:
np.array(<arreglo>)
  • Podemos asignar una cabecera a nuestros valores de la siguiente manera:
cabecera = [('nobre_datos',tipo_datos)]
datos = [(data)]
arreglo = np.array(datos,dtype=cabecera)

#ejemplo:
headers = [('Nombre', 'S10'),('edad',int),('pa铆s','S15')]  #'S10' significa string de tama帽o 10
data = [('Manuel',12,'Bolivia'),('Jose',10,'Paraguay'),('Daniel',5,'Venezuela'),('Ivon',30,'Chile'),('Lupe',28,'Mexico')]
people = np.array(data,dtype=headers)
  • Para tomar parte de un arreglo usamos slice notation (de manera similar a las listas):
mi_arreglo = np.array([1,2,3],[4,5,6],[7,8,9])
mi_arreglo[1][1] #devuelve 5
mi_arreglo[1:] #devuelve la segunda y tercera fila
  • Comandos utiles.
    • np.zeros(<dimension>) 鈫 crea un arreglo de dimensi贸n indicada con todos los valores iguales a 0
    • np.ones(<dimension>) 鈫 crea un arreglo de dimensi贸n indicada con todos los valores iguales a 1
    • np.linspace(<inicio>,<fin>,<n_datos>) 鈫 crea un arreglo de n datos igualmente espaciados con un inicio y fin indicados
    • <arreglo>.ndim 鈫 devuelve la dimensi贸n del arreglo
    • np.sort(arreglo) 鈫 devuelve el arreglo ordenado (en caso de tener encabezado se puede usar el atributo order=鈥<nombre_dato>鈥)
    • np.arrange(<inicio>,<fin>,<pasos>) 鈫 crea un arreglo con inicio y fin dado aumentando el paso
    • np.full(<dimension>,<valores>) 鈫 crea un arreglo de la dimensi贸n data cuyos componentes son llenados con los valores
    • np.diag(<diagonal>,<k>) 鈫 crea una matriz diagonal con los valores dados (k es opcional y determina el n煤mero de columnas (signo negativo) o filas(signo positivo) a aumentar en caso de que la matriz no sea cuadrada)

me gusto esta clase veo que son los fundamentos necesario par crear matrices de varias dimensiones al igual que las dimensiones en el plano cartesiano estas se crean en X, Y y Z creando valores en cada uno de los planos. algunos de estos comandos son:

1). hacer el llamado de la librer铆a de numpy y reasignar al valor np con:
import numpy as np

2). crear arreglos en una dimensi贸n o como yo lo entend铆 crear listas con:
np.array([valores ])

3). agregar esa lista a un valor
a= np.array([鈥榲alores鈥)]

4). buscar valores en esos arreglos con:
a=[1:] o a[1::]

5). crear matrices de varias dimensiones con zero y uno con:

una dimensi贸n np.zeros(5) o np.ones(5)
dos dimensiones np.zeros((4,5)) o np.ones((4,5)
tres dimensiones np.zeros(((4,5,6))) o np. ones(((4,5,6)))

6). crear matrices con intervalos y limites:

np.linspace(limite inferior, limite superior, numero de valores)

7). como saber cuantas dimensiones tiene una variable:
b.ndim

8). para ordenar:

np.order

9). crear un rango con sus limites y intervalos:

np.arange (limite inferior, limite superior, y intervalo)

10). crear un matriz con un valor con varias dimensiones:

np.full((cantidad en la primera dimensi贸n, cantidad en la segunda dimensi贸n) valor en todas ellas )

11). crear matrices con el orden de los valores en diagonal

np.diag([valores]

Cuando inici茅 a llevar cursos en Platzi, pensaba 鈥溌縋or qu茅 no editan los videos como todas las dem谩s plataformas para omitir la parte donde comete un error el profesor y dejan un video m谩s limpio?鈥

Con el tiempo me fui dando cuenta de que es m谩s 煤til para todos nosotros observar, incluso compartir o vivir el error del profesor y resolverlo con su gu铆a a omitirlo y que tal vez el alumno cometa el mismo error pero no sepa c贸mo resolverlo s贸lo.

Me doy cuenta de que se requiere mucha humildad y fuerza de todos los profesores de Platzi para aceptar los errores y hacernos aprender a todos nosotros de ellos

Import numpy as np
import pandas as pd

cabeceras = [('Name', 'S10'), ('Age', int), ('Country', 'S10')]
datos = [('Juan', 10, 'Colombia'), ('Maria', 70, 'Argentina'), ('Javier', 42, 'Ecuador'), ('Samuel', 15, 'Argelia')]
usuarios = np.array(datos, dtype = cabeceras)
np.sort(usuarios, order = 'Country')

df = pd.DataFrame()
df['Name'] = datos[0]
df['Age'] = datos[1]
df['Country'] = datos[2]

un dato curioso para los que ya conozcan la biblioteca pandas. Si se usa el comando pd.DataFrame() para el ultimo array en el ejemplo de edad y nombre, hace que estos valores sean los nombres de las columnas y tengamos un dataframe hecho a pie.

En GeeksForGeeks pueden encontrar un muy buen tutorial sobre Numpy.

Bueno aqu铆 comparto mi c贸digo y resultado correspondiente:

import numpy as np
cabeceras = [('nombre', 'S10'), ('edad', int), ('pais', 'S15')]
datos = [('Juan', 10, 'Brasil'), ('Maria', 70, 'Colombia'), 
         ('Javier', 42, 'Peru'), ('Samuel', 70, 'Italia')]
usuarios = np.array(datos, dtype = cabeceras)

np.sort(usuarios, order = ('edad','pais'))

Lo que quer铆a ordenar era primero por edad y despu茅s por pa铆s si ten铆an las misma edad

array([(b'Juan', 10, b'Brasil'), (b'Javier', 42, b'Peru'),
       (b'Maria', 70, b'Colombia'), (b'Samuel', 70, b'Italia')],
      dtype=[('nombre', 'S10'), ('edad', '<i8'), ('pais', 'S15')])

Te dejo algunos atajos de teclado muy 煤tiles para Colab y Jupyter:

  • Ejecutar bloque actual: shift + enter
  • Ejecutar todas las celdad del cuaderno: ctrl + F9
  • Ejecutar selecci贸n: ctrl + shift + enter
  • Ejecutar las celdas anteriores a la actual: ctrl + F8

Los dem谩s se pueden ver en la pesta帽a de Herramientas/Combinaciones de Teclas o presionando la combinaci贸n ctrl + M H

batalle pero pude 馃槃

Escribiendo esto:

np.full((3,3,3),10)

Me sale esto:

array([[[10, 10, 10],
[10, 10, 10],
[10, 10, 10]],

   [[10, 10, 10],
    [10, 10, 10],
    [10, 10, 10]],

   [[10, 10, 10],
    [10, 10, 10],
    [10, 10, 10]]])

Aqui esta mi aporte!!!

鈥媊``

<h1>sort por un parametro espeficifico with three dimension array</h1>

athlete = [(鈥榥ame鈥, 鈥楽10鈥), (鈥榓ge鈥, int), (鈥榮port鈥, 鈥楽10鈥)]
data = [(鈥楯uan鈥, 25, 鈥榖alomano鈥), (鈥楳ichael鈥, 33, 鈥榥atacion鈥), (鈥楽erena鈥, 42, 鈥榯enis鈥), (鈥楢lsonso鈥, 38, 鈥榝1鈥)]
users = np.array(data, dtype = athlete)

np.sort(users, order = 鈥榮port鈥)

array([(b鈥橨uan鈥, 25, b鈥檅alomano鈥), (b鈥橝lsonso鈥, 38, b鈥檉1鈥),
(b鈥橫ichael鈥, 33, b鈥檔atacion鈥), (b鈥橲erena鈥, 42, b鈥檛enis鈥)],
dtype=[(鈥榥ame鈥, 鈥楽10鈥), (鈥榓ge鈥, 鈥<i8鈥), (鈥榮port鈥, 鈥楽10鈥)])

Mi reto鈥

cabecera = [('nombre', 'S15'), ('edad', int), ('Pais' , 'S15') ]
datos = [('Lance', 77, 'Estadonidese'), ('Joseph ', 48,'Estadonidese'), ('Jun', 30,'Chino'), ('Brenda', 59,'Espaniola'), ('Charles', 28,'Mexicana'), ('Juan', 51,'Mexicana'), ('Sean', 19,'Groenlandia'), ('Joan', 47,'Brasilenia')]
usuarios = np.array(datos, dtype=cabecera)

np.sort(usuarios, order= 'nombre')

Reto:

este es mi c贸digo

import numpy as np

cabeceras = ([("nombre","S20"), ("edad",int), ("pais","S10")])
datos = [("Rafael",20,"Mexico"), ("Luis",18,"Colombia"), ("Pedro",36,"Argentina")]
usuarios = np.array(datos, dtype = cabeceras)

np.sort(usuarios, order = "nombre")```

Me gusta la forma de explicar

cabecea=[('nombre','S10'), ('edad', int),('pais','S5')]
datos=[('juan',10, 'arg'),('paula',21,'colmbia'),('juancuerz',66,'EEUU')]
usuarios = np.array(datos,dtype=cabecea)


np.sort(usuarios,order='pais')```

buenas noches aqu铆 esta mi reto, sin embargo cuando le doy imprimir los datos de nombre y pa铆s no aparecen, me podr铆an colaborar con el error, muchas gracias

import numpy as np

cabecera = [("nombre", "str"), ("edad", int), ("pais", "str")]
datos = [[[("maria", 25, "Colombia")],[("juan", 22, "ecuador")], [("camilo", 5, "Mexico")]]]
usuarios = np.array(datos, dtype=cabecera)

np.sort(usuarios, order ="pais")

array([[[('', 25, '')],
        [('', 22, '')],
        [('',  5, '')]]],
      dtype=[('nombre', '<U'), ('edad', '<i8'), ('pais', '<U')])

usuarios.ndim

3

No deber铆an explicar numpy ni pandas en cursos como este o posteriores, si est谩s en este curso se supone que ya has hecho cursos anteriores donde ya se ha explicado esto muchas veces.

Para definir los tipos de los arreglos, si queremos usar 鈥楽tring鈥 es mejor usar 鈥楿10鈥 que 鈥楽10鈥 seg煤n la documentaci贸n de Numpy. 鈥楿鈥 se define para cadenas unicode mientras que 鈥楽鈥 se define para una secuencia de bytes distintos de 0.
https://numpy.org/devdocs/reference/arrays.dtypes.html

Challenge

headers = [(鈥榥ame鈥, 鈥楽10鈥), (鈥榓ge鈥, int)]
data = [[[(鈥楯oaquin鈥, 72), (鈥楢nne鈥, 32)], [(鈥楨dd鈥, 31), (鈥楢vril鈥, 33)]],[[(鈥楯uan鈥, 52), (鈥楢na鈥, 36)], [(鈥楧avid鈥, 54), (鈥楢licia鈥, 84)]]]
users = np.array(data, dtype=headers)

np.sort(users, order=鈥榓ge鈥)

cabecera= [(鈥淣ombre鈥,鈥楽10鈥),(鈥渆dad鈥, int),(鈥減ais鈥,鈥楽10鈥)]
datos=[(鈥渆merson鈥,10, 鈥渃olombia鈥),(鈥渏una鈥,12,鈥渕exivo鈥),(鈥渆mmanuel鈥,21,鈥渃olombia鈥),(鈥渟ara鈥,21,鈥渃olombia鈥),(鈥渃arlos鈥,26,鈥淯USS鈥),(鈥渢ucan鈥,27,鈥淯USS鈥)]
arreglo=np.array(datos,dtype=cabecera)
print(np.sort(arreglo,order= 鈥渆dad鈥))

headers = [('nombre','S10'),('pais','S20'),('edad',int)]
datos = [('Eday','COL',32), ('Veronica','BRA',31), ('Chris','AUS',3)]
usuarios = np.array(datos, dtype=headers)

np.sort(usuarios,order='edad')
np.sort(usuarios,order='nombre')

exercice

#sort by atributes
headers = [ ('nombre', 'S10'), ('edad', int), ('nacionalidad', 'S10')]
data = [('Juan', 50, 'Peruvian'), ('Maria', 70,'Brazilian'), ('Javier', 42, 'Colombian'), ('Samuel', 15, 'Chilean')]
users = np.array(data, dtype= headers)
UsersSort =  np.sort(users, order='nacionalidad')
print(UsersSort) 

Podemos jugar con el comando np.full por ejemplo con:

np.full ((3,5), [['a'], ['b'], ['c']])

Lo que nos dar谩 una letra diferente en cada fila

Por si alguien gusta revisar el porque de np.array(<serie>, dtype = )
https://numpy.org/doc/stable/reference/arrays.dtypes.html

Reto:

cabeceras = [ ('nombre', 'S10'), ('pais', 'S10'), ('edad', int) ]
datos = [ ('Juan', 'Bolivia', 18), ('Pedro', 'Bolivia', 21), ('Andres', 'Ecuador', 25), ('Pepe', 'Brasil', 35) ]
usuarios = np.array(datos, dtype = cabeceras)

np.sort(usuarios, order = 'edad')

Reto terminado !
head=[(鈥榥ombre鈥,鈥楽10鈥),(鈥榚dad鈥,int),(鈥榩ais鈥,鈥楽10鈥)]
data=[(鈥榟iro鈥,23,鈥榩eru鈥),(鈥榖ea鈥,23,鈥榩eru鈥),(鈥榡ose鈥,27,鈥榲enuezuela鈥),(鈥榯aisa鈥,24,鈥榖razil鈥),(鈥榓ntonela鈥,25,鈥榓rgentina鈥)]
user=np.array(data,dtype=head)
np.sort(user,order=鈥榩ais鈥)

#Challenge: create an 3 dimensions array (name, age and country) and sort it

header = [ ('name', 'S10' ), ('age', int), ('country', 'S10') ]
data = [ ('Felipe', 30, 'Colombia'), ('Angelica', 25, 'Canada'), ('Nhaga', 5, 'Francia'), ('Squirtle', 21, 'Australia') ]
users = np.array(data, dtype = header)

np.sort(users, order = 'name' )

#output
#array([(b'Angelica', 25, b'Canada'), (b'Felipe', 30, b'Colombia'),
#       (b'Nhaga',  5, b'Francia'), (b'Squirtle', 21, b'Australia')],
 #     dtype=[('name', 'S10'), ('age', '<i8'), ('country', 'S10')]) 

Aqu铆 mi soluci贸n al reto:

Reto:
import numpy as np
#Reto Array de 3 dimensiones
cabeceras = [(鈥榥ombre鈥,鈥楽100鈥),(鈥榤onto鈥,int),(鈥楳oneda鈥,鈥楽10鈥)]
datos = [(鈥楴ativo Digital鈥,70000,鈥楤olivianos鈥),
(鈥楳igrante Digital鈥,5000,鈥楧olares鈥)]
productos = np.array(datos, dtype=cabeceras)
print(np.sort(productos,order=鈥榤onto鈥))

cabeza = [('nombre','S15'),('edad',int),('pais','S10'),('grado academico',int)]

data = [('Juan',10,'Colombia',5),('Ana',15,'Ecuador',10),('Ariel',18,'Atlantida',11),('Estebandido',8,'Mexico',4)]

compac = np.array(data, dtype=cabeza)

uno = np.sort(compac, order='nombre')
dos = np.sort(compac, order='edad')
tres = np.sort(compac, order='pais')
cuatro = np.sort(compac, order='grado academico')

Reto
Creamos los datos con sus respectivas cabeceras

headers = [('name', 'S10'), ('age', int), ('salary', float)]
data = [('Juan', 10, 10.0), ('Maria', 70, 100.000), ('Xavier', 25, 33.500), ('Jose', 18, 6.000)]
users = np.array(data, dtype=headers)
print(users)

Y ordenamos:

np.sort(users, order='salary')
np.sort(users, order='age')
np.sort(users, order='name')

Nota: Numpy no tiene mayor problema con ordenar strings.

Fue una clase ardua, pero se logr贸 馃槃

Comparto el reto resuelto:

header=[('Nombre', 'S20'), ('Edad', int), ('Pais', 'S20')]
data=[('Diego', '22', 'Mexico'),('Yecely', '40', 'Mexico'),('Arcadio', '30', 'Colombia')]
users=np.array(data, dtype=header)

np.sort(users, order='Pais')

Recordando siempre que nos ense帽贸 el poderos铆simo profe Facundo que es importante procurar programar en ingl茅s n.n

隆Hola! Aqu铆 la soluci贸n al reto 馃槂

cabecera = [('Nombre', 'S10'), ('Edad', int), ('Pais', 'S10')] #Qu茅 significa S10? R/. Que el valor no puede tener mas de 10 caracteres
datos = [('Santiago', 19, 'Estados Unidos'), ('Emmanuel', 19, 'Alemania'), ('Daniela', 19, 'Italia'), ('Andres', 19, 'Brasil')]
manito = np.array(datos, dtype = cabecera)
np.sort(manito, order = 'Pais')

Agrego una partecita de mis apuntes 隆Saludos!

Dejo el reto

headers = [('nombre','S10'), ('edad',int), ('pais','S10')]
data = [('Elias', 22, 'Venezuela'), ('Paul', 28, 'Argentina'),
        ('Erick', 35, 'Mexico'), ('Amparo', 30, 'Uruguay')]
users = np.array(data, dtype=headers)

np.sort(users, order='pais')

Les traigo mi reto, recuerden que pueden filtrar palabras con acento cambiando su estructura, espero les guste. : )

# Challenge
cabeceras = [('nombre', 'U10'), ('edad','i8'), ('pa铆s','U10')]

datos = [('Juan',10,'M茅xico'), ('Mar铆a',70,'Argentina'), ('Javier',42,'Brazil'), ('Samuel',15,'Per煤')]

usuarios = np.array(datos, dtype = cabeceras)

ageFilter    = np.sort(usuarios, order = 'edad')

contryFilter = np.sort(usuarios, order = 'pa铆s')

nameFilter   = np.sort(usuarios, order = 'nombre')

print(f'''
        filter by name
      {[(usuario['nombre']) for usuario in nameFilter]}
      {list(map(lambda usuario: usuario['nombre'],nameFilter))}
        
        filter by age
      {[(usuario['edad']) for usuario in ageFilter]}
      {list(map(lambda usuario: usuario['edad'],ageFilter))}
        
        filter by country
      {[(usuario['pa铆s']) for usuario in contryFilter]}
      {list(map(lambda usuario: usuario['pa铆s'],contryFilter))}
      ''')

np.dialog , es una 煤til para trabajar con matrices. es tan sencillo como escribir: np.diag([0,3,6,9,12]), y autom谩ticamente nuestro array har谩 una diagonal

Si no queremos hacer un array con n dimensions, con solo unos o ceros, entonces es momento de utilizar full, para que podamos usar pr谩cticamente los mismo que ones and zeros, pero tenemos que agregar que n煤mero queremos repetir al infinito.

El arange nos permite usarlo pr谩cticamente como un range normal.

tambi茅n podemos crear listas a modo de un range cl谩sico, con: np.arange(23)

Para que nuestro array compuesto por dos listas en las que una contiene las columnas y su tipo de dato y otra los datos, entonces: np.array(datos, dtype = cabecera)

Tambi茅n podemos organizar varias listas en un arreglo, pasando c贸mo par谩metros dos listas ya definidas, luego para ordenar estas listas, utilizamos el m茅todo sort, con varios par谩metros: 1. la lista que le pasamos 2. Le pasamos el par谩metro order = "Nuestro inter茅s" es decir, el valor por el que queremos que est茅n ordenados.

El atributo ndim, nos muestra las dimensiones de un array.

linspace, es bueno para la creaci贸n de gr谩ficas.

el m茅todo linspace((2,8,10)) nos permite hacer un vector, con un n煤mero inicial, luego el n煤mero de datos que queremos, y n煤mero m谩ximo.

Es sencillo crear un arreglo de dos dimensiones con el m茅todo array: var = np.array[ [12,"Buenas", "Tardes"], [34,67,125]] Esto nos ayuda a crear un array ndarray.

Si declaras una variable a un ndim array, entonces te toca hacer un doble 铆ndice para acercarte a un elemento.

Para hacer arrays con varias dimensiones, es tan sencillo como poner: np.ones((R,C)) para definir n煤meor de filas y n煤mero de col煤mnas.

para crear un array, es tan f谩cil como utilizar el m茅todo array de np o Numpy: np.array([12,15,63,721])

Numpy es sencilla, adecuada para el manejo de arreglos y adem谩s tenemos eficiencia.

Numpy, es muy buena para la ciencia de datos, pero indirectamente tambi茅n para el maching learning.

Ejercicios de la clase

import numpy as np

#NUMPY permite agilizar el uso de arrays

print( "np.array:", np.array([10, 20, 30 ,40 ,50]) )

a = np.array([10,15,89,70,36,45])
print("indice fijo:", a[4] )
print("desde un indice hasta el final:", a[3:] )
print("desde un indice a otro:", a[3:7] )
print("desde un indice en saltos de 4:", a[0::4] )
print("arrays 0:", np.zeros(5) )
print("matriz de 0 (4,5)", np.zeros((4,5)) )
print("matriz de 1 (3,5):", np.ones((3,5)) )

print("mostrar el tipo:", type(np.ones(3)))

print("numeros decimales aleatorios", np.linspace(3, 10, 5))

b = np.array( [['x','y','z'],['a','b','c']] )
print("matriz 2 dimensiones:",b)
print("numero de dimensiones:",b.ndim)

c = [12, 4, 10, 40, 2]
print("array ordenado:", np.sort(c))

cabecera = [('nombre','S10'), ('edad', int)]
datos = [('Juan',70), ('Maria',45), ('Javier', 10)]
usuarios = np.array(datos, dtype=cabecera)
print("ordenar array de objetos:",np.sort(usuarios, order='edad'))

print("Generar array con numeros consecutivos:",np.arange(5,30))

print("Generar array con numeros consecutivos de 5 en 5: ", np.arange(5,6,7) )

print("llenar matriz con un numero:", np.full((3,5),10))

print("generar matriz con una diagonal de numeros:", np.diag([1,3,9,10]))

cabeceras = [('nombre','S10'),('edad',int),('Pais','S100')]
datos = [('Juan', 10, 'Mexico'), ('Maria', 70, 'Colombia'), ('Javier', 42, 'Argentina')]

usuarios = np.array(datos, dtype = cabeceras)

np.sort(usuarios, order='Pais')

Resultado

array([(b鈥橨avier鈥, 42, b鈥橝rgentina鈥), (b鈥橫aria鈥, 70, b鈥機olombia鈥),
(b鈥橨uan鈥, 10, b鈥橫exico鈥)],
dtype=[(鈥榥ombre鈥, 鈥楽10鈥), (鈥榚dad鈥, 鈥<i8鈥), (鈥楶ais鈥, 鈥楽100鈥)])

cabeceras = [('nombre','S10'),('edad', int),('pais','S10')]
datos = [("Juan",10,"Mexico"),("Maria",70,"USA"),("Javier",25,"China"),("Samuel",15,"Rusia")]
usuarios = np.array(datos, dtype = cabeceras)

np.sort(usuarios, order = 'pais')

Output:
array([(b鈥橨avier鈥, 25, b鈥機hina鈥), (b鈥橨uan鈥, 10, b鈥橫exico鈥),
(b鈥橲amuel鈥, 15, b鈥橰usia鈥), (b鈥橫aria鈥, 70, b鈥橴SA鈥)],
dtype=[(鈥榥ombre鈥, 鈥楽10鈥), (鈥榚dad鈥, 鈥<i4鈥), (鈥榩ais鈥, 鈥楽10鈥)])

esta muy buena la clase creo que me hubiera servido tomarla antes ya que en varios cursos la usan pero no explican que hace cada funci贸n

驴hay forma de ordenar pero de forma inversa por ejemplo si hago una lista de empleados con sueldo y ordeno por sueldo al usar sort me ordena del empleado con menor sueldo al de mayor hay forma de que lo ordene de mayor a menor?
use este codigo para hacerlo

cabeceras = [(鈥渘ombre鈥,鈥淪10鈥),(鈥渟ueldo鈥,int)]
datos =[(鈥渓ola鈥,100),(鈥渏ose鈥,700),(鈥渓ilia鈥,420),(鈥減edro鈥,150)]
usuarios = np.array(datos,dtype=cabeceras)

np.sort(usuarios,order =鈥渟ueldo鈥)

header = [('nombre','S10'),('edad',int),('Salario',int)]
datos = [('Juan',20,2000),('Maria',19,4000),('David',23,3000),('Josue',18,1000)]
Personas = np.array(datos,dtype=header)

np.sort(Personas,order='Salario')

Resultado

array([(b鈥橨osue鈥, 18, 1000), (b鈥橨uan鈥, 20, 2000), (b鈥橠avid鈥, 23, 3000),
(b鈥橫aria鈥, 19, 4000)],
dtype=[(鈥榥ombre鈥, 鈥楽10鈥), (鈥榚dad鈥, 鈥<i8鈥), (鈥楽alario鈥, 鈥<i8鈥)])

cabeceras2 = [('nombre','S10'), ('edad',int),('Pais','S10'),('Calificacion',int)]


datos2 = [('Juan',10, 'Francia',5),('Maria',70,'Colombia',3.5),('Javier',42,'Argentina',2),('Samuel',15,'Zimbague',4)]



usuarios = np.array(datos2, dtype = cabeceras2)
print(usuarios)

ed = np.sort(usuarios, order = 'edad')
print(ed)
pa = np.sort(usuarios, order = 'Pais')
print(pa)
no = np.sort(usuarios, order = 'nombre')
print(no)

RETO

Comparto ejer_mod 3:
cabecera = [ (鈥楴ombre鈥, 鈥楽10鈥), (鈥楨dad鈥, int), (鈥楶ais鈥, 鈥楽20鈥) ]
datos = [ (鈥楶ablo鈥, 45, 鈥楥olombia鈥), (鈥楻osa鈥, 78, 鈥楶eru鈥), (鈥楯ulian鈥, 25, 鈥楿ruguay鈥), (鈥榁anesa鈥, 10, 鈥楢rgentina鈥) ]
usuarios = np.array(datos, dtype = cabecera)
np.sort(usuarios, order = 鈥楨dad鈥)

Tarea:

headers = [('name','S10'),('age',int),('nacionality','S10'),('job','S20')]
data = [('Alexander',20,'Peru','Data Science'),('Zoila',32,'Venezuela','DevOps'),('Walter',28,'Chile','Marketing'),('Julian',39,'Peru','Javascript Developer'),('Alex',20,'Peru','Cloud Computer')]
db= np.array(data,headers)
np.sort(db,order=["age","job"])
//rpt
array([(b'Alex', 20, b'Peru', b'Cloud Computer'),
       (b'Alexander', 20, b'Peru', b'Data Science'),
       (b'Walter', 28, b'Chile', b'Marketing'),
       (b'Zoila', 32, b'Venezuela', b'DevOps'),
       (b'Julian', 39, b'Peru', b'Javascript Developer')],
      dtype=[('name', 'S10'), ('age', '<i8'), ('nacionality', 'S10'), ('job', 'S20')])

Saludos a todos, este es el resultado del ejercicio

NumPy es un paquete de Python que significa 鈥淣umerical Python鈥, es la librer铆a principal para la inform谩tica cient铆fica, proporciona potentes estructuras de datos, implementando matrices y matrices multidimensionales. Estas estructuras de datos garantizan c谩lculos eficientes con matrices.

python tambien tiene un metodo de sort y la funcion sorted

Ac谩 puedes encontrar la documentaci贸n de numpy:

https://numpy.org/doc/1.18/numpy-user.pdf

Reto ordenado por pais:

cabecera = [(鈥榥ombre鈥,鈥楽10鈥),(鈥榚dad鈥,鈥榠nt鈥),(鈥榩ais鈥,鈥楽15鈥)]
datos = [(鈥楯uan鈥,10,鈥楥olombia鈥),(鈥楢ndres鈥,18,鈥楢rabe鈥),(鈥楲uis鈥,98,鈥楢leman鈥),(鈥楽antiago鈥,96,鈥榋ueco鈥)]
usuarios = np.array(datos,dtype=cabecera)

np.sort(usuarios,order = 鈥榩ais鈥)

import numpy as np

cabecera = [ (鈥榥ombre鈥, 鈥楽20鈥), (鈥榚dad鈥, int), (鈥榩ais鈥, 鈥楽20鈥) ]
datos = [ (鈥楳anolo鈥, 25, 鈥楳exico鈥), (鈥楢xel鈥, 26, 鈥楥olombia鈥), (鈥楯imon鈥, 24, 鈥楥anada鈥) ]

usuarios = np.array(datos, dtype = cabecera)

print('Ordenado por Nombre: ', np.sort(usuarios, order = 鈥榥ombre鈥))
print('Ordenado por Edad: ', np.sort(usuarios, order = 鈥榚dad鈥))
print('Ordenado por Pais: ', np.sort(usuarios, order = 鈥榩ais鈥))

este es mi codigo
encabezado = [(鈥榥ombre鈥, 鈥楽10鈥), (鈥榚dad鈥, int),(鈥榗iudad鈥, 鈥楽15鈥)]
datos = [(鈥楪loria鈥, 25,鈥楤ogota鈥),(鈥楳aria鈥, 40,鈥楥ali鈥),(鈥楯orge鈥, 36,鈥楾unja鈥)]
usuario = np.array (datos, dtype = encabezado)
np.sort (usuario, order = (鈥榚dad鈥))

mi output
array([(b'gian', b'chile'), (b'marcelo', b'mexico'), (b'jeff', b'peru')], dtype=[('nombre', 'S10'), ('Pais', 'S10')])

array([(b鈥橢nrique鈥, 39, b鈥橞olivia鈥), (b鈥橪uis鈥, 19, b鈥機olombia鈥),
(b鈥機arlos鈥, 29, b鈥橮eru鈥)],
dtype=[(鈥榥ombre鈥, 鈥楽10鈥), (鈥榚dad鈥, 鈥<i4鈥), (鈥楶ais鈥, 鈥楽20鈥)])

cabecera = [('nombre', 'S10'), ('edad', int), ('Pais', 'S20')]
datos = [('Juan', 10, 'Mexico'), ('Maria', 70, 'Peru'), ('Javier', 42, 'Chile'), ('Samuel', 15, 'Brazil')]
usuarios = np.array(datos, dtype = cabecera)

np.sort(usuarios, order = 'Pais')


array([(b'Samuel', 15, b'Brazil'), (b'Javier', 42, b'Chile'),
       (b'Juan', 10, b'Mexico'), (b'Maria', 70, b'Peru')],
      dtype=[('nombre', 'S10'), ('edad', '<i8'), ('Pais', 'S20')])

Con datos inventados pero funciona

cabecera  = [('Equipo','S15'),('A帽o',int),('Titulos',int)]
data = [('Barcelona',1916,36),('Juventus',1915,28),('Atl.Madrid',1956,16)]
np_data = np.array(data,dtype = cabecera)

np.sort(np_data,order = 'A帽o')```
cabeceras = [('nombre', 'S10'), ('pais', 'S15'), ('edad', int)]
datos = [('Camilo', 'Espania', 28), ('Pedro', 'Argentina', 35), ('Lucia', 'Uruguay', 22), ('Luna', 'Ecuador', 26)]
usuarios = np.array(datos, dtype = cabeceras)
np.sort(usuarios, order = 'edad')
usuarios```
<cabecera = [('nombre:','S10'),('apellido:','S10'),('a帽o de nacimiento',int)]
datos = [('Pablo','Torres',1999),('Luis','Quintana',1970),('Carlos','Fuentes',1980)]
usuarios = np.array(datos, dtype = cabecera)
np.sort(usuarios, order='a帽o de nacimiento')>

Comparto mi ejercicio de este capitulo.

cabecera = [ (鈥楴ombre鈥, 鈥楽30鈥 ), (鈥榓nio鈥, int), (鈥楶ais鈥, 鈥楽20鈥) ]
datos_us = [ (鈥楧iana Ramirez鈥, 1985,鈥楥olombia鈥), (鈥楯ohanita鈥, 1987, 鈥楶eru鈥), (鈥楩arouk Jimenez鈥, 1983, 鈥楢rgentina鈥), (鈥楪ing鈥, 2011, 鈥楥hile鈥) ]
usuarios = np.array(datos_us, dtype = cabecera)
np.sort(usuarios, order = 鈥榓nio鈥 )

cabeseras = [ ('nombre', 'S10'), ('apellido','S15'), ('edad', int) ]
datos = [ ('Maria','Perez', 30), ('Luis', 'Rios', 24), ('Andres', 'Lopez', 70) ]
usuarios = np.array( datos, dtype = cabeseras)


np.sort(usuarios, order= 'nombre')

heads = [('nombre', 'S10'), ('edad', int), ('Pais','S10')]
data = [('Juan',10, 'Colombia'), ('Maria', 70, 'Chile'), ('Javier', 42, 'Canada'), ('Samuel', 15, 'Colombia')]
users = np.array(data, dtype=heads)

np.sort(users, order = 'Pais')```

Hola cuando le doy type(ones) o type(ones[3]) me salen errores como
NameError: name 鈥榦nes鈥 is not defined a q se debe

cabeceras = [('Nombre', 'S10'), ('Edad', int), ('Pais', 'S10')]
datos = [('Miguel', 18, 'Mexico'), ('Arturo', 65, 'Peru'), ('Rocio', 10, 'Tunez'), ('Amber', 8, 'Rusia')]

usuarios = np.array(datos, dtype= cabeceras)
np.sort(usuarios, order='Pais')

headers = [('nombre','S10'), ('edad','int'), ('country','S15')]
data = [('David','25','Colombia'), ('Dario','35','Venezuela'), ('Davo','29', 'united states'), ('Davinci','27','Mexico')]
users = np.array(data, dtype = headers)
print(users)
[(b'David', 25, b'Colombia') (b'Dario', 35, b'Venezuela')
 (b'Davo', 29, b'united states') (b'Davinci', 27, b'Mexico')]
np.sort(users, order='country')
array([(b'David', 25, b'Colombia'), (b'Davinci', 27, b'Mexico'),
       (b'Dario', 35, b'Venezuela'), (b'Davo', 29, b'united states')],
      dtype=[('nombre', 'S10'), ('edad', '<i8'), ('country', 'S15')])```

Muy buena explicaci贸n

cabeceras = [('Nombre', 'S10'), ('Edad', int), ('Pa铆s', 'S10')]
datos = [
         ('Jose', 52, 'Espana'),
         ('Eduardo', 25, 'Peru'),
         ('Antonio', 61, 'Ecuador'), 
         ('Andrea', 56, 'Chile'), 
         ('Arturo', 35, 'Venezuela')]
usuarios = np.array(datos, dtype = cabeceras)
np.sort(usuarios, order='Pa铆s')

Aqu铆 mi reto 馃槃

Reto

import numpy as np


def run():
    headers = [('Name', 'S10'), ('Age', int), ('Country', 'S20'), ('Email', 'S30')]
    data = [('Carlos', '28', 'Argentina', '[email protected]'),
            ('Felipe', '31', 'Brazil', '[email protected]'),
            ('Dana', '27', 'Colombia', '[email protected]'),
            ('Andrea', '29', 'Mexico', '[email protected]')]
    users = np.array(data, dtype=headers)
    print('*' * 60)
    print(users)
    users_order_age = np.sort(users, order='Age')
    print('*' * 60)
    print(users_order_age)
    print('*' * 60)


if __name__ == '__main__':
    run()

headers = [('nombre', 'S10'), ('edad', int), ('pais', 'S3')]
datos = [('obama', 70, 'USA'),
         ('sadam', 100, 'NN'),
         ('samurai', 40, 'CHN'),
         ('malandra', 20, 'CHL'),
         ('calceta', 34, 'ARG')]
usuarios = np.array(datos, dtype = headers)
np.sort(usuarios, order = 'edad')
header = [('name', 'S10'),('age',int), ('country', 'S15')]
data = [('Wilson',17,'Colombia'),('Alirio',42,'Canada'),('Sofia',10,'France'),('Milena',40,'Germany'),('James',56,'United States')]
users= np.array(data, dtype= header)
np.sort(users, order='country')
<h1>reto:</h1> <h1>crear array de tres dimensiones y ordenar por pais</h1>

cabeceras = [(鈥榥ombre鈥, 鈥楽15鈥), (鈥榚dad鈥, int), (鈥榩ais鈥, 鈥楽10鈥)]
datos = [(鈥楻icardo鈥, 51, 鈥楨S鈥), (鈥楻aquel鈥, 47, 鈥楨S鈥), (鈥楳ichiel鈥, 32, 鈥楴L鈥)]
personas = np.array(datos, dtype = cabeceras)

np.sort(personas, order = 鈥榩ais鈥)

cabecera=[('nombre', 'S10'),('edad',int),('pais','S10')]
datos=[('carlos',42,'brasil'),('karen',25,'paraguay'),('ana',32,'colombia')]

personas=np.array(datos,dtype=cabecera)
np.sort(personas, order= 'pais')

Llevo varios cursos de Machine Learning y es el primero que paran a explicar las funciones de las librer铆as de esta forma. Puede ser la primera clase pero pinta s煤per bien

Probe los ordenamientos con los diferentes campos: edad, name, country

header = [('name', 'S10'), ('edad', int), ('country', 'S10')]
data = [('Lolo', 23, 'Spain'), ('Lili', 11, 'Congo'), ('Lala', 45, 'Italy') ]
users = np.array(data, dtype=header)

users

np.sort(users, order='edad')
np.sort(users, order='name')
np.sort(users, order='country')```

Son cosas m铆as o esta usando jupyter notebooks

Mi reto

cabs = [('nombre','S10'),('edad',int),('pais','S5')]
vals = [('Juan',20,'USA'),('Dario',25,'AL'),('Monica',30,'AR'),('Camila',26,'ESP')]
users = np.array(vals,dtype=cabs)
np.sort(users,order='pais')```
cabeceras = [('nombre','S20'),('edad',int),('sexo','S1')]
datos = [('Sergio',21,'M'),('Camilo',17,'M'),('Yesi',30,'F')]

usuarios = np.array(datos, dtype = cabeceras)
print(np.sort(usuarios, order = 'edad'))

Matriz de identidad

matriz_identidad = np.eye(4)
cabecera = [ ('pais', 'S10'), ('moneda', 'S5'), ('poblacion', float)]
datos = [('Peru', 'PEN', 30.5), ('Ecuador', 'USD', 20), ('Colombia', 'COP', 89.34)]
usuarios = np.array(datos, dtype= cabecera)
np.sort(usuarios, order = 'poblacion')```

creo q esta des actualizado

cabeceras = [('nombre', 's10'),('edad', int)]
datos= [('juan',10),('maria', 80)]
usuarios = np.array(datos,dtype=cabeceras)
np.sort(usuarios, order='edad')

xq tengo un error