Introducción a Numpy

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)

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]

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

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 😄

En este link les dejo varios usos de esta gran libreria

https://colab.research.google.com/drive/1-Nf_Ps6rVshZOPmLf6n-zNt7neG2cuk2#scrollTo=GPIoXiBa4ZAf

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

​```

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

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

cabecera= [(“Nombre”,‘S10’),(“edad”, int),(“pais”,‘S10’)]
datos=[(“emerson”,10, “colombia”),(“juna”,12,“mexivo”),(“emmanuel”,21,“colombia”),(“sara”,21,“colombia”),(“carlos”,26,“UUSS”),(“tucan”,27,“UUSS”)]
arreglo=np.array(datos,dtype=cabecera)
print(np.sort(arreglo,order= “edad”))

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

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

cabeceras = [(‘nombre’, ‘S15’), (‘edad’, int), (‘pais’, ‘S10’)]
datos = [(‘Ricardo’, 51, ‘ES’), (‘Raquel’, 47, ‘ES’), (‘Michiel’, 32, ‘NL’)]
personas = np.array(datos, dtype = cabeceras)

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

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