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(()))
Fundamentos prácticos
Aplica Platzidoro en este curso y asegura el éxito de tu aprendizaje
Los fundamentos de machine learning que aprenderás
Introducción a Numpy
Introducción y manipulación de datos con Pandas
Introducción a ScikitLearn
Comandos básicos de las librerías usadas en el curso (Numpy, Pandas y ScikitLearn)
Regresión Lineal y Logística
¿Qué es la predicción de datos?
Sobreajuste y subajuste en los datos
Regresión lineal simple y regresión lineal múltiple
Regresión lineal simple con Scikit-Learn: división de los datos
Regresión lineal simple con Scikit-Learn: creación del modelo
Regresión logística con Scikit-Learn: definición y división de datos
Regresión logística con Scikit-Learn: evaluación del modelo
Matriz de confusión
PlatziDoro Cápsula 1
Árboles de decisión
¿Qué es un árbol de decisión y cómo se divide?
Comprendiendo nuestro data set para la creación de un árbol de decisión
Creando un clasificador con Scikit-Learn
Entrenamiento del modelo de clasificación
Visualización del árbol de decisión
K-Means
¿Qué es K-Means?
Cargando el data set de Iris
Construcción y evaluación del modelo con K-Means
Graficación del modelo
PlatziDoro Cápsula 2
Aprendizaje profundo
Introducción al aprendizaje profundo
Conceptos básicos de Tensor Flow
Red neuronal convolucional
Conociendo el set de datos para la creación de la red neuronal
Crea y entrena tu primera red neuronal convolucional con Tensor Flow
Evaluación de la red convolucional
PlatziDoro Cápsula 3
Despedida
Recomendaciones para analizar correctamente tu problema
Siguientes pasos para continuar aprendendiendo de Machine Learning
Aportes 149
Preguntas 13
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).
import numpy as np
np.array(<arreglo>)
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)
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
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:
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 😄
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!!!
```
<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
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:
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')
Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.