Analyzing average movie budgets using Python 3

Question

This python program analyzes movie data by finding the average budget of films in a data set - it also identifies films that exceed the average budget calculated.

I need advice on my code in terms of (architecture, risks, opportunities, design) so that I can learn how I can code better & grow my skills.

# List of movies and their budgets
movies = [
    ('Avengers: Endgame', 400000000),
    ('Pirates of the Caribbean: On Stranger Tides', 379000000),
    ('Avengers: Age of Ultron', 365000000),
    ('Star Wars: Ep. VII: The Force Awakens', 306000000),
    ('Avengers: Infinity War', 300000000)
]

# Allows user to input how many movies they want to add to the list
add_new_movie = int(input('How many movies do you want to add? '))

# Takes the name and budget of the movie the user entered and add the movie to the list
for _ in range(add_new_movie):
    name = input('Enter movie name: ')
    budget = input('Enter movie budget: ')
    new_movie = (name, int(budget))
    movies.append(new_movie)

# List representing over budget movies and counter to keep track of the total budget of all the movies in the list
over_budget_movies = []
total_budget = 0

# Adds together the budget of each movie
for movie in movies:
    total_budget += movie[1]

# Calculates the average cost of all movies in the list
average_budget = int(total_budget / len(movies))

# If the movie budget is over the average budget, how much the movies are over budget will be calculated and added to the over budget list
for movie in movies:
    if movie[1] > average_budget:
        over_budget_movies.append(movie)
        over_average_cost = movie[1] - average_budget
        print(
            f"{movie[0]} was ${movie[1]:,}: ${over_average_cost:,} over average.")
        print()

# Prints how many movies were over the average budget
print(
    f"There were {len(over_budget_movies)} movies with budgets that were over average.")

This is entirely irrelevant to your specific question, but in terms of data analysis, Hollywood accounting is a good example of garbage in, garbage out. — Paul D. Waite
– Paul D. Waite, Commented Jun 18, 2021 at 9:25

FMc · Accepted Answer · 2021-06-17 23:40:27Z

Data entry without persistence does not make sense in most contexts. If a human has to type the data, save it somewhere. It could be a JSON file, CSV file, database, whatever you would like to try. This kind of approach -- where the data lives separately from the code -- has many benefits. It's a good vehicle for learning as well, so give it a shot.

Data entry and reporting are different tasks. Sometimes you want to add new data to the system. Sometimes you want to analyze that data, get reports, etc. In its simplest form, that might call for a program with 3 functions: a main() function where the user decides what to do (add data or get a report), and then one function for each task.

Use meaningful data objects rather than generic collections. Currently, you represent a movie as a 2-tuple. But that's not very declarative: for example, your code has to use movie[1] rather than movie.budget. Modern Python makes it super easy to create simple data objects (eg, namedtuple, dataclass, or attrs-based classes).

Avoid mixing computation and printing, if feasible. It's a good practice to separate computation and anything that has "side effects". Printing is the most common example of a side effect. This is a huge topic in computer science, and you can learn more about it as you go forward. But when you're learning, just try to get in the habit of keeping different things separate: for example, don't print over-budget movies while you are creating a list of them.

Here's an illustration of those ideas (ignoring data entry):

from collections import namedtuple

# Meaningful data objects.

Movie = namedtuple('Movie', 'title budget')

movies = [
    Movie('Avengers: Endgame', 400000000),
    Movie('Pirates of the Caribbean: On Stranger Tides', 379000000),
    Movie('Avengers: Age of Ultron', 365000000),
    Movie('Star Wars: Ep. VII: The Force Awakens', 306000000),
    Movie('Avengers: Infinity War', 300000000)
]

# Computation.

total_budget = sum(m.budget for m in movies)
average_budget = int(total_budget / len(movies))
over_budget_movies = [m for m in movies if m.budget > average_budget]

# Printing.

print(f'Number of overbudget movies: {len(over_budget_movies)}')
for m in over_budget_movies:
    diff = m.budget - average_budget
    print(f'{m.title} was ${m.budget}: ${diff} over average.')

You could also use total_budget // len(movies) (floor division, which is identical to casting to an integer for positive numbers). A better version would actually be to round to the nearest whole number (e.g. 3.75 -> 4 instead of 3). — IllustriousMagenta
– IllustriousMagenta, Commented Jun 18, 2021 at 6:01

Stack Exchange Network

Analyzing average movie budgets using Python 3

1 Answer 1

You must log in to answer this question.

Hot Network Questions

Analyzing average movie budgets using Python 3

1 Answer 1

You must log in to answer this question.

Related

Hot Network Questions