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 y manipulación de datos con Pandas

4/34
Recursos
Transcripción

Aportes 148

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Aquí mi solución al reto.

data = pd.read_csv('canciones-2018.csv')
subset = data[['name','tempo','duration_ms']]
subset.sort_values(by='tempo',axis=0 , ascending=True)

al cargar el archivo usando pd.read_csv. Hay algunos parametros que son de interés por si cargan otro tipo de archivos.

delimiter = tipo de separador de los datos en el csv
decimal = notacion decimal de los datos ( , o .)
encoding = puede que se tengan archivos cuya codificacion no se utf-8 y se necesite cambiar a por ejemplo latin1

df = pd.read_csv('nombre.csv', delimiter = ',' , decimal = '.' , encoding= 'utf-8')

Vengo del curso anterior Introduccion a Machine Learning, y no enseñaban asi, creo que ese curso o debe estar mucho mas adelante en la ruta de aprendizaje o sacarlo de la ruta porque sinceramente hasta desanima en seguir.

algunas notas importantes

  1. si se usa data.iloc[ ] el iloc se usa cuando se va a usar el indice de las filas y columnas para filtrar nuestros datos.Pero también esta data.loc[] donde se usan los nombres de las columnas.

  2. un comando que no vi se mostró es data.info() que nos da un resumen de las variables y el tipo de dato en cada una de ellas.

Pandas (Panel Data)

  • Es una librería derivada de numpy pensada para el manejo de datos en forma de panel.
  • Trabaja con series, data frames y panels, generan indices a los arreglos (a manera de panel o tabla de excel), en una (Series), dos (DataFrames) o tres dimensiones (Panels)
  • Al igual que numpy hay que importar primero la librería:
import pandas as pd
  • Creación de series y dataframes:
serie = pd.Series(<datos>)
dataframe = pd.DataFrame(<datos>)

El código anterior genera una serie o dataFrame a partir de los datos ingresados, pueden ser listas, tuplas o , en el caso de un DataFrame, arreglos o diccionarios (en el caso de los diccionarios los indices de las columnas toman el valor de las llaves)

  • Algunos comandos útiles
    • df[<nombre_columna>] → selecciona la columna invocada
    • pd.read_csv(<nombre_archivo>) → permite importar datos a partir de un csv
    • type(<objeto>) → permite saber el tipo de objeto
    • df.shape → Devuelve el tamaño del df
    • df.colums → Devuelve las columnas del df
    • df[<nombre_columna>] .describe() → devuelve un análisis estadístico de la columna
    • df.sort_index() → ordena de acuerdo al índice (axis=0 → filas; axis=1 → columnas)
    • df.sort_values(by=<campo_a_ordenar>) → ordena de acuerdo a los valores

Ordenar con base al valor de una columna

Me parece importante mencionar que usando el método sort_values() podemos ordenar con base en los valores de una columna

# Ordenando según la clase
data[['name', 'artists', 'tempo', 'duration_ms']].sort_index(axis=0, level='name', ascending=True)

#Ordenando según columna 'tempo'
data[['name', 'artists', 'tempo', 'duration_ms']].sort_values('tempo')

Si quieren profundizar más en pandas, hay un curso gratuiro en kaggle.com

Aun no estoy seguro de cómo resolver el reto,

En el minuto 10:58 la profesora Yecely señala que axis = 0 corresponde a la posición 0, pero leyendo la documentación oficial el parámetro axis puede tomar solo 4 valores. 0 o ‘index’ - 1 o ‘columns’ (el valor 0 hace referencia a las filas).

Entonces me confundo porque el reto dice selecciona 3 columnas y ordenalas de manera ascendente. Entonces:

Podría hacer esto:

data.sort_index(axis=0, by=['name', 'artists', 'energy'], ascending=[True, True, True])

Que seria lo mismo:

data.sort_index(by=['name', 'artists', 'energy'])

y lo que estaría haciendo es, ordenar de manera múltiple las filas segun las 3 columnas de mi preferencia. No estoy seguro si eso era lo solicitado ya que tambien podria hacer lo siguiente:

data[['name', 'artists', 'energy']].sort_index(axis=1)

en este caso, selecciono 3 columnas y las ordenó de manera ascendente, pero las filas quedan inalteradas.

Espero haberme explicado bien.

Por cierto, con esta clase de manipulación de datos con Panda se me vino a la mente el ORM de Django. Toma los datos y facilita su manejo. Espero no estar equivocado en mi analogía.

Saludos!

pandas.DataFrame.sort_index

data = pd.read_csv(’/canciones-2018.csv’)
data.head(5)

Si lo hago como la profe ,me da un error , se debe colocar el / antes del archivo. Supongo que es por cuestion de versiones.

new_data = {'Artista': data.artists, 
            'Bailabilidad': data.danceability, 
            'Sonoridad': data.loudness}

selected_columns = pd.DataFrame(new_data)
selected_columns

selected_columns.sort_index(axis=0, ascending=True)

Artista Bailabilidad Sonoridad
0 Drake 0.754 -9.211
1 XXXTENTACION 0.740 -4.880
2 Post Malone 0.587 -6.090
3 Post Malone 0.739 -8.011
4 Drake 0.835 -5.833
… … … …
95 Zac Efron 0.684 -7.005
96 Clean Bandit 0.638 -6.318
97 DJ Khaled 0.552 -4.706
98 ZAYN 0.258 -6.593
99 Dean Lewis 0.553 -6.319

data = pd.read_csv('cannciones_2018.csv')
data2 = data[['name','artists','energy']]
data2.sort_index(axis=0,ascending=True)```
data = pd.read_csv('canciones-2018.csv')
dataWork = data[['artists','name','danceability']]
dataWork.rename(columns={'artists': 'Artista', 'name': 'NombreCancion','danceability': 'Bailabilidad'}, inplace=True)
dataWork.sort_values(by=['Artista'],ascending=True)```

![]("

import pandas as pd

canciones = pd.read_csv("canciones-2018.csv")
df2 = canciones[["name","energy","key"]]
df2 = df2.sort_index(axis=1, ascending=True)
df2.head()

")

Seleccioné name, artist y danceability y lo ordené por artistas de manera ascendente

data2 = data[['name','artists','danceability']]
d2s=data2.sort_values(by= "artists", axis=0, ascending= True )
d2s.head(5)

Muy buen video, me quedo todo claro.

<h1>sorted by colnms selecting three items</h1>

songs = pd.read_csv(‘canciones-2018.csv’)
songs_data = songs[[‘artists’, ‘tempo’, ‘duration_ms’]]
songs_data.sort_index(by=‘tempo’, axis=0, ascending = True)

“Aqui el Warning de Sergio, que sice que sort se va en un futuro”

/usr/lib/python3.7/site-packages/ipykernel_launcher.py:4: FutureWarning: by argument to sort_index is deprecated, please use .sort_values(by=...)
  after removing the cwd from sys.path.

Pero ahi esta!!!

Mi solución:

filtered_data = data.loc[:,['artists','name','danceability','duration_ms']]
filtered_data.sort_values(by = ['artists','duration_ms'], inplace = True)
filtered_data

Implemente esa debido a que quise hacer la siguiente:

filtered_data = data[['artists','name','danceability','duration_ms']]
filtered_data.sort_values(by = ['artists','duration_ms'], inplace = True)
filtered_data.sort_values

Y me sale una advertencia, con un link que me manda a la documentacion donde dice que la forma preferida en pandas es con el loc. El inplace=True me permite que el dataframe sea actualizado y cambiado con el nuevo orden. Me di cuenta tambien que la advertencia es por el uso del inplace. Por lo que una alternativa es la siguiente:

filtered_data = (data[['artists','name','danceability','duration_ms']]
                 .sort_values(by = ['artists','duration_ms']))
filtered_data

Para la siguiente forma me saca un warning diciendo que .sort_index es un argumento obsoleto y es mejor usar .sort_values(by=…)

filtered_data = data[['artists','name','danceability','duration_ms']]
filtered_data.sort_index(by = ['artists','duration_ms'], axis = 0)

Ahí jugué un rato con diferentes formas de hacer el ejercicio. Saludos

Pandas:
Biblioteca de código abierto que proporciona estructuras de datos y herramientas de análisis de datos de alto rendimiento y fáciles de usar.
Tiene dos tipos de datos en particular:

  • Series (1D)
  • Dataframes (2D)
  • Panels (3D) *no será necesario para este curso

De estas tres columnas ordenalas conforme a los valores de la columna ‘name’:

data[['name', 'key', 'mode']].sort_values('name')

data.sort_index(axis=0, by=[‘name’,‘artists’,‘energy’],ascending=[True,True,True])

lst = data[['id', 'tempo','name']].sort_index(axis=0, ascending=True)
lst```

Les dejo mi respuesta 😄

data.sort_values(['name','danceability','energy'], ascending=[True,True,True,])

XD me salio medio raro xd

head3 = filex[['name','id','mode']]
head = head3.sort_index(axis = 0,ascending =True)
head.head(3)

Pero tengo tres columnas asi que esta bien supongo

data_extract = data.iloc[:,3:7]
data_extract.sort_values(‘key’, ascending =True )

Pandas pd Esta genial

Mi reto, datos ordenados por la columna duration_ms

Mi reto, top 10 artistas con mayor energía:

Para los que usen Google Colab. Si les da error al hacer

data = pd.read_csv('canciones-2018.csv')

Pueden intentar primero conectar a su Google Drive usando

from google.colab import drive
drive.mount('/content/drive')

Google les pedirá confirmación para realizar esta acción, y después navegan por sus carpetas hasta donde esté ubicado el archivo, por ejemplo:

%cd /content/drive/MyDrive/Platzi
!ls

Hecho esto, vuelven a intentar

data = pd.read_csv('canciones-2018.csv')

Y debería funcionar bien

usando el dataset original se crea un nuevo dataset con las columnas que queremos.

fav_data = pd.DataFrame(data=None)
fav_data['name'] = data['name']
fav_data['artists'] = data['artists']
fav_data['energy'] = data['energy']
fav_data.sort_index(axis =0, ascending = True)
  1. Importo pandas y leo el csv
import pandas as pd
df= pd.read_csv('canciones.csv')

  1. Luego ordeno el data frame seleccionando las trescolumnas de mi preferencia:
order = df[['speechiness','danceability','energy']]
  1. Ordeno el data frame ‘order’ en modo ascendente para cada una de sus columnas:
order.sort_values(by='danceability',axis=0 , ascending=True)
order.sort_values(by='energy',axis=0 , ascending=True)
order.sort_values(by='speechiness',axis=0 , ascending=True)

Esta es mi solucion

df = pd.read_csv('canciones-2018.csv', usecols=['name', 'tempo', 'duration_ms'], low_memory=True).sort_values(by='tempo', axis=0, ascending=True)

¡Mi aporte!

<#Challenge
    data2 = data[['name', 'energy', 'time_signature']]
    print(data2.sort_index(axis=0, ascending=True))> 

df = pd.DataFrame(np.random.rand(3,3), columns = [‘artists’,‘energy’,‘mode’])
df.sort_index(axis=0,ascending=True)
df

Excelente curso les dejo mi resolución del reto

indices = ['name', 'artists','duration_ms']
data_index = data.sort_values(by=indices,axis=0, ascending=True)
data_index[indices].head(10)
data.sort_values(by='artists')

Si creamos un diccionario en Python donde las llaves están asociadas a listas, podemos crear un DataFrame donde las llaves pasan a ser los nombres de las columnas (o cabeceras), que a su vez estarán compuestas por los elementos que se encuentran en las listas asociadas.

Les comparto mi solución del reto:

data[['name','danceability','duration_ms']].sort_index(axis = 0, ascending = True)

Deepnote block

data = pd.read_csv('canciones-2018.csv')
line1 = data[['id','artists','time_signature']]
line1.sort_values(by = 'artists', axis= 0, ascending = True)

Modifique un poco el reto para hacerlo divertido. El programa te devuelve una canción random que debes escuchar. Cada vez que ejecutas el código te muestra una canción distinta, aparte de los elementos ordenados.

import pandas as pd
import random 

def main():
    random_info = random.randint(1,100)
    data_frame = pd.DataFrame(pd.read_csv('canciones.csv'))
    data_pick = data_frame[['artists', 'name', 'time_signature']]
    data_pick.sort = data_pick.sort_values(by='name',axis=0, ascending=True) 
    print(data_pick)

    print("\nCANCION RANDOM QUE TIENES QUE ESCUCHAR: \n")
    print(data_frame['artists'][random_info],'-', data_frame['name'][random_info],'-', data_frame['time_signature'][random_info])


if __name__ =='__main__':
    main()

seleccion = data[[‘name’,‘artists’,‘loudness’,‘danceability’]]
seleccion.sort_values(by = ‘loudness’, axis=0, ascending=True)

Mi solución al reto:

import pandas as pd

# función para transformar los milisegundos en minutos y segundos
def convertir_ms(milisegundos):
    minutos = int((milisegundos/1000)/60)
    segundos = int(milisegundos/1000) - (minutos*60)
    tiempo = "%s m %s s" % (minutos,segundos)
    return tiempo

# leemos los datos
data = pd.read_csv('canciones-2018.csv')

# escogemos tres columnas
data = data[['name', 'artists', 'duration_ms']]

# transformamos la columna duration_ms para que tenga un formato más legible en minutos y segundos
data['duration_ms'] = data['duration_ms'].apply(convertir_ms)

# ordenamos por artista
data = data.sort_values(by='artists', ascending=True)

Solución al reto

subdata = data[['artists', 'name', 'duration_ms']]

subdata.sort_values(by='name', axis=0, ascending=True)
subdata.sort_values(by='artists', axis=0, ascending=True)
subdata.sort_values(by='duration_ms', axis=0, ascending=True)

Mi ordenamiento de las 3 columnas, seteando primero los campos y luego aplicando el sort

campos_ordenar = [‘key’,‘mode’,‘acousticness’]
data.sort_values(by=campos_ordenar, axis = 0, ascending = True)

#Challenge: order asciending three columns of your preference

data = pd.read_csv('canciones.csv')
my_columns = data[['artists','name','duration_ms']]
my_columns.sort_values(by='artists',ascending=True)

#Output:

artists	name	duration_ms
23	5 Seconds of Summer	Youngblood	203418.0
55	6ix9ine	FEFE (feat. Nicki Minaj & Murda Beatz)	179405.0
88	Anitta	Downtown	193456.0
60	Anne-Marie	2002	186987.0
65	Ariana Grande	God is a woman	197547.0
...	...	...	...
38	XXXTENTACION	changes	121887.0
98	ZAYN	Dusk Till Dawn - Radio Edit	239000.0
95	Zac Efron	Rewrite The Stars	217440.0
14	Zedd	The Middle	184732.0
35	benny blanco	Eastside (with Halsey & Khalid)	173800.0
100 rows × 3 columns 

Cumpliendo el reto 😃

Aquí mi solución al reto:

data = pd.read_csv(‘canciones-2018.csv’)

data = pd.read_csv('canciones-2018.csv')
data_ord_asc = data.sort_index(axis = 0, ascending = True)
data_1 = pd.DataFrame(data_ord_asc)
print(data_1[[ 'name', 'artists','duration_ms' ]])

Ordenando por bailabilidad y duración.
:T

data = pd.read_csv("canciones-2018.csv")
df1 = data[['name','danceability','duration_ms']]
df1.sort_values(by=['danceability', 'duration_ms'],ascending=False)

data.sort_index(axis = 0, ascending=False)

Uff, durante el video en el minuto 11:12 se ve que hay una obta maestra de canción en la lista de la profesora.

Así que decidí llamarla para verla con detenimiento😂 Les paso el código😎

rolon=data.iloc[21]
rolon

Cópienlo si quieren saber cuál es😎 Like si también te gusta

P.D: El código de la actividad:

subset=data[['name', 'artists', 'duration_ms']]
subset.sort_values(by='duration_ms', axis=0, ascending=True)

¡Hola!
Aquí mi solución al reto. Había extraído columna por columna pero a la hora de imprimir las 3 aparecía sólo la última. Sin embargo encontré que se puede tomar un subconjunto de columnas del data set.

columnas = data[['name','artists','duration_ms']] #restrinjo la tabla a las columnas que deseo
columnas.sort_index(axis = 0, ascending = True)

¡Saludos!

El reto

data[['name','artists','key']].sort_values(by='name', ascending=True).head()

Si queremos observar el final de nuestro archivo, solo necesitamos al igual que en Linux: tail() en los paréntesis, van los números de las columnas que desemos ver.

Si quiero ver un registro en especial, solo tengo que llamar al atributo: iloc y luego un íncide, con el que le indico el registro. Inmediamente al ejecutarlo, nos imprime los valores de todo el resgistro en particular.

Para acceder a un columna, solo tenemos que utilizar el dot notation. nombre de la columna, sobre nuestra variable.

Podemos utilizar el método: head, y así como el Linux, solo nos mostrará las 5 primeras líneas.

Nosotros solo tenemos que poner: pandas.DataFrame(data), y ya tenemos nuestro data frame. Ahora bien, ese 'data', puede ser cualquier tipo de colección, pero tiene que estar bien organizada.

Data frame es esencial, para trabajar con los datos que va a procesar nuestra inteligencia artificial.

Para hacer slices, es la misma vaina.

Para hacer Series: pandas.Series([2,3,589,12456,122,3]) y listo.

Lo interesante, es cómo obtenemos nuestros datos, a la hora de imprimirlos.

La estructura de datos más sencilla de pandas es: Series.

Pandas va a ser muy fácil, leer información proveniente de archivos: .csv, .xls o de la nube.

Existen 3 tipos de datos para pandas: series, Dataframes y Panels

Pandas nos permite manejar los datos, de forma tal que incluso nos podemos apoyar de esta librería, para programar algoritmos de aprendizaje, asistidos y no asistidos.

import pandas as pd

series = pd.Series( [5, 10, 15, 20, 30])
print("Series:", series)

print("Series indice 3:", series[3])

cad = pd.Series( ['A','B','C','D'] )
print("Caracteres:", cad)

lst = ['Hola','mundo','robotico']
df =  pd.DataFrame(lst)
print("dataframe:", df)

data = {
    'Nombre': ['Juan','Ana','Jose','Arturo'],
    'Edad': [14, 15, 20, 25],
    'Pais': ['mx', 'mx', 'usa', 'esp']
}
df = pd.DataFrame(data)
print("json to dataframe:", df)

print('Dataframe por columnas:', df[['Nombre','Pais']])

data = pd.read_csv('canciones.csv')
print("canciones.scv:",data.head(5))

artist = data.artists
print("artista:", artist[5])

info = data.iloc[15]
print("info artist:", info)


print("canciones ultimos registros", data.tail())

print("forma de la tabla:", data.shape)

print("columnas disponibles:", data.columns)

print("info de tempo", data["tempo"].describe())

print("ordenar:", data.sort_index(axis=0, ascending=False))

subset = data[['name','tempo','duration_ms']]
subset.sort_values(by='tempo',axis=0 , ascending=True)
print("ordenar y mostrar 3 columnas:", subset)
data = pd.read_csv('canciones-2018.csv')

data_energy = data.sort_values(by = 'energy', ascending = True)
data_energy

Asi lo hice.

<import numpy as np
import pandas as pd
data = pd.read_csv('Canciones.csv')
#Problema seleccionar tres columnas de mi preferencia y ordenarlas de manera ascendente
print(data.columns)
Grupos = ['name','artists','tempo']
print(data[Grupos].sort_index(axis=0, ascending=True))
> 

Escoger 3 columnas y ordenarlas de manera ascendente de acuerdo al campo seleccionado

data3 = data[[‘artists’,‘danceability’,‘energy’]]
data3.sort_values(by=‘danceability’, axis = 0, ascending = True)
print(data3)

Reto partiendo del dataframe “Data”

df_challengue = data[['name', 'artists', 'danceability']]
df_challengue.sort_values(by=['danceability'], ascending= False)

Si no están en el directorio raíz pueden montar cualquier carpeta de su google drive con la siguiente instrucción:

from google.colab import drive
drive.mount('/content/drive')

selected = data[[‘artists’,‘loudness’,‘energy’]]
selected.head()
selected.sort_index(axis = 1,ascending = True)

aquí una liga que me ayudo un poco con el reto del final

https://datatofish.com/sort-pandas-dataframe/

Mi solución, tomé Artists, danceability, tempo y duration_ms, luego ordeno por duration_ms de forma ascendente:

data2 = data[['artists', 'danceability', 'tempo', 'duration_ms']]
data2.sort_values(by='duration_ms', axis = 0, ascending = True)

es prometedor, despues de la decepcion q fue el anterios esta esta muy bien

wut = data[['name','artists','tempo']]
wut.sort_index(axis=0,ascending=True) #por indice
wut.sort_values(by='tempo',axis=0,ascending=True) #por tempo

Resultado
name artists tempo
0 God’s Plan Drake 77.169
1 SAD! XXXTENTACION 75.023
2 rockstar (feat. 21 Savage) Post Malone 159.847
3 Psycho (feat. Ty Dolla $ign) Post Malone 140.124
4 In My Feelings Drake 91.030

Ordenados por índice, luego por duración:

from google.colab import files
files.upload()

df = pd.read_csv('canciones-2018.csv')
df.sort_values(by=['artists', 'danceability', 'energy'])

espero aprender a hacer Redes nueronales

data.sort_index(axis=0,by=[‘id’,‘name’,‘energy’],ascending=[True,True,True])

data_2 = pd.read_csv('canciones-2018.csv')
fav = {'name':data_2['name'], 'tempo':data_2['tempo'],'artists':data_2['artists']}
fav = pd.DataFrame(fav)
fav.sort_index(axis = 0,ascending=1)

En GeeksForGeeks pueden encontrar un muy buen tutorial sobre Pandas.

import pandas as pd
data = pd.read_csv('canciones-2018.csv')
playlist = data [['name','artists','danceability']].sort_index(axis=1, ascending=True).head(5)
print(playlist)

En este blog pueden encontrar más información sobre el metodo sort_values().

reto = data[['duration_ms','danceability','artists']].sort_index(axis=0,ascending=True).head(15)
reto

Ordenando por bailabilidad

reto = data[['name', 'artists', 'mode']]
reto.sort_index(axis = 0, ascending = True )
data = pd.read_csv('canciones-2018.csv')
data.sort_values(['name', 'key', 'tempo'], ascending=[True, True, True])

intente asi pero me salio un error, y tambien cual e sla diferencia entre sort_index y sort_values? Gracias

canciones = pd.read_csv('canciones-2018.csv')
cancionesdata = canciones[["name","artists","liveness"]
result = cancionesdata.sort_index(by='liveness',axis=0, ascending = True)

data.sort_index(by = [‘name’, ‘artists’, ‘duration_ms’], ascending = True)

Este es el codigo de ordenar por dos columnas el df

<h1>cargar el archivo</h1>

canciones = pd.read_csv(‘canciones-2018.csv’)

<h1>Ver las primeras cinco fila</h1>

canciones.head(5)

<h1>ordena por varias columnas</h1>

order_canciones = canciones.sort_values([‘name’, ‘artists’])
order_canciones.head()

Mi reto 2

import pandas as pd
data = pd.read_csv(‘canciones-2018.csv’)
data.head(4)
Newdata = data[[‘id’,‘name’,‘artists’,‘tempo’]]
Newdata.sort_index(axis = 1, ascending = True )

data2 = data[['name', 'artists', 'energy']].sort_values(by='energy', ascending = True)
table = data[['id','energy','artists']].sort_index(axis = 0, ascending=True)```

Hola compañeros, tengo una duda que probablemente les sonará muy boba.

¿Qué diferencia hay entre Numpy y Pandas? ¿Puedo hacer algo con Numpy que no haga pandas?

Saludos

ordenando la variable artista, de manera ascendente.

artist = df.iloc[:,2]
artist.sort_values(ascending =True)

Cordial saludo. A mí no me sirve el archivo canciones lo subí colab y nada me da error

selection = data[['name','energy','mode']]
selection.sort_values(by='energy',axis=0, ascending=False)