Question

Sandwiches: Write a function that accepts a list of items a person wants on a sandwich. The function should have one parameter that collects as many items as the function call provides, and it should print a summary of the sandwich that is being ordered. Call the function three times, using a different number of arguments each time.

Short answer

Define `make_sandwich(*args)` and print the items. Call three times with varying arguments.

Step-by-step solution

Define the Function

Start by defining a Python function named `make_sandwich`. This function will take a variable number of arguments, so use the '*args' syntax. This allows the function to accept any number of arguments passed to it.

Create a Summary within the Function

Inside the function, print a message summarizing the items that will be included in the sandwich. Use a loop to iterate over the `args` to access each item, and format the output neatly.

Plan to Call the Function

Prepare to call the function `make_sandwich` three times. Each call should include a different number of arguments to test the function's ability to handle variable input sizes.

Call the Function with Sample Orders

Execute the function `make_sandwich` three times with different numbers of arguments. For example: ```python make_sandwich('ham', 'cheese') make_sandwich('turkey', 'lettuce', 'tomato') make_sandwich('peanut butter', 'jelly', 'banana', 'honey') ```

Verify Output

Check that the output of each function call correctly summarizes the sandwich order, listing all the items provided in the arguments.

Key concepts

Functions in Python

Functions in Python are a way to encapsulate code that performs a specific task. They define a particular behavior or action that can be reused throughout a program.
Functions help in organizing code, making it readable and maintainable. A function has a name, can take arguments (inputs), and can return outputs.
For example, defining a function starts with the `def` keyword followed by a name and parameters: ```python def make_sandwich(*items): # Code to execute ```

• `def`: The keyword to declare a function.
• `make_sandwich`: The name of the function, chosen to be descriptive of its operation.
• (*items): Represents parameters, allowing the function to accept multiple input values.

Functions can perform calculations, modify data, or execute tasks, such as printing a custom sandwich order.
By encapsulating this action in a function, you only write the task once and reuse it multiple times. This saves time and reduces errors.

Variable Arguments

In Python, variable arguments allow a function to accept any number of arguments. This is facilitated by the use of the `*args` syntax.
The `*args` parameter is used to pass a variable-length argument list to the function. It allows you to input as few or as many arguments as you want when calling the function.

• Flexible Input: With `*args`, the function can process varying numbers of arguments, making it adaptable and flexible.
• Usage Syntax: The asterisk `*` before the parameter name tells Python to pack all the extra arguments into a tuple named `args`.
• Unpredictable Data: Great for when the number of input items is not known beforehand.

For instance, in our sandwich-making function: ```python make_sandwich('ham', 'cheese') make_sandwich('turkey', 'lettuce', 'tomato') ``` Each call can have a different number of parameters, all handled seamlessly.

List Iteration

List iteration in Python allows you to go through elements sequentially in a list or collection. This is particularly useful when you need to perform actions on each element, such as printing or processing data.
Iterating over a list can be done with loops like `for` loops, which go through each item in order: ```python for item in items: print(f"Including {item} on your sandwich.") ```

• Access Each Element: Iteration means you can process each item in a collection individually.
• Simplify Operations: Automatically go through all elements, writing less and more efficient code.
• Formatting Output: Great for generating detailed, formatted output from collections.

Using iteration in our `make_sandwich` function ensures all items are neatly listed in the sandwich summary.
Each ingredient is accessed and printed, creating a clear output without manually writing code for each possible ingredient.