Question

Write a program that reads numbers and adds them to a list if they aren't already contained in the list, When the list contains ten numbers, the program displays the contents and quits.

Short answer

Read numbers continually, add to list if unique, stop and print when list has 10 numbers.

Step-by-step solution

Initialize an Empty List

Start by creating an empty list that will be used to store unique numbers. This will be our main data structure to keep track of the numbers we collect.

Set Up a Loop to Read Numbers

We need a way to continuously prompt for and read numbers from input. Set up an infinite loop (using a `while` loop) to handle this as we'll stop only when our condition is met.

Process Input to Check Uniqueness

Inside the loop, take each number entered by the user. Use an `if` statement to check if the number is already in the list. If it's not, add it to the list.

Check Count of Numbers in List

After processing each entry, check the length of the list. Use the `len()` function to determine if the list has reached ten numbers.

Display and Terminate

If there are ten numbers in the list, print the list contents using the `print()` function and then break the loop to terminate the program.

Key concepts

Control Structures

Control structures in Python are fundamental in directing how a program flows. They help us decide which blocks of code to execute based on certain conditions. In this exercise, two primary control structures are used:

• If statements: Crucial for decision-making, the `if` statement checks whether a condition is met—that is, whether a number is already present in the list.
• While loops: This is essential for repeating an action. Here, it allows us to continually prompt the user for a number until our list meets a specific condition—containing ten unique numbers.

Understanding these control structures helps us create dynamic and flexible programs that can handle a variety of inputs and execute actions based on specific requirements.

Lists

Lists are a versatile data structure in Python, perfect for storing multiple items. In this program, we use a list to collect unique numbers. Lists support various operations which make them highly adaptable:

- Creation and Initialization: Starting with an empty list, it becomes simple to collect data as it comes in. This is done with `my_list = []`. - Checking Membership: By using the `in` keyword, we can quickly check if a number is part of the list, ensuring we only add unique items. - Length Checking: To decide when to stop our loop, we use the `len()` function to count items in our list. This functionality is crucial for controlling the loop's termination.

Input and Output

Input and output are key aspects of interacting with the user in Python. In this exercise, we cover both:

• Input: We use the `input()` function to read a number from the user. This function allows us to collect data and store it appropriately after conversion from a string to an integer using the `int()` function.
• Output: The `print()` function allows us to display information back to the user. Once the list contains ten numbers, `print()` outputs the list contents, showing the user all stored numbers.

Mastering input and output operations is vital for developing interactive Python programs that can handle user data effectively.

Loops

Loops are programming constructs that allow us to execute a block of code multiple times. In this problem, we use a `while` loop until specific conditions are met. Loops are especially useful when the number of iterations required is unknown at the start: - Infinite Loops: We initiate an infinite loop with `while True:` that keeps asking for more numbers. This loop continues indefinitely until explicitly terminated using `break` when our list reaches ten unique numbers. - Break Statements: This statement helps us exit the loop once the condition of having ten numbers is satisfied. Break statements are useful in controlling loop execution and stopping further iterations once our desired result is achieved. Loops add the capability to handle repetitive tasks efficiently, saving time and reducing code redundancy.