Snow Leopards- Ja Hopkins #153
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,23 +1,141 @@ | ||
| # ------------- WAVE 1 -------------------- | ||
|
|
||
|
|
||
| def create_movie(title, genre, rating): | ||
| # if truthy return a dictionary | ||
| # dictionary contains 3 key-value pairs | ||
| # return none if falsy | ||
| title_genre_rating = {} | ||
| if title and genre and rating: | ||
|
There was a problem hiding this comment. Nice truthy checks. But consider reversing the sense of the comparison so that the more error-like condition is handled within the conditional check, and the main logic (making the dictionary) doesn't need to be nested. Structuring the checks to look for the more error-like conditions is a pattern referred to as a guard clause, and it's a common way of organizing our code. if not title or not genre or not rating:
# code to run when one of the inputs is falsy
# code to run when all inputs are truthy |
||
| title_genre_rating.update({'title': title, 'genre': genre, 'rating': rating}) | ||
|
There was a problem hiding this comment. Notice that the argument to title_genre_rating = {'title': title, 'genre': genre, 'rating': rating} |
||
| return(title_genre_rating) | ||
|
There was a problem hiding this comment.
return ("this" + "is" + "a" + "long" + "expression"
+ "that" + "I" + "want" + "to" + "wrap") |
||
| return None | ||
|
There was a problem hiding this comment. Taking all that feedback, we might end up with a function like this: if not title or not genre or not rating:
return None
return {'title': title, 'genre': genre, 'rating': rating} |
||
|
|
||
| def add_to_watched(user_data, movie): | ||
|
|
||
| user_data["watched"].append(movie) | ||
| return user_data | ||
|
|
||
| # user_data = {watched: [{movie}{moveie}]} | ||
| # add each movie to the watched key | ||
|
|
||
| def add_to_watchlist(user_data, movie): | ||
|
|
||
| # user_data = {watchlist: [{movies}{user}]{wants}{to_watch}} | ||
| # add movie into the watchlist inside of user data | ||
| # return user_data | ||
| user_data["watchlist"].append(movie) | ||
| return(user_data) | ||
|
There was a problem hiding this comment. As above, no need for the parens on the return here (or throughout the rest of the functions). |
||
|
|
||
| def watch_movie(user_data, title): | ||
| # user_data = {watchlist: watched:} | ||
| # if title is in watch_list then add to watched: | ||
| # return user_data | ||
| # if not in watch list: | ||
| # return user_data | ||
|
|
||
| for movie in user_data["watchlist"]: | ||
| if title in movie.values(): | ||
|
There was a problem hiding this comment. This could potentially find the if title == movie["title"]: |
||
| user_data["watchlist"].remove(movie) | ||
| user_data["watched"].append(movie) | ||
|
There was a problem hiding this comment. Consider Also, a blank line after this would help visually separate the |
||
| return(user_data) | ||
|
|
||
|
|
||
|
|
||
| # ----------------------------------------- | ||
| # ------------- WAVE 2 -------------------- | ||
| # ----------------------------------------- | ||
|
|
||
| def get_watched_avg_rating(user_data): | ||
| # user data = {watched: [{movie2}, {movie2}]} | ||
| user_rating = [] | ||
|
|
||
| if len(user_data["watched"]) == 0: | ||
|
There was a problem hiding this comment. Nice handling for the case of an empty list. A slightly more pythonic way to check for whether a list is empty is if not some_list_var:
# code to handle empty listSo here, if not user_data["watched"]: |
||
| average_rating = 0.0 | ||
| return average_rating | ||
| else: | ||
|
There was a problem hiding this comment. Since the |
||
| for movie in user_data["watched"]: | ||
| user_rating.append(movie["rating"]) | ||
|
Comment on lines
+55
to
+56
There was a problem hiding this comment. We haven't talked about list comprehensions in python, but there's a special syntax that lets us effectively append a set of values very concisely. The following would initialize user_rating = [movie["rating"] for movie in user_data["watched"]]The general pattern lets us take some code like new_list = []
for item in old_list:
if should_process(item):
new_list.append(process(item))and write it like: new_list = [process(item) for item in old_list if should_process(item)] |
||
| average_rating = (sum(user_rating)) / (len(user_rating)) | ||
|
There was a problem hiding this comment. Notice that since this is indented under the loop, we're recalculating the average each time through the loop. We only need to do this once (after the loop), after we've added all of the ratings to the list in the loop. |
||
| # print(user_rating) | ||
| # print(average_rating) | ||
| return(average_rating) | ||
|
|
||
| def get_most_watched_genre(user_data): | ||
|
|
||
| genres_watched = {} | ||
|
|
||
| if not user_data["watched"]: | ||
|
|
||
| return None | ||
|
|
||
| for movie in user_data["watched"]: | ||
| if movie["genre"] not in genres_watched: | ||
| genres_watched[movie["genre"]] = 1 | ||
| elif movie["genre"] in genres_watched: | ||
|
There was a problem hiding this comment. A key is either in a dict or it's not. So we can use a |
||
| genres_watched[movie["genre"]] += 1 | ||
|
|
||
| num_of_genres_watched = genres_watched.values() | ||
| max_num_genres_watched = max(num_of_genres_watched) | ||
|
There was a problem hiding this comment. Nice use of We'll see that there's really not a performance difference, though, and arguably this code is a little simpler. (but writing a max finder ourself is great practice!). |
||
|
|
||
| for genre, times_watched in genres_watched.items(): | ||
| if times_watched == max_num_genres_watched: | ||
| return genre | ||
|
|
||
|
|
||
|
|
||
| # ----------------------------------------- | ||
| # ------------- WAVE 3 -------------------- | ||
| # ----------------------------------------- | ||
|
|
||
| def get_unique_watched(user_data): | ||
| # user_data = {watched :[{"title: title"}, {"title": title}], friends: [{watched_key:[{"title:title"}{title:title}]}{watched_key:[{title:title}{title:title}]}]} | ||
| # each movie dict in watched_key has a title | ||
|
|
||
| unique_movies = [] | ||
| movies_watched_by_friends = [] | ||
|
|
||
| for friend in user_data["friends"]: | ||
| for movie_details in friend["watched"]: | ||
| movie_title = movie_details["title"] | ||
| movies_watched_by_friends.append(movie_title) | ||
|
Comment on lines
+95
to
+98
There was a problem hiding this comment. Nice way to build up a list of movie titles the friends have watched. Notice that since you decided to use the title as representative of the entire movie record ( areasonable decision given our data), we could use a |
||
| # print(movie_details["title"]) | ||
| for movie in user_data["watched"]: | ||
| movie_watched = movie["title"] | ||
| if movie_watched not in movies_watched_by_friends: | ||
| unique_movies.append(movie) | ||
| # watched_titles.append(movie["title"]) | ||
| return(unique_movies) | ||
|
There was a problem hiding this comment. No need for |
||
|
|
||
| def get_friends_unique_watched(user_data): | ||
| all_movies_watched = [] | ||
| unique_movies_watched_by_friends = [] | ||
|
|
||
| for movie in user_data["watched"]: | ||
| movie_watched = movie["title"] | ||
| # add all the movies watched to new list | ||
| all_movies_watched.append(movie_watched) | ||
|
Comment on lines
+111
to
+114
There was a problem hiding this comment. As above, since you're using the title as a proxy for the entire moview, we could use a |
||
| for friend in user_data["friends"]: | ||
| for movie_details in friend["watched"]: | ||
| movie_title = movie_details["title"] | ||
| if (movie_title not in all_movies_watched and | ||
| movie_details not in unique_movies_watched_by_friends): | ||
|
There was a problem hiding this comment. Nice way to filter out a movie that's already been added from another friend. Here, we do need to build a list of movie detail records, not just the title. So As it is, doing the |
||
| # check if details are unqie friends list to avoid duplicates | ||
| # create list of dictionary containing movie details | ||
| unique_movies_watched_by_friends.append(movie_details) | ||
| return unique_movies_watched_by_friends | ||
|
|
||
|
|
||
|
|
||
| # ----------------------------------------- | ||
| # ------------- WAVE 4 -------------------- | ||
| # ----------------------------------------- | ||
|
|
||
| def get_available_recs(user_data): | ||
| recommended_movies = [] | ||
| friends_watched = get_friends_unique_watched(user_data) | ||
|
There was a problem hiding this comment. 👍 Great reuse of your |
||
| for movie in friends_watched: | ||
| if movie["host"] in user_data["subscriptions"]: | ||
| recommended_movies.append(movie) | ||
| return recommended_movies | ||
|
|
||
| # ----------------------------------------- | ||
| # ------------- WAVE 5 -------------------- | ||
| # ----------------------------------------- | ||
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
👍