Clase 22 de 23 • Curso de Estructuras de Datos Lineales con Python
Contenido del curso
Christian Molina Vázquez
Luis Lira
Pedro Alvarado Garcia
Alexis Dorado Muñoz
Manuel Guzman
Alexis Dorado Muñoz
Martín Steven Hernández Ortiz
Juan Agustin Di Pasquo
Mauricio Gonzalez Falcon
iecgerman .
Michelle Duque De La Rosa
Junior Peves
Oscar Eduardo Barrios Blanco
Alexis Dorado Muñoz
Alexis Dorado Muñoz
Hanns Maza
Marco Alvarez Zambrano
Rigoberto Maldonado
Andres Montes
Sebastián Andrés Sanhueza Tapia
Victor R Vele
Mauricio Escobar
Juan Granada
Jhon Freddy Tavera Blandon
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 😬
Gracias por tu aporte
Gracias por tu aporte
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))
Fascinante 😮!!
Mi GitHub del código: Python Playlist
No puedo creer todo lo que he aprendido en tan poco tiempo 🤩
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()
Print playlist:
Add to queue (Spotify):
If neccesary add in node_based_queue:
Reto
class TwoWayNode(object): def __init__(self, song_name = None, next = None, previous = None): self.song_name = song_name self.next = next self.previous = previous class Queue: def __init__(self): self.head = None self.tail = None self.count = 0 self.current = self.head def Add_song (self, song_name): new_node = TwoWayNode(song_name, None, None) if self.head is None: self.head = new_node self.tail= self.head else: new_node.previous = self.tail self.tail.next = new_node self.tail = new_node self.count += 1 def Reproduce (self): if self.head is None: print('No hay más canciones en la cola') self.current = None return None node2remove = self.head if self.count == 1: self.count -=1 self.head = None self.tail = None elif self.count >1: self.head = self.head.next self.head.previous = None self.count -=1 self.current = node2remove if self.head is None: self.current = None print(f'reproduciendo {node2remove.song_name}') return node2remove.song_name
# Simulador de playlist musical # Este programa simula una cola de reproducción de canciones con títulos y duraciones aleatorias. # Importar librerías from random import randint # Para generar duraciones aleatorias de canciones from time import sleep # Para simular el tiempo de reproducción de cada canción # Clase Node: Representa un nodo individual en la cola class Node: def __init__(self, data): self.data = data # Datos almacenados en el nodo (en este caso, un objeto Track) self.next = None # Enlace al siguiente nodo en la cola # Clase Queue: Implementación básica de una cola basada en nodos class Queue: def __init__(self): self.front = None # Apuntador al inicio de la cola self.rear = None # Apuntador al final de la cola self._count = 0 # Contador interno de elementos en la cola # Método para agregar un elemento al final de la cola def enqueue(self, item): new_node = Node(item) # Crear un nuevo nodo con el item if self.rear is None: # Si la cola está vacía self.front = self.rear = new_node else: # Si ya hay elementos, añadir al final self.rear.next = new_node self.rear = new_node self._count += 1 # Incrementar el contador de elementos # Método para eliminar y devolver el elemento del inicio de la cola def dequeue(self): if self.front is None: # Si la cola está vacía, no hay nada que devolver return None temp = self.front # Guardar el nodo del inicio self.front = self.front.next # Mover el inicio al siguiente nodo if self.front is None: # Si la cola queda vacía, ajustar el final self.rear = None self._count -= 1 # Decrementar el contador de elementos return temp.data # Devolver los datos del nodo eliminado # Propiedad para obtener la cantidad de elementos en la cola @property def count(self): return self._count # Retornar el número de elementos # Método para verificar si la cola está vacía def is_empty(self): return self.front is None # True si no hay elementos # Clase Track: Representa una canción con título y duración class Track: def __init__(self, title=None): self.title = title # Título de la canción self.length = randint(5, 6) # Duración aleatoria entre 5 y 6 segundos (simulando minutos) def __str__(self): return f"{self.title}" # Representación en cadena del título de la canción # Clase MediaPlayerQueue: Cola de reproducción que hereda de Queue class MediaPlayerQueue(Queue): def __init__(self): super().__init__() # Inicializar la clase padre (Queue) # Método para agregar una canción a la cola de reproducción def add_track(self, track): self.enqueue(track) # Usar enqueue de la clase padre para agregar la canción # Método para reproducir todas las canciones en la cola def play(self): # Mostrar la cantidad de canciones en la cola antes de reproducir print(f"Total tracks in queue: {self.count}") # Reproducir mientras haya canciones en la cola while not self.is_empty(): # Seguir hasta que la cola esté vacía # Obtener la canción actual sacándola de la cola current_track = self.dequeue() # Mostrar qué canción se está reproduciendo print(f"Now playing: {current_track}") # Simular la duración de la canción con una pausa sleep(current_track.length) # Instanciar la cola de reproducción media_player = MediaPlayerQueue() # Agregar canciones a la cola de reproducción media_player.add_track(Track("The Beatles - Let It Be")) media_player.add_track(Track("Queen - Bohemian Rhapsody")) media_player.add_track(Track("Lynyrd Skynyrd - Sweet Home Alabama")) # Reproducir la cola de reproducción media_player.play() ```*# Simulador de playlist musical# Este programa simula una cola de reproducción de canciones con títulos y duraciones aleatorias.* *# Importar librerías*from random import randint *# Para generar duraciones aleatorias de canciones*from time import sleep *# Para simular el tiempo de reproducción de cada canción* *# Clase Node: Representa un nodo individual en la cola*class Node: def \_\_init\_\_(self, data): self.data = data *# Datos almacenados en el nodo (en este caso, un objeto Track)* self.next = None *# Enlace al siguiente nodo en la cola* *# Clase Queue: Implementación básica de una cola basada en nodos*class Queue: def \_\_init\_\_(self): self.front = None *# Apuntador al inicio de la cola* self.rear = None *# Apuntador al final de la cola* self.\_count = 0 *# Contador interno de elementos en la cola* *# Método para agregar un elemento al final de la cola* def enqueue(self, item): new\_node = Node(item) *# Crear un nuevo nodo con el item* if self.rear is None: *# Si la cola está vacía* self.front = self.rear = new\_node else: *# Si ya hay elementos, añadir al final* self.rear.next = new\_node self.rear = new\_node self.\_count += 1 *# Incrementar el contador de elementos* *# Método para eliminar y devolver el elemento del inicio de la cola* def dequeue(self): if self.front is None: *# Si la cola está vacía, no hay nada que devolver* return None temp = self.front *# Guardar el nodo del inicio* self.front = self.front.next *# Mover el inicio al siguiente nodo* if self.front is None: *# Si la cola queda vacía, ajustar el final* self.rear = None self.\_count -= 1 *# Decrementar el contador de elementos* return temp.data *# Devolver los datos del nodo eliminado* *# Propiedad para obtener la cantidad de elementos en la cola* @property def count(self): return self.\_count *# Retornar el número de elementos* *# Método para verificar si la cola está vacía* def is\_empty(self): return self.front is None *# True si no hay elementos* *# Clase Track: Representa una canción con título y duración*class Track: def \_\_init\_\_(self, title=None): self.title = title *# Título de la canción* self.length = randint(5, 6) *# Duración aleatoria entre 5 y 6 segundos (simulando minutos)* def \_\_str\_\_(self): return f"{self.title}" *# Representación en cadena del título de la canción* *# Clase MediaPlayerQueue: Cola de reproducción que hereda de Queue*class MediaPlayerQueue(Queue): def \_\_init\_\_(self): super().\_\_init\_\_() *# Inicializar la clase padre (Queue)* *# Método para agregar una canción a la cola de reproducción* def add\_track(self, track): self.enqueue(track) *# Usar enqueue de la clase padre para agregar la canción* *# Método para reproducir todas las canciones en la cola* def play(self): *# Mostrar la cantidad de canciones en la cola antes de reproducir* print(f"Total tracks in queue: {self.count}") *# Reproducir mientras haya canciones en la cola* while not self.is\_empty(): *# Seguir hasta que la cola esté vacía* *# Obtener la canción actual sacándola de la cola* current\_track = self.dequeue() *# Mostrar qué canción se está reproduciendo* print(f"Now playing: {current\_track}") *# Simular la duración de la canción con una pausa* sleep(current\_track.length) *# Instanciar la cola de reproducción*media\_player = MediaPlayerQueue() *# Agregar canciones a la cola de reproducción*media\_player.add\_track(Track("The Beatles - Let It Be"))media\_player.add\_track(Track("Queen - Bohemian Rhapsody"))media\_player.add\_track(Track("Lynyrd Skynyrd - Sweet Home Alabama")) *# Reproducir la cola de reproducción*media\_player.play()
reto cumplido
from time import sleep class Node: def __init__(self, data, child=None, parent=None): self.data = data self.child:Node = child self.parent:Node = parent def __repr__(self): if isinstance(self.child, Node): return f"<Node({self.data}) {hex(id(self))}> -> Node({self.child.data})" else: return f"<Node({self.data}) {hex(id(self))}> -> {self.child}" def __str__(self): if isinstance(self.child, Node): return f"Node({self.data}) -> {self.child.__str__()}" else: return f"Node({self.data}) -> {self.child}" def link_child(self, node): """ tanto mi nodo hijo como tu nodo padre se relacionaran """ self.child = node node.parent = self def link_parent(self, node): """ tanto mi nodo padre como tu nodo hijo se relacionaran """ self.parent = node node.child = self def unlink_child(self): """ tanto mi nodo padre como tu nodo hijo, rompen relacion y te lo devuelvo """ child = self.child child.parent = None self.child = None return child def unlink_parent(self): """ tanto mi nodo padre como tu nodo hijo, rompen relacion y te lo devuelvo """ parent = self.parent parent.child = None self.parent = None return parent class Queue: def __init__(self): self.front:Node = None #head self.rear:Node = None #tail self.size = 0 def __repr__(self): return f"<Queue({self.size}) {hex(id(self))}>" def __str__(self): if self.front: return self.front.__str__() else: return "None" def __iter__(self): probe = self.front while probe: yield probe probe = probe.child def is_empty(self): return not(self.front and self.size > 0) def enqueue(self, data): """ agrego un nuevo elemento al final de la queue """ new_node = Node(data) if self.rear: self.rear.link_child(new_node) else: self.front = self.rear = new_node self.rear = new_node self.size += 1 def dequeue(self): """ devuelvo el primer elemento agregado """ if self.front == None: return None remove_item = self.front if remove_item.child: self.front = remove_item.unlink_child() else: self.front = self.rear = None self.size -= 1 return remove_item.data class Song: def __init__(self, name:str, time:int=0): self.name = name self.time = time def __repr__(self): return f"<Song({self.name}) {hex(id(self))}>" def __str__(self): return f"cancion: {self.name}\n tiempo: {self.time} s" def minutes(self): minutos = self.time // 60 segundos_restantes = self.time % 60 return minutos, segundos_restantes playlist = Queue() playlist.enqueue(Song('Sebastián Yatra, Dalmata - Sutra', 3*60 + 36)) playlist.enqueue(Song('Sebastián Yatra - Traicionera', 4*60 + 2)) playlist.enqueue(Song('Reik, Maluma - Amigos Con Derechos', 4*60 + 49)) playlist.enqueue(Song('Cali Y El Dandee - Por Fin Te Encontré ft. Juan Magan, Sebastian Yatra', 4*60 + 43)) playlist.enqueue(Song('Joey Montana - Moribundo ft. De La Ghetto', 4*60 + 5)) def play(): while not playlist.is_empty(): song:Song = playlist.dequeue() min, seg = song.minutes() print(f"Reproduciendo({min}m {seg}s): {song.name}") sleep(song.time) play()
Mi solucion al reto 🤯▶️ (Añadir en el header # -*- coding: utf-8 -*- para mostrar caracteres especiales como el simbolo de play cuando se esta reproduciendo una canción)
import time class Song(): def __init__(self, name, artist, next=None, prev=None): self.name = name self.artist = artist self.next = next self.prev = prev def show(self): title = (self.name + " - " + self.artist) return(title) class Playlist(): def __init__(self): self.head = None self.tail = None self.size = 0 def add_song(self, name, artist): song = Song(name, artist) if self.head == None: self.head = song self.tail = song else: song.prev = self.tail self.tail.next = song self.tail = song self.size += 1 def quit_song(self): current = self.head if self.size < 1: print("The playlist is empty") elif self.size == 1: self.head = None self.tail = None self.size -= 1 print(current.show() + " was deleted") return current elif self.size > 1: self.head = self.head.next self.head.prev = None self.size -= 1 print(current.show() + " was deleted") return current def play(self): i = self.size played = self.head while i > 0: print("▶ " + played.show()) played = played.next i -= 1 time.sleep(2) ```import time class Song(): def \_\_init\_\_(*self*, *name*, *artist*, *next*=None, *prev*=None): *self*.name = *name* *self*.artist = *artist* *self*.next = *next* *self*.prev = *prev* def show(*self*): title = (*self*.name + " - " + *self*.artist) return(title) class Playlist(): def \_\_init\_\_(*self*): *self*.head = None *self*.tail = None *self*.size = 0 def add\_song(*self*, *name*, *artist*): song = Song(*name*, *artist*) if *self*.head == None: *self*.head = song *self*.tail = song else: song.prev = *self*.tail *self*.tail.next = song *self*.tail = song *self*.size += 1 def quit\_song(*self*): current = *self*.head if *self*.size < 1: print("The playlist is empty") elif *self*.size == 1: *self*.head = None *self*.tail = None *self*.size -= 1 print(current.show() + " was deleted") return current elif *self*.size > 1: *self*.head = *self*.head.next *self*.head.prev = None *self*.size -= 1 print(current.show() + " was deleted") return current def play(*self*): i = *self*.size played = *self*.head while i > 0: print("▶ " + played.show()) played = played.next i -= 1 time.sleep(2)
Buen dia, resultado en el repositorio de GitHub. enter link description here
Gran parte del resultado fue…
reto de crear la playlist
Mi solución al reto
from colas_queue import ListQueue class Song: def __init__(self, title, artist, duration): self.title = title self.artist = artist self.duration = duration def __str__(self): return f"{self.title} - {self.artist}: {self.duration}" class Playlist: def __init__(self): self.queue = ListQueue() def add_song(self, song): self.queue.enqueue(song) def show_playlist(self): print("Playlist:") for song in range(self.queue.size): print(f"{self.queue.size - song}. {self.queue.items[song]}") def play(self): while self.queue.size > 0: print(f"Playing: {self.queue.dequeue()}") playlist = Playlist() playlist.add_song(Song("Tren al Sur", "Los prisioneros", "2:51")) playlist.add_song(Song("La voz de los 80", "Los prisioneros", "4:16")) playlist.add_song(Song("Perfecta", "Miranda", "3:01")) playlist.add_song(Song("Quieren Dinero", "Los prisioneros", "2:55")) playlist.add_song(Song("Eligiendo una reina", "Los chanchos en Piedra", "3:19")) playlist.add_song(Song("Mateo", "Tronic", "1:55")) playlist.show_playlist() playlist.play() playlist.show_playlist()
Este es mi trabajo:
from random import randint
from time import sleep
from node_based_queue import Queue
class Track:
def __init__(self, title=None):
self.title = title
self.length = randint(1, 10)
class MediaPlayer(Queue):
def __init__(self):
super(MediaPlayer, self).__init__()
def add_track(self, track):
self.enqueue(track)
def play(self):
print(f"count: {self.count}")
while self.count > 0 and self.head is not None:
current_track_node = self.dequeue()
current_track = current_track_node.title # Acceder al título de la pista
print(f"Now playing: {current_track}")
sleep(current_track_node.length)
track1 = Track("Highway to Hell")
track2 = Track("go")
track3 = Track("Light years")
track4 = Track("The Great Gatsby")
track5 = Track("Breath me")
track6 = Track("Los pollitos")
media_player = MediaPlayer()
media_player.add_track(track1)
media_player.add_track(track2)
media_player.add_track(track3)
media_player.add_track(track4)
media_player.add_track(track5)
media_player.add_track(track6)
media_player.play()
resultados count: 6
Now playing: Highway to Hell
Now playing: go
Now playing: Light years
Now playing: The Great Gatsby
Now playing: Breath me
Now playing: Los pollitos
~/python103$
Hice un queue basado en listas 😬 les puse nombres a las canciones y toda la cosa. Aclaración: ya sé que es un poco raro poner tantos comentarios, los pongo para saber bien lo que estoy haciendo. Cuando tenga más práctica la idea es colocar los menos posibles. Heres the code:
Aquí mi humilde código:
songs = [ { 'name': 'song1', 'duration': '3:00', 'artist': 'artist1', 'album': 'album1', }, { 'name': 'song2', 'duration': '3:00', 'artist': 'artist2', 'album': 'album2', }, { 'name': 'song3', 'duration': '3:00', 'artist': 'artist3', 'album': 'album3', }, { 'name': 'song4', 'duration': '3:00', 'artist': 'artist4', 'album': 'album4', }, { 'name': 'song5', 'duration': '3:00', 'artist': 'artist5', 'album': 'album5', } ] class PlayList: def __init__(self, name): self.queue = [] self.history = [] self.name = name self.size = 0 def add_song(self, song): self.queue.insert(0, song) self.size += 1 def playing_song(self): if not self.queue: print("Queue is empty.") return None song = self.queue.pop() print("Now playing:", song['name'], '-', song['artist']) self.history.append(song) self.size -= 1 return song def play_previous_song(self): if not self.history: print("History is empty.") return None song = self.history.pop() self.queue.append(song) self.size += 1 return song def play_queue(self): if not self.queue: print("Queue is empty.") return for song in self.queue: print(song['name'], '-', song['artist']) def remove_song(self, song): if song in self.queue: self.queue.remove(song) self.size -= 1 else: print("Song not found in the queue.")
class Queue: def __init__(self): self.items = [] def is_empty(self): return len(self.items) == 0 def enqueue(self, item): self.items.append(item) def dequeue(self): if self.is_empty(): raise IndexError("Queue is empty") return self.items.pop(0) def front(self): if self.is_empty(): raise IndexError("Queue is empty") return self.items[0] def size(self): return len(self.items) class MusicPlaylist: def __init__(self): self.playlist = Queue() def add_songs(self, songs): for song in songs: self.playlist.enqueue(song) def play_song(self): if self.playlist.is_empty(): print("No songs in the playlist") else: song = self.playlist.dequeue() print("Now playing:", song[0]) def play_all_songs(self): if self.playlist.is_empty(): print("No songs in the playlist") else: print("Playing all songs:") while not self.playlist.is_empty(): song = self.playlist.dequeue() print(song[0]) def all_songs(self): if self.playlist.is_empty(): print("No songs in the playlist") else: print("Songs in the playlist:") for song in self.playlist.items: print(song[0]) ''' En esta implementación, la clase Queuerepresenta la estructura de cola basada en listas. Mientras que la clase MusicPlaylist utiliza la cola para simular la lista de reproducción musical. El método add_songs(songs)recibe una tupla de canciones y las agrega a la lista de reproducción utilizando el método enqueuede la cola. El método play_song()reproducir la canción en la parte frontal de la lista de reproducción utilizando el método dequeuede la cola. El método play_all_songs()para reproducir todas las canciones en la lista de reproducción utilizando un bucle whilehasta que la lista de reproducción esté vacía. El método all_songs()muestra todas las canciones en la lista de reproducción utilizando el atributo itemsde la cola. Ten en cuenta que las canciones se reproducen en el orden en que se agregan a la lista de reproducción, siguiendo el principio FIFO (First In, First Out). Espero que esto te ayude a desarrollar el simulador de playlist musical utilizando la estructura Queue basada en listas en Python. Si tienes más preguntas, no dudes en preguntar.''' #Implementacón # Crear una instancia de la clase MusicPlaylist my_playlist = MusicPlaylist() # Agregar canciones a la playlist songs = [("Song 1", "3:45"), ("Song 2", "4:20"), ("Song 3", "2:55")] my_playlist.add_songs(songs) # Visualizar todas las canciones en la playlist my_playlist.all_songs() # Reproducir una canción my_playlist.play_song() # Reproducir todas las canciones en la playlist my_playlist.play_all_songs()
