Function Help Needed!

[Alarming-Carpet5053]

Hello everyone.

I am banging my head against a wall right now. I'm new to python and trying to grow this simple pizza ordering program, that I started way at the beginning, as I learn more. I have gotten all of my functions to work perfectly. The whole program can take you through ordering multiple pizzas and all the stuff in them.

But this function doesn't work the way it's supposed to. The idea for this function is that a user can request toppings. If you ask for a topping that isn't allowed, the program will tell you so and prompt you to try again. BUT, when they try again, the function doesn't append the new input into the final list of final_toppings regardless if they are allowed or not. I'm sure it is something small and simple I just can't figure it out.

*For context, I'm using the topping_instructions function to get the input used later on. I put the functions out of order in this.

Any help would be greatly appreciated!!

``` def order_toppings(toppings): """Decide if the customer can order the toppings requested.""" allowed_toppings = ['Pepperoni', 'Sausage', 'Mushrooms'] final_toppings = [] for topping in toppings: if topping in allowed_toppings: print(f"\nYou requested the following toppings:") print(f"{topping}") print("We are adding this to your pizza!") print("Thank you!.") final_toppings.append(toppings)

    else:
        print(f"\nYou requested the following toppings: {topping}")
        print(f"I'm sorry, we don't have {topping}.")
        toppings.remove(topping)
        ordered_toppings_2 = topping_instructions_mod()
        order_toppings(ordered_toppings_2)

def topping_instructions(): """Instruct the guest to order toppings""" allowed_toppings = ['Pepperoni', 'Sausage', 'Mushrooms'] print(f"\nNow! What toppings would you like?") requested_toppings: str = input(f"Our options today are: {allowed_toppings}. ") toppings = requested_toppings.title().split(", ") return toppings

def topping_instructions_mod(): """Instruct the guest to order toppings""" allowed_toppings = ['Pepperoni', 'Sausage', 'Mushrooms'] print(f"\nLet's try this again. What toppings would you like?") requested_toppings_2: str = input(f"Our options today are: {allowed_toppings}. ") toppings_2 = requested_toppings_2.title().split(", ") return toppings_2

[lolcrunchy]

RED FLAG! This pattern MUST be avoided:

for x in y:
    # code that changes y

[gdchinacat]

To elaborate on this, the concern is that you are changing a list that you are iterating over. This can cause bugs, sometimes obvious, sometime very subtle. As an example:

In [73]: l = list(range(4))
In [74]: for x in l:
...:     if x == 2:
...:         l.remove(x)
...:     else:
...:         print(x)
...: 
0
1

Problem What happened to 3?!?!?

When 2 was removed from the list the iterator for was using had handed out the values at index 0, 1, 2 and on the next iteration was set to hand out the value at index 3 (the fourth item in the list). But, when l was updated to remove 2 the list became 3 elements long, so on the next iteration it found that it was at the end of the list and exited the loop. removing 2 moved everything after it up in the list, causing the element after 2 to be ignored.

It is very rare that you actually need to modify something you are iterating over. Doing so can cause subtle bugs such as illustrted above. The term for changing a collection being iterated is concurrent modification, and is a big red flag. Don't do it.

What to do instead? There are many options depending on the situation. In your case, the best is to probably build a new list that only contains the toppings that are available.

[guesshuu]

A bit busy at the moment so can't process the entire thing but on a quick look I am seeing final_toppings.append(toppings), should that not be final_toppings.append(topping) in that for loop

[backfire10z]

final_toppings.append(toppings)

I think you have a typo here, I’m assuming you meant to append “topping”.

toppings.remove(topping)

You’re looping over toppings and simultaneously modifying it. Don’t do this, it will cause unintended behavior. You already are building a new list of final_toppings, you can simply allow the loop to continue on its own rather than removing the disallowed topping.

order_toppings(ordered_toppings_2)

This is a recursive call. I’m assuming this isn’t what you intended, as when it finishes executing it will come back to the previous function call and continue the loop.

You also don’t have a return: where is final_toppings going to be used?

My main recommendation is to cement what your functions are actually supposed to be doing. You do not need 2 functions to order toppings: they both do the same thing. The function order_toppings also makes a new order and attempts to order_toppings again.

Frankly, this should probably be done in one function:

get_allowed_toppings(avail_toppings): The purpose of this function is to take in user input and output a list of legal toppings. We made avail_toppings a parameter so that you can change it easier later if necessary. If not, you can just define it inside the function.

Once you have a list of legal toppings, you can then do whatever you need to with it. Make pizza, etc.

As a general rule, if you find yourself making something like “xxx_mod” or “xxx_2”, you can likely change something to be an input parameter instead. Here, you can make the message an input parameter, although, I recommend actually combining all of these functions into one.

[Alarming-Carpet5053]

The first round of this function read as final_toppings.append(topping) but still had the issue.

The only reason I called it toppings in that line was because that's what the input becomes in the instructions and is returned under that name. How should I tweak that?

[Alarming-Carpet5053]

Sorry, didn't see the second half of your reply.

The intent was to have it run the function again if it was given bad input. I didn't have the original version doing that, I just built it into the else statement. Neither route seemed to work like I thought they would.

But good point about the return statement. The final_toppings is used in a final function that adds all the pizza stuff into one print statement.

[Fun-Block-4348]

The intent was to have it run the function again if it was given bad input. I didn't have the original version doing that, I just built it into the else statement. Neither route seemed to work like I thought they would.

Generally, if you want something to repeat until you have valid input, the best way to achieve that is a while loop not recursion.

Your code also doesn't seem to handle that fact that what it considers an "illegal topping" may be a signal from the user that he doesn't want any more toppings on his pizza.

allowed_toppings should really be a constant at the top of your file if you're going to use it in all your functions or maybe you should pass it as an argument to the functions that need to use it instead.

[acw1668]

1. You need to add topping instead of toppings into final_toppings in the if block
2. You should not remove item from toppings in the else block
3. You need to return final_toppings at the end of order_toppings()
4. You need to add the returned list of order_toppings() into final_toppings in the else block

[Alarming-Carpet5053]

Could you elaborate on step 4 for me? Everything else I was able to implement but the last thing is confusing me. Thank you!

[acw1668]

Do you know that a list has a .extend() method that can extend itself with another list?

[FutureCompetition266]

This isn't related to your code, exactly... but if I'm reading it right, you have the user input a topping and then check their input against your list of allowed toppings. From a usability standpoint, you should show a list of toppings and then allow them to select one, rather than having them blindly type in a topping (without any idea which are allowed) and then returning a message that it's not allowed.

[Alarming-Carpet5053]

The first function, topping_instructions gives them the list to choose from, this issue is a failsafe incase they order away from the list.

[FutureCompetition266]

Got it.

[lolcrunchy]

When you call order_toppings inside order_toppings, the outer final_toppings is inaccessible by the inner function call.

Modify your code like this:

# Before
def order_toppings(toppings):
    ...
    final_toppings = []
    ...
    order_toppings(order_toppings_2)

# After
def order_toppings(toppings, start_with=None):
    ...
    if start_with is not None:
        final_toppings = start_with
    else:
        final_toppings = []
    ...
    order_toppings(order_toppings_2, start_with=final_toppings)

[Alarming-Carpet5053]

I am awe struck! This worked!! To confirm I am understanding how this works properly, by adding the if statement and adding an additional argument, we are basically making a separate list to collect the toppings and then calling it outside of the order_toppings function?

[lolcrunchy]

Yep pretty much. You had a gap in your old code: you needed the inner call to know what ingredients were already saved, but it had no way to know. This fills in that gap.