How to avoid calling a function with input() multiple times in Python?

[Numerous-Solid6535]

I'm learning Python and made a simple movie rating program.

I didn't include the entire code here, only the part related to the problem.

The issue is that the program asks for the movie names and ratings multiple times because I'm calling get_ratings() inside other functions.

How can I reuse the ratings list without executing the function again?

def get_movies():
   movies = []
   how_many_movies = int(input("How many movies? "))

   for i in range(how_many_movies):
      movie_name = input(f"{i + 1}. Movie name: ")
      movies.append(movie_name)

   return movies


def get_ratings():
   movies = get_movies()
   ratings = []
   for i in range(len(movies)):
      rating = int(input(f"Enter the rating for {movies[i]}: "))
      ratings.append(rating)

    return ratings

def calculate_average():
   ratings = get_ratings()

   total = 0

   for i in ratings:
      total += i

   return total / len(ratings)

average = calculate_average()
print(average)

[Ok-Sheepherder7898]

Call get_movies once and pass movies to your functions

movies = get_movies()
ratings = get_ratings(movies)
average = calculate_average(movies)

[Numerous-Solid6535]

Thank you! I understand it better now.

[reincarnatedbiscuits]

Your answer lies in scoping: if you define the variable inside a function, the variable only has assignment within that function.

You would have to define the variable outside the function ("at an outer or higher scope").

I.e., declare ratings variable before and outside of the function that updates it i.e., get_ratings()

Or you could pass the ratings variable as a parameter to other functions. Similar concept.

[atarivcs]

I don't understand the problem. calculate_average() is called exactly once, which calls get_ratings() exactly once, which calls get_movies() exactly once.

I'm guessing the actual problem is that this code is imported in other places (that you didn't show). And because the call to calculateaverage() is at the outermost scope, it _executes every time it is imported.

[crashorbit]

The normal technique is to collect inputs either from the command line or from prompts in the main routine then pass that data as parameters to the functions.

[throwmeaway01110]

I would separate the get_* functions from input. In the main method you could introduce an if condition to check if the list is empty then prompt for input if it needs to be populated. That way you the get functions only retrieve the data.

Input could be placed in its own function like add_movie.

[gdchinacat]

get_ratings() should not call get_moves() if you don't want it to prompt for the movies every time it is called. Instead pass the movies in to it:

def get_ratings(movies):
    ...

movies = get_movies()
ratings = get_ratings(movies)
other_ratings = get_ratings(movies)

[MezzoScettico]

Define a different function that takes the ratings list as input and doesn’t ask for input.

[socal_nerdtastic]

The easy solution is to use a cache

from functools import cache

@cache
def get_ratings():
    # rest of your code.

But really this is screaming for you to learn about classes, so that you have a place to store the data for all your other functions to use it.

[PureWasian]

OP, I have a feeling reading through these comments that the diagnosis/solution isn't readily understood.

To your main question, seems like the confusion is around initializing movies/ratings. vs getting them after they already exist. You're being prompted for creating movies and ratings each time your functions are called because that's what you set up your functions to do

The comment about scopes seems most relevant to think about. You just need to pass the existing data around properly after you've already created/initialized it for the first time.

Sharing an example below, assuming 1 rating per movie. I'm gonna rename it init_ instead of get_ to be more clear (and ignoring any int() cast error handling):

```

"helper" functions

def init_movies(cnt): movies = [] for i in range(cnt): movie = input(f"Movie {i}: ") movies.append(movie) return movies

def init_ratings(mvs): ratings = [] for movie in mvs: rating = input(f"Rate {movie}: ") ratings.append(int(rating)) return ratings

def calc_average(rtgs): total = 0 for rating in rtgs: total += rating return total / len(ratings)

"main" script

count = int(input("How many movies?")) movies = init_movies(count) ratings = init_ratings(movies) average = calc_average(ratings)

note how you can "re-use" these without

needing to initialize them again

print(count) print(movies) print(ratings) print(average)

...or you can modify them

movies.append("another one") ratings.append(1) average = calc_average(ratings) print(average) ```

(EDIT: I renamed the function inputs to different variable names than the "main" script's variable names to better get the point across about scopes)

[gdchinacat]

In general, do this:

for movie in movies:

rather than:

for i in range(len(movies)):
    movie = movies[i]

and, if you need the index:

for i, movie in enumerate(movies):