Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Reto: simulador de playlist musical

22/23
Recursos

Aportes 18

Preguntas 0

Ordenar por:

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

Mi solución al reto.
Utilice la estructura Queue basada en listas.
Creeu na clase MusicPlaylist con 4 métodos.
-Un método para agregar canciones mediante una tupla con su nombre, y duración(add_songs)
-Un método para reproducir solo una canción(play_song)
-Un método para reproducir todas las canciones dentro de la playlist
-Y un método para visualizar todas las canciones dentro de la playlist(all_songs)

import time

class ListQueue:
    def __init__(self):
        self.items = []
        self.size = 0

    def enqueue(self, data):
        self.items.insert(0, data)
        self.size += 1

    def dequeue(self):
        if self.size <= 0:
            return 0
        data = self.items.pop()
        self.size -= 1
        return data
        

class MusicPlaylist(ListQueue):
    def __init__(self):
        super().__init__()

    def add_songs(self, song: tuple):
        self.enqueue(song)

    def play_song(self):
        song = self.dequeue()
        if song:
            print(f'Playing: {song[0]} for {song[1]} min')
            time.sleep(song[1])
        else:
            print('There are no more songs')

    def play_songs(self):
        while self.items:
            self.play_song()

    def all_songs(self):
        if self.items:
            print('The songs in the playlist are:')
            for i, song in enumerate(self.items[::-1],start=1):
                print(f'Song {i}: {song[0]}, Time: {song[1]}')
        print(f'There are {self.size} songs')
        return self.size
        



if __name__ == '__main__':
    playlist = MusicPlaylist()

    playlist.add_songs(("REMEMBER", 5.19))
    playlist.add_songs(("comfy vibes", 3.12))
    playlist.add_songs(("Into the blue's", 4.03))
    playlist.add_songs(("E.M.A", 4.16))

    playlist.all_songs()
    print()

    playlist.play_songs()
    print()

    playlist.play_song()
    playlist.all_songs()

Outputs

The songs in the playlist are:
Song 1: REMEMBER, Time: 5.19
Song 2: comfy vibes, Time: 3.12
Song 3: Into the blue's, Time: 4.03
Song 4: E.M.A, Time: 4.16
There are 4 songs

Playing: REMEMBER for 5.19 min
Playing: comfy vibes for 3.12 min
Playing: Into the blue's for 4.03 min
Playing: E.M.A for 4.16 min

There are no more songs
There are 0 songs

Hace tiempo intenté replicar el funcionamiento de “songrequest” de los bots de Twitch y para esto tuve que usar una forma similar (aunque no hice una clase Queue), les dejo el código por si quieren checarlo https://github.com/LuisLiraC/michi-bot-twitch/blob/master/music_player.py 😬

Terminado !!!
Use una estrucutra de DoubleWayNodes para hacer el Queue, me parece que estan hechos los DoubleWayNodes para estos tipos de usos, sencillos, rápidos y fácil de usar e implementar.
Ademas del metodo de agregar y “reproducir” canciones, agrege uno para poner en random la playlist, agregando los nodos al head o al tail.

#!/usr/bin/python3

from random import randint

class DoubleNode ():
    def __init__ (self, data=None, next_node=None, prev_node=None):
        self.data = data
        self.next = next_node
        self.prev = prev_node

class Playlist ():
    def __init__ (self):
        self.head = None
        self.tail = None
        self.count = 0

    def __iter__ (self):
        current_node = self.head

        for i in range(self.count):
            node = current_node
            
            try:
                current_node = current_node.next
            except AttributeError:
                current_node = None

            yield node

    def __str__ (self):
        node_list = []

        for node in self:
            node_list.append(node.data)

        return str(node_list)

    def __init_linked_list (self, node):
        self.head = node
        self.tail = node

    def __delete_all_nodes (self):
        self.head = None
        self.tail = None
        self.count = 0

    def __add_node_to_head (self, node):
        if self.head is None:
            self.__init_linked_list(node)
            return 

        node.next = self.head
        self.head.prev = node
        self.head = node
    
    def __add_node_to_tail (self, node):
        if self.tail is None:
            self.__init_linked_list(node)
            return 

        node.prev = self.tail
        self.tail.next = node
        self.tail = node

    def __pop_node_in_head (self):
        if self.head is None or self.count <= 0:
            return None

        deleted_node = self.head

        try:
            self.head.next.prev = None
            self.head = self.head.next
        except AttributeError:
            pass

        return deleted_node

    def __pop_node_in_tail (self):
        if self.tail is None or self.count <= 0:
            return None

        deleted_node = self.tail

        try:
            self.tail.prev.next = None
            self.tail = self.tail.prev
        except AttributeError:
            pass

        return deleted_node
 
    def add_song (self, song_name):
        song_node = DoubleNode(song_name)

        self.__add_node_to_head(song_node)
        self.count += 1

    def play_next_song (self):
        self.__pop_node_in_tail()
        self.count -= 1

    def shuffle_playlist (self):
        node_list = []

        for node in self:
            node_list.append(node)
        
        self.__delete_all_nodes()

        for node in node_list:
            random_num = randint(0, 100)

            if random_num >= 50:
                self.__add_node_to_head(node)
            else:
                self.__add_node_to_tail(node)

            self.count += 1

        return self.head.data

if __name__ == "__main__":
    MusicPlaylist = Playlist()

    for i in range(10):
        MusicPlaylist.add_song(f"song_{i}")

    print(str(MusicPlaylist))

    MusicPlaylist.shuffle_playlist()

    print(str(MusicPlaylist))

Esta es mi solución:

class Playlist:
    def __init__(self):
        self.canciones = []
        self.lista_canciones = 0
    
    def insertar_cancion(self,data):
        self.canciones.insert(0,data)
        self.lista_canciones += 1

    def reproducir_cancion(self):
        cancion = self.canciones.pop()
        self.lista_canciones -= 1
        return cancion
    
    def lista_canciones_completas(self):
        play_list_completo = self.lista_canciones

        for item in range(play_list_completo):
            print(self.canciones[item])


lista = Playlist()
lista.insertar_cancion("Hey Jude")
lista.insertar_cancion("Yellow Submarine")
lista.insertar_cancion("Let it be")

print("Cancion que se esta reproduciendo en el momento: ")
print(lista.reproducir_cancion())
print("Canciones que quedan en la lista de reproducción ")
lista.lista_canciones_completas()
  • Para resolver el reto cree una clase canción en la cual el usuario agrega el nombre, el cantante, el tiempo y en cualquier caso si canta con alguien más (ft).
  • Luego desarrolle una clase PlayList basada en nodos, ya que es mi forma de datos favorita de momento.
  • Tiene métodos para reproducir, agregar, buscar y reproducir, y reproducir toda la playlist sin eliminarla.

Mi GitHub del código: Python Playlist

Reto:

class MusicPlayList:
    def __init__(self) -> None:
        self.list = []
        self.size = 0

    def add_song_to_playlist(self, song):
        self.list.insert(0, song)
        self.size += 1

    def play(self):
        song = self.list.pop()
        self.size -= 1
        return f'Reproduciendo {song}'
    
    def next(self):
        return self.play()

    def show_playlist(self):
        songs_count = 0
        for song in self.list:
            print(f'Song {self.size - songs_count} - {song}')
            songs_count += 1

Implementación:

from reto_playlist_queue import MusicPlayList
def run():
    music = MusicPlayList()
    music.add_song_to_playlist('New Shapes, by Charli XCX')
    music.add_song_to_playlist('No Reason by Big Thief')
    music.add_song_to_playlist('Love Me More, by Mitski')
    music.add_song_to_playlist('Tabula Rasa, by Earl Sweatshirt feat. Armand hammer')
    music.add_song_to_playlist('Tears In The Club, by FKA twigs')
    music.add_song_to_playlist('Fanny Girl, by FKA twigs')
    music.add_song_to_playlist('Taking Me Back, by Jack White')

    print('=================================')
    music.show_playlist()
    print('=================================')
    print(music.play())
    print(music.next())
    print('=================================')
    music.show_playlist()
    print(music.play())
    print(music.play())
    print(music.play())
    print('=================================')
    music.show_playlist()
    

if __name__ == '__main__':
    run()

MI solución al reto

import time
import secrets

class Playlist:
    def __init__(self):
        self.songs = []
        self.size = 0

    def validate_playlist(func):
        def wrapper(self):
            if self.size > 0:
                func(self)
            else:
                print('There is no more songs to listen on the playlist')
        return wrapper

    def add_song(self, song: str):
        if isinstance(song, str):
            self.songs.insert(0, song)
            self.size += 1
        else:
            print('Only strings accepted')

    def listen_all_playlist(self):
        while self.size > 0:
            self.listen_song()

    @validate_playlist
    def listen_song(self):
        song = self.songs.pop()
        self.size -= 1
        print(f'Listening {song}...')
        time.sleep(10)

    @validate_playlist
    def shuffle(self):
        song = secrets.choice(self.songs)
        self.songs.remove(song)
        self.size -= 1
        print(f'Listening {song}...')
        time.sleep(10)

Mi solución

class MusicQueue:
    def __init__(self):
        self.inbound_queue=[]
        self.outbound_queue=[]
        self.size=0

    def enqueue(self,song):
        self.inbound_queue.append(song)
        self.size+=1
    
    def dequeue(self):
        if not self.outbound_queue:
            while self.inbound_queue:
                self.outbound_queue.append(self.inbound_queue.pop())
        self.size-=1
        return self.outbound_queue.pop()
    
    def get_size(self):
        return self.size

if __name__ == "__main__":
    list_songs=MusicQueue()
    flag='Y'
    while flag=='Y':
        new_song=str(input("Introduce a new song: "))
        list_songs.enqueue(new_song)
        print("Song inserted successfully")
        flag=str(input("Introduce Y for continue appending songs or N to close and reproduce: "))
    
    if flag=='N':
        for i in range(list_songs.get_size()):
            print(list_songs.dequeue())
        print("Music ended, good luck!")
    else:
        print("Unexpected value, program terminated!")



Mi reto es el siguiente:

class Playlist:
    def __init__(self):
        self.items = []
        self.size = 0

    def add_to_playlist(self, data):
        """Enqueue method"""
        self.items.insert(0, data)
        self.size += 1

    def play_a_song(self):
        """Dequeue method"""
        data = self.items.pop()
        self.size -= 1
        print("Se empieza a reproducir {}".format(data))

    def show_playlist(self):
        total_items = self.size

        counter = self.size

        for song in range(total_items):
            print("{}: {}".format(counter, self.items[song]))
            counter -= 1

    def ask_song(self):
        data = input('¿Qué canción desea añadir a la playlist?')
        print("Añadiendo a la playlist")
        self.add_to_playlist(data=data) 

Print playlist:

Add to queue (Spotify):

If neccesary add in node_based_queue:

Código que hice antes de ver la clase:

class TwoWayNode(object):
    def __init__(self, data = None, next = None, previous = None):
        self.data = data
        self.next = next
        self.previous = previous


class Queue:
    def __init__(self):
        self.head = None
        self.tail = None
        self.count = 0


    def addSong(self, song):
        if self.head == None:
            self.head = TwoWayNode(song)
            self.tail = self.head
        else:
            current = self.head
            while current.next != None:
                current = current.next
            current.next = TwoWayNode(song)
            current.next.previous = current
            self.tail = current.next
        self.count += 1


    def playSongs(self):
        current = self.head
        while current != None:
            print(f'Song playing: {current.data} \n')
            current = current.next


La solucion mas simple que no sacrifique elegancia en la que pude pensar

from dataclasses import dataclass


@dataclass
class Song:
    artist: str
    title: str

    def __str__(self) -> str:
        return f"Artist: {self.artist}\nTitle: {self.title}\n"


class Playlist:
    def __init__(self) -> None:
        self.list = []

    def add_song(self, song: Song) -> None:
        self.list.append(song)

    def play(self) -> None:
        song = self.list.pop(0)
        print("=" * 25)
        print("Playing song...")
        print("-" * 25)
        print(song)


if __name__ == "__main__":

    player = Playlist()

    player.add_song(Song("CardiB", "Up"))
    player.add_song(Song("Olivia Rodrigo", "Good 4 U"))
    player.add_song(Song("Arooj Aftab", "Mohabbat"))

    while player.list:
        player.play()

Esta fue una evaluación tipo proyecto que tuve que hacer en mi universidad. Eran 20 puntos sobre el parcial de estructuras lineales de la materia de estructuras de datos. Lo malo es que lo tuve que hacer en C++ 😢

😃
Mi resultado del reto:
github: https://github.com/Valot3/music-player-simulator.git

Esta fue mi solucion al reto

Hice una clase para crear las canciones, estas tienen titulo, artista y album, luego una clase para las queues basadas en listas con un metodo para añadir cada cancion creada, otro metodo que las reproduce (y al reproducirlas las quita de la lista en el orden en que se añadieron, cumpliendo con FIFO)

class Song:
    def __init__(self, artist='', title='', album=''):
        self.artist = artist
        self.title = title
        self.album = album


class Queue:
    def __init__(self):
        self.songs = []
        self.size = 0

    def enqueue(self, song):
        #Se usa insert para que lo agregue al principio
        self.songs.insert(0, song)
        self.size += 1

    def play(self):
        #Al reproducirse una cancion, esta se elimina
        if self.size > 0:
            song = self.songs.pop()
            self.size -= 1
            print(f'Se esta reproduciendo {song.title} de {song.artist}, perteneciente al album {song.album}')
        else:
            print('No hay mas canciones por reproducir')

    def traverse(self):
        total_songs = self.size

        if total_songs > 0:
            print(f'El total de canciones es: {total_songs}')

            for index, song in enumerate(self.songs):
                print(f'La cancion #{index + 1} es: \nArtista:{song.artist}, titulo:{song.title}, album:{song.album}')
        else:
            print('No hay canciones en la lista')


#Asi se veia el output en la terminal

from reto_playlist import Song, Queue
>>> canciones = Queue()
>>> thriller = Song('Michael Jackson', 'Thriller', 'Thriller')
>>> malo_de_ser_bueno = Song('El Cuarteto de Nos', 'Lo Malo De Ser Bueno', 'Porfiado')
>>> in_the_end = Song('Linkin Park', 'In The End', 'Hybrid Theory')
>>> canciones.enqueue(thriller)
>>> canciones.enqueue(malo_de_ser_bueno)
>>> canciones.enqueue(in_the_end)
>>> canciones.traverse()
El total de canciones es: 3
La cancion #1 es: 
Artista:Linkin Park, titulo:In The End, album:Hybrid Theory
La cancion #2 es: 
Artista:El Cuarteto de Nos, titulo:Lo Malo De Ser Bueno, album:Porfiado
La cancion #3 es: 
Artista:Michael Jackson, titulo:Thriller, album:Thriller
>>> canciones.play()
Se esta reproduciendo Thriller de Michael Jackson, perteneciente al album Thriller
>>> canciones.traverse()
El total de canciones es: 2
La cancion #1 es: 
Artista:Linkin Park, titulo:In The End, album:Hybrid Theory
La cancion #2 es: 
Artista:El Cuarteto de Nos, titulo:Lo Malo De Ser Bueno, album:Porfiado