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 149

Preguntas 13

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’Valerie’, 30, b’Canadiense’), (b’Alejandra’, 22, b’Cubana’),
(b’Amelie’, 21, b’Francesa’), (b’Valentina’, 25, b’Inglesa’)],
dtype=[(‘nombre’, ‘S10’), (‘edad’, ‘<i8’), (‘nacionalidad’, ‘S100’)])```

​​Numpy (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)

Cuando inicié a llevar cursos en Platzi, pensaba “¿Por 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

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([‘valores’)]

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]

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.

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]

Reto:

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

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

Terminado el reto:

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 = [(‘name’, ‘S10’), (‘age’, int), (‘sport’, ‘S10’)]
data = [(‘Juan’, 25, ‘balomano’), (‘Michael’, 33, ‘natacion’), (‘Serena’, 42, ‘tenis’), (‘Alsonso’, 38, ‘f1’)]
users = np.array(data, dtype = athlete)

np.sort(users, order = ‘sport’)

array([(b’Juan’, 25, b’balomano’), (b’Alsonso’, 38, b’f1’),
(b’Michael’, 33, b’natacion’), (b’Serena’, 42, b’tenis’)],
dtype=[(‘name’, ‘S10’), (‘age’, ‘<i8’), (‘sport’, ‘S10’)])

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

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

Mi practica:

Reto completado

lo hice con futbol 😃

<cabeceras = [('Name', 'S10'), ('Age', int), ('goles',int)]
datos = [('messi', 35, 14), ('El BICHO', 37, 13), ('courtois', 30,1), ('pique', 35,5)]
usuarios = np.array(datos, dtype = cabeceras)
np.sort(usuarios, order = 'Age')> 

Hay que tener muy en cuenta los corchetes y las dimensiones que se quieren tener. Os dejo el ejemplo y vereis la diferencia entre 2 y 3 dimensones

dim2 = np.array(
    [
        [1, 1, 1],
        [2, 2, 2],
        [3, 3, 3]
    ]
)
print(dim2)
print(f'dim2 tiene {dim2.ndim} dimensiones')

dim3 = np.array(
  [
    [[1,1,1]],
    [[2,2,2]],
    [[3,3,3]]]
)

print(dim3)
print(f'dim3 tiene {dim3.ndim} dimensiones')

Siendo este el resultado

[[1 1 1]
[2 2 2]
[3 3 3]]
dim2 tiene 2 dimensiones
[[[1 1 1]]
[[2 2 2]]
[[3 3 3]]]
dim3 tiene 3 dimensiones

<cabeceras=[('nombre','S10'),('edad',int),('Pais','S10')]
datos=[('Juan',10,'colombia'),('Maria',70,'Argentina'),('Javier',42,'Ecuador'),('Samuel',15,'Hungria')]
usuarios=np.array(datos,dtype=cabeceras)> 

Si quisieran crear arrays o matrices con números aleatorios enteros:

# Crea un array de 5 valores con números aleatorios del 0 al 10
array = np.random.randint(10, size= 5)

# Matriz de 3x2 con valores aleatorios del 0 al 10
matriz = np.random.randint(10, size= (3, 2))

Actividad:

columnas = [('País', 'S10'), ('PIB', int), ('GINI', int)]
valores = [('Colombia', 1500, 0.7), ('Brasil', 2850, 0.5), ('Chile', 1375, 0.6)]
Macro = np.array(valores, dtype = columnas)
np.sort(Macro, order = 'GINI')
np.sort(Macro, order = 'PIB')

cabeceras = [ (‘nombre’, ‘S10’ ), ( ‘edad’, int), (‘pais’, ‘S15’) ]
datos = [ (‘Juan’, 10, ‘Ecuador’), (‘Maria’, 70, ‘Bolivia’), (‘Javier’, 42, ‘Uruguay’), (‘Samuel’, 15, ‘Colombia’)]
usuarios = np.array(datos, dtype = cabeceras)

np.sort(usuarios, order = ‘pais’)

Resultado:
array([(b’Maria’, 70, b’Bolivia’), (b’Samuel’, 15, b’Colombia’),
(b’Juan’, 10, b’Ecuador’), (b’Javier’, 42, b’Uruguay’)],
dtype=[(‘nombre’, ‘S10’), (‘edad’, ‘<i8’), (‘pais’, ‘S15’)])

dt = np.dtype([('nombre','S100'),('edad',int),('nacionalidad','S100')])

datos = [('Leandro',13,'Chilena'),('Pedro',15,'Inglesa'),('Anthony',16,'Francesa'),('Brandom',17,'Boliviano')]

personas = np.array(datos, dt)

np.sort(personas, order = ('nombre','nacionalidad','edad'))
RESULTADO
array([(b'Anthony', 16, b'Francesa'), (b'Brandom', 17, b'Boliviano'),
       (b'Leandro', 13, b'Chilena'), (b'Pedro', 15, b'Inglesa')],
      dtype=[('nombre', 'S100'), ('edad', '<i8'), ('nacionalidad', 'S100')])

Reto Cumplido

cabeceras = [ ('nombre', 'S10' ), ('edad', int), ('mesCasamiento', int) ]
datos = [ ('Juan', 10, 3), ('Maria', 70,5), ('Javier', 42,2), ('Samuel', 15, 6) ]
usuarios = np.array(datos, dtype = cabeceras)
usuarios= np.sort(usuarios, order = 'mesCasamiento' )
print(usuarios)

Me salía un error aquí, pero lo solucioné modificándolo un poco: type(np.ones([3]))

Mi reto:

Hola estoy buscando un cientifico de datos hay una convocatoria de 100 000 dolares para crypto estoy buscando mi equipo de trabajo , me pueden encontrar como SrAndersj en redes y en linkedin como o byandersj y pronto espero hagan el cambio a SrAndersj

cabeceras = [ ('nombre', 'S10' ), ('edad', int), ('Ciudad','S15') ]
datos = [ ('Juan', 10, 'Buenos Aires'), ('Maria', 70, 'Managua'), ('Javier', 42, 'Caracas'), ('Samuel', 15, 'Juigalpa') ]
usuarios = np.array(datos, dtype = cabeceras)

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

interesante esta diferencia

print(np.arange(5,50,5))# de cuanto en cuanto variará 
print(np.linspace(5, 50, 5)) # en cuantos valores sera dividivo

cabeceras = [(‘nombre’, ‘S10’), (‘edad’ , int)]
datos = [(‘boris’,51),(‘angelica’, 22),(‘Maria’, 12),(‘Arelys’, 43)]
familia = np.array(datos, dtype =cabeceras)
np.sort(familia, order = ‘edad’)

Mi solución ordenando por primer carácter de nacionalidad:

header=[('Nombre', 'S10'),('edad',int),('nacionalidad','S15')]
data=[('Maria',11,'Colombiana'),('Sasuke',17,'Japones'),('Ramon', 66, 'Mexicano'),('Mr_Beast',29,'Estadounidence'),('Naruto',17,'Japones')]
user=np.array(data, dtype=header)
np.sort(user, order='nacionalidad')

El resultado es:

array([(b'Maria', 11, b'Colombiana'),
       (b'Mr_Beast', 29, b'Estadounidence'), (b'Naruto', 17, b'Japones'),
       (b'Sasuke', 17, b'Japones'), (b'Ramon', 66, b'Mexicano')],
      dtype=[('Nombre', 'S10'), ('edad', '<i8'), ('nacionalidad', 'S15')])

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 ‘String’ es mejor usar ‘U10’ que ‘S10’ según la documentación de Numpy. ‘U’ se define para cadenas unicode mientras que ‘S’ se define para una secuencia de bytes distintos de 0.
https://numpy.org/devdocs/reference/arrays.dtypes.html

Challenge

headers = [(‘name’, ‘S10’), (‘age’, int)]
data = [[[(‘Joaquin’, 72), (‘Anne’, 32)], [(‘Edd’, 31), (‘Avril’, 33)]],[[(‘Juan’, 52), (‘Ana’, 36)], [(‘David’, 54), (‘Alicia’, 84)]]]
users = np.array(data, dtype=headers)

np.sort(users, order=‘age’)

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=[(‘nombre’,‘S10’),(‘edad’,int),(‘pais’,‘S10’)]
data=[(‘hiro’,23,‘peru’),(‘bea’,23,‘peru’),(‘jose’,27,‘venuezuela’),(‘taisa’,24,‘brazil’),(‘antonela’,25,‘argentina’)]
user=np.array(data,dtype=head)
np.sort(user,order=‘pais’)

#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 = [(‘nombre’,‘S100’),(‘monto’,int),(‘Moneda’,‘S10’)]
datos = [(‘Nativo Digital’,70000,‘Bolivianos’),
(‘Migrante Digital’,5000,‘Dolares’)]
productos = np.array(datos, dtype=cabeceras)
print(np.sort(productos,order=‘monto’))

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’Javier’, 42, b’Argentina’), (b’Maria’, 70, b’Colombia’),
(b’Juan’, 10, b’Mexico’)],
dtype=[(‘nombre’, ‘S10’), (‘edad’, ‘<i8’), (‘Pais’, ‘S100’)])

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’Javier’, 25, b’China’), (b’Juan’, 10, b’Mexico’),
(b’Samuel’, 15, b’Rusia’), (b’Maria’, 70, b’USA’)],
dtype=[(‘nombre’, ‘S10’), (‘edad’, ‘<i4’), (‘pais’, ‘S10’)])

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 = [(“nombre”,“S10”),(“sueldo”,int)]
datos =[(“lola”,100),(“jose”,700),(“lilia”,420),(“pedro”,150)]
usuarios = np.array(datos,dtype=cabeceras)

np.sort(usuarios,order =“sueldo”)

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’Josue’, 18, 1000), (b’Juan’, 20, 2000), (b’David’, 23, 3000),
(b’Maria’, 19, 4000)],
dtype=[(‘nombre’, ‘S10’), (‘edad’, ‘<i8’), (‘Salario’, ‘<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 = [ (‘Nombre’, ‘S10’), (‘Edad’, int), (‘Pais’, ‘S20’) ]
datos = [ (‘Pablo’, 45, ‘Colombia’), (‘Rosa’, 78, ‘Peru’), (‘Julian’, 25, ‘Uruguay’), (‘Vanesa’, 10, ‘Argentina’) ]
usuarios = np.array(datos, dtype = cabecera)
np.sort(usuarios, order = ‘Edad’)

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 “Numerical 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 = [(‘nombre’,‘S10’),(‘edad’,‘int’),(‘pais’,‘S15’)]
datos = [(‘Juan’,10,‘Colombia’),(‘Andres’,18,‘Arabe’),(‘Luis’,98,‘Aleman’),(‘Santiago’,96,‘Zueco’)]
usuarios = np.array(datos,dtype=cabecera)

np.sort(usuarios,order = ‘pais’)

import numpy as np

cabecera = [ (‘nombre’, ‘S20’), (‘edad’, int), (‘pais’, ‘S20’) ]
datos = [ (‘Manolo’, 25, ‘Mexico’), (‘Axel’, 26, ‘Colombia’), (‘Jimon’, 24, ‘Canada’) ]

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

print('Ordenado por Nombre: ', np.sort(usuarios, order = ‘nombre’))
print('Ordenado por Edad: ', np.sort(usuarios, order = ‘edad’))
print('Ordenado por Pais: ', np.sort(usuarios, order = ‘pais’))

este es mi codigo
encabezado = [(‘nombre’, ‘S10’), (‘edad’, int),(‘ciudad’, ‘S15’)]
datos = [(‘Gloria’, 25,‘Bogota’),(‘Maria’, 40,‘Cali’),(‘Jorge’, 36,‘Tunja’)]
usuario = np.array (datos, dtype = encabezado)
np.sort (usuario, order = (‘edad’))

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

array([(b’Enrique’, 39, b’Bolivia’), (b’Luis’, 19, b’Colombia’),
(b’Carlos’, 29, b’Peru’)],
dtype=[(‘nombre’, ‘S10’), (‘edad’, ‘<i4’), (‘Pais’, ‘S20’)])

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 = [ (‘Nombre’, ‘S30’ ), (‘anio’, int), (‘Pais’, ‘S20’) ]
datos_us = [ (‘Diana Ramirez’, 1985,‘Colombia’), (‘Johanita’, 1987, ‘Peru’), (‘Farouk Jimenez’, 1983, ‘Argentina’), (‘Ging’, 2011, ‘Chile’) ]
usuarios = np.array(datos_us, dtype = cabecera)
np.sort(usuarios, order = ‘anio’ )

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 ‘ones’ 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')