update_rating function yet again, “If only I’d outlined it first, I’d have saved myself a lot of confusion!”
update_rating
update_rating for modifying a song’s rating in her music library. In earlier sections, she discovered the hard way that mixing all her logic and data assumptions in one big chunk of code led to repeated mistakes. Eventually, she documented the function properly:
Preconditions:
libraryis a non-empty list of[title, rating, play_count]entries.song_titleis a non-empty string.new_ratingis an integer in[1..5].Raises:ValueErrorif any inputs are invalid.
update_ratingdef update_rating(library: list, song_title: str, new_rating: int) -> bool:
"""
Updates the rating for a song in the music library.
(Full docstring details in previous sections!)
"""
# 1. Validate inputs (library, song_title, new_rating)
# - If invalid, raise ValueError
# 2. Loop through the library:
# - For each song, check if song_title matches
# - If so, update rating, return True
# 3. If we finish the loop with no match found, return False
pass # We'll fill this in later
pass statements create a roadmap for her final implementation. Now, Audrey (and anyone else reading her code) can see exactly where each step belongs: from handling incorrect inputs to deciding when to return True or False. This level of clarity makes subsequent coding (and debugging) far more straightforward.
def some_function(data: list) -> ???:
# 1. Validate data (not None, correct format, etc.)
# 2. Loop through data:
# - If some condition is met, do something (maybe return or update)
# 3. Return a final result if not found or if the loop completes
update_rating function is a classic example: after validation, it loops for a matching title, updates if found, and returns True. If no match is found, it returns False.
def compute_something(data: list) -> ???:
# 1. Validate data
# 2. Initialize an accumulator (e.g., an empty list or 0)
# 3. Loop through data:
# - If item meets a condition, add/append to the accumulator
# 4. Return the accumulator
find_favorite_songs(library) (which filters out songs rated 4 or 5) would gather matching titles in a list, then return that list once the loop finishes.
def process_input(input_data):
# 1. Validate input_data
# 2. If input_data is type X, do something
# 3. Else if input_data is type Y, do something else
# 4. Else, handle "unexpected" case (raise an error or return a default)
# 5. Return final result
ValueError, your skeleton should include a “Validate inputs” step.True vs. False, your skeleton must reveal how and when each is returned.compute_popularity
compute_popularity(song) from Section 2, which calculates rating × log(play_count + 1) for a single song. Here’s how its skeleton might look:
import math
def compute_popularity(song: list) -> float:
"""
Returns a popularity score based on rating and play_count.
(See Section 2 for the full docstring.)
"""
# 1. Validate 'song' is not None and has the form [title, rating, play_count]
# - rating in [1..5], play_count >= 0
# - If invalid, raise ValueError
# 2. Calculate popularity = rating * math.log(play_count + 1)
# 3. Return the popularity (float)
pass
rating = 5, play_count = 0 (expecting 0), a typical case for rating = 5, play_count = 100, and invalid inputs that raise ValueError. Each bullet in the skeleton lines up with those tests. If we neglected to handle play_count < 0, our skeleton would be missing a crucial step—and a test would (hopefully) fail.
find_favorite_songs.
find_favorite_songs(library) function from earlier sections, which returns a list of titles for songs with a rating >= 4. Write a short skeleton that:
library (must be non-empty; each entry is [title, rating, play_count])rating ≥ 4, and appends song[0] to the resultcreate_playlist.
create_playlist function that filters songs by mood (either "chill" or "upbeat") and then sorts them by rating (highest first). Sketch a skeleton:
True.
False.
remove_song(library, song_title) to delete a song from library. We already have:
Data Definition (Section 1):
Method Signature & Purpose Statement (Section 2):def remove_song(library: list, song_title: str) -> bool:
title == song_titlefromlibrary, returningTrueif successful orFalseif the song is not found.libraryis a list ofSongitems.song_titleis non-empty.ValueErrorifsong_titleis empty.
Examples & Tests (Section 3):We have test scenarios confirming removal of an existing song, returningTrue, plus tests checking an empty library or absent title (returnFalse), and aValueErrorifsong_titleis empty.
remove_song using the Design Recipe so that your final code is structured and aligns with the above deliverables. In your answer, do the following:
song_title is non-empty, using the test scenarios from Section 3 to guide your logic).# remove_song(library, song_title) -> bool # Step 1: Validate Inputs # - If song_title is empty, raise ValueError # - If library is None or not a list, maybe raise ValueError # # Step 2: Loop through each song in library # - Check if the current song's title == song_title # - If found, remove that song from library, return True # # Step 3: If loop ends with no match, return False
Song and song_title is valid (non-empty).bool and possibly raise ValueError if song_title is empty.
