Question

Magicians: Make a list of magician’s names. Pass the list to a function called show_magicians(), which prints the name of each magician in the list.

Short answer

Create a list, define a function to print the list, and call that function.

Step-by-step solution

Create a List of Magicians

First, create a list in Python that contains the names of the magicians you want to display. You can name this list `magicians`. Here is an example: ```python magicians = ['Harry Houdini', 'David Blaine', 'Penn and Teller'] ```

Define the Function

Next, define a function called `show_magicians()` that will take the `magicians` list as a parameter and print each magician's name. Here's how you can define the function: ```python def show_magicians(magicians): for magician in magicians: print(magician) ```

Call the Function

Finally, call the `show_magicians()` function and pass the `magicians` list to it. This will execute the function and print each name in the list: ```python show_magicians(magicians) ```

Key concepts

Functions in Python

In Python, functions are blocks of reusable code that execute a specific task. They help streamline and organize code, making it easier to read and understand. A function is defined using the `def` keyword, followed by a name and parentheses. Inside the parentheses, you can specify parameters that the function will use.

For example, when we defined the `show_magicians()` function, we included the `magicians` list as a parameter. This tells the function to expect a list that it can work with. Here's how you define a simple function:

• The `def` keyword starts the function definition.
• The function name allows you to reference it later.
• Parameters inside parentheses act as placeholders for values you'll provide later.
• The colon (`:`) signals the start of the function's code block.
• Indentation is critical in Python and shows which code belongs to the function.

A key benefit of functions is that once defined, you can call them as many times as needed, avoiding repetition and ensuring consistency.

Lists in Python

Lists in Python are one of the most versatile and widely used data structures. They allow you to store an ordered collection of items. You can put almost anything in a list, like numbers, strings, or even other lists. Lists are defined by placing a comma-separated sequence of elements within square brackets `[]`.

Here is an example list: ```python magicians = ['Harry Houdini', 'David Blaine', 'Penn and Teller'] ```

• Lists are ordered, meaning that each element has a specific position or index.
• Python lists are mutable, so you can add, remove, or change elements after the list is created.
• They can hold elements of different data types, but typically it's good practice to keep them consistent.
• Indexes in Python lists start from 0, so the first element is accessed with `list_name[0]`.

Lists are essential for handling collections of data and are often used alongside loops for efficient data processing.

Looping Through Lists

Looping through lists is a fundamental technique in Python programming. It allows you to perform actions on each element within a list. The `for` loop is a common way to iterate over a list.

The syntax generally looks like this: ```python for item in list_name: # Perform action with item ```

• The `for` loop starts with the `for` keyword followed by a temporary variable (e.g., `item`) that represents each element in the list.
• The `in` keyword is used to specify the list you want to loop through.
• A colon (`:`) indicates the beginning of the loop's code block, which will execute for each element.
• Each iteration of the loop assigns the current list element to the temporary variable, allowing you to work with it.
• Indentation is crucial to define the nested code that belongs to the loop.

In our exercise, we used a `for` loop to print each magician's name. This is an efficient way to handle collections of data, as it eliminates the need for manual indexing and enhances code readability.