Operations on lists

In this section, we will explore various operations and concepts related to lists in Python. Lists are a versatile data structure that allows us to store and manipulate collections of elements. We will learn how to process lists using slices and the in and not in operators. Although we have covered the in and not in operators previously, in this article, we will recap their usage. Additionally, we will analyze simple programs that demonstrate the practical application of lists in more challenging projects.

First, we will delve into the inner workings of lists and uncover a surprising feature that sets them apart from ordinary variables. We will explore how lists are stored in memory and understand the implications of assigning one list to another. This understanding is crucial for avoiding potential issues in our programs. Next, we will discover the power of slices in Python. Slicing allows us to create new copies of lists or extract specific portions of a list without modifying the original list. We will explore different forms of slicing syntax and understand how to use positive and negative indices to specify the desired elements. Through examples and experimentation, we will witness how slices can be employed effectively.

Furthermore, we will introduce the in and not in operators, which provide a convenient way to search for specific values within a list. These operators allow us to check if an element is present or absent in a list, returning True or False accordingly. We will see these operators in action and understand their usefulness in different scenarios.

To solidify our understanding of lists, we will examine a few simple programs that showcase their practical applications. We will explore programs that find the largest value in a list, search for the location of an element within a list, and others. These examples will highlight the versatility and effectiveness of lists in solving real-world problems.

By the end of this section, you will have a solid understanding of list processing techniques, allowing you to leverage lists effectively in your Python projects.

In this section, we will delve into the inner workings of lists in Python and explore a crucial feature that sets them apart from ordinary variables. It is important to grasp this concept as it can significantly impact your future programs and potentially lead to issues if overlooked. We will walk you through an example and provide insights on how to effectively manage this behavior.

The Unexpected Behaviour

Let's begin by examining a surprising behavior when working with lists. Consider the following code snippet:

list_1 = [1]
list_2 = list_1
list_1[0] = 2
print(list_2)

One might expect the output to be [1], as we only modified list_1, but the actual result is [2]. This unexpected outcome highlights a fundamental difference between lists and scalar variables.

Knowing the Difference

Lists (along with other complex Python entities) are stored differently compared to scalar variables. To comprehend this distinction, consider the following analogy:

• The name of an ordinary variable represents its content.
• The name of a list represents a memory location where the list is stored.

Take a moment to absorb this concept as it forms the basis of our subsequent discussion.

Copying Names, Not Contents

In the assignment list_2 = list_1, the name of the list (list_1) is copied, not its contents. Consequently, both list_1 and list_2 refer to the same memory location. Any modifications made through one name will affect the other, creating a bidirectional relationship.

In the section above, we have the assignment: list_2 = list_1 copies the name of the array, not its contents. In effect, the two names (list_1 and list_2) identify the same location in the computer memory. Modifying one of them affects the other, and vice versa.

What Strategies Can Be Used to Address the Problem?

Fortunately, Python offers a simple yet powerful solution to make copies of lists or extract specific parts from them: slices. Slices are a fundamental element of Python syntax that enables you to create brand new copies of lists or select portions of a list with ease. What sets slices apart is that they copy the actual contents of the list, not just its name. This distinction is crucial for understanding the true power of slices. Let's take a closer look at a code snippet to illustrate their functionality:

list_1 = [1]
list_2 = list_1[:]
list_1[0] = 2
print(list_2) #Output: [1]

In this example, the list_1 contains a single element, which is then assigned to list_2 using slice notation [:]. When we modify the first element of list_1 to 2, we might expect list_2 to remain unchanged. However, thanks to slices, the output of this code will be [1]. This seemingly small addition of [:] creates a new list, independent of the original, ensuring that any modifications made to one list do not affect the other. Slices are a vital tool for working with lists in Python, providing flexibility and control over your data.

Basic Slicing in Python Lists

A key feature of slices in Python is their ability to extract specific portions of a list using a general syntax. The basic form of a slice is my_list[start:end], which may look similar to indexing, but the colon inside makes a significant difference as shown in figure below.

This type of slice creates a new list, referred to as the target list, by selecting elements from the source list based on the indices ranging from start to end-1. It's important to note that the ending index is not inclusive but represents the first element that is excluded from the slice. This behavior ensures that the resulting slice corresponds precisely to the desired range of elements. Furthermore, just like indexing, it is possible to use negative values for both the start and end indices, enabling you to conveniently extract elements from the list in reverse order or relative to the end of the list. Slices provide a versatile and intuitive mechanism for manipulating and extracting subsets of lists in Python.

Examples of Slicing in Python Lists

In the code snippet below, we demonstrate the usage of slicing in Python to create new lists or extract specific parts of existing lists:

# Copying the entire list.
list_1 = [1]
list_2 = list_1[:]
list_1[0] = 2
print(list_2)

# Copying some part of the list.
my_list = [10, 8, 6, 4, 2]
new_list = my_list[1:3]
print(new_list)

In the first part of the code, we create a list list_1 with a single element. To make a copy of the entire list, we use slicing with [:], which effectively duplicates the content of list_1 into list_2. Modifying list_1 by assigning a new value to its first element does not affect list_2, as they are now separate lists. The output of the code will be [1], demonstrating that the contents of list_2 remain unaffected.

In the second part of the code, we have a list called my_list with elements [10, 8, 6, 4, 2]. By using the slice my_list[1:3], we create a new list new_list that contains the elements at indices 1 and 2 from my_list. The slicing excludes the element at index 3, resulting in a new_list with elements [8, 6]. Running the code will print the new_list as the output, demonstrating the extraction of a specific part of the original list.

Slice Syntax and Behavior

When using slicing in Python lists, the syntax my_list[start:end] allows you to specify a range of elements to include in the slice. The start index represents the first element to be included, while the end index represents the first element that is not included in the slice. Negative indices can also be used to refer to elements relative to the end of the list.

When Start Index < End Index(e.g. my_list[1:-1])

If the start index is less than the end index (counting from the beginning of the list), the resulting slice will be as follow:

my_list = [10, 8, 6, 4, 2]
new_list = my_list[1:-1]
print(new_list)

The output of this snippet is [8, 6, 4]. Here, the slice my_list[1:-1] includes elements with indices 1, 2, and 3, but excludes the element at index-1.

When Start Index > End Index (e.g. my_list[-1:1])

If the start index is greater than the end index (counting from the beginning of the list), the resulting slice will be empty. For instance:

my_list = [10, 8, 6, 4, 2]
new_list = my_list[-1:1]
print(new_list)

The output of this snippet is an empty list [], as the start index-1 refers to an element beyond the one described by the end index 1.

In the example, we are trying to create a slice of my_list using the indices -1 and 1. The start index is -1, which refers to the last element of the list, and the end index is 1, which refers to the element at index 1 (the second element of the list).

Conclusion

However, when slicing a list, the start index must be less than the end index to define a valid range. In this case, the start index-1 is greater than the end index 1, counting from the beginning of the list. As a result, the resulting slice is empty because there are no elements within that range.

Therefore, when we print new_list, we get an empty list [] as the output. It indicates that no elements are included in the slice due to the invalid range specified by the start and end indices.

When Omitting Start Index (e.g. my_list[:end])

When omitting the start index in a slice, it is assumed that you want to begin at the element with index 0. This can be achieved using the slice my_list[:end], which is equivalent to my_list[0:end]. Consider the following example:

my_list = [10, 8, 6, 4, 2]
new_list = my_list[:3]
print(new_list)

The output is [10, 8, 6], as the slice includes elements with indices 0, 1, and 2.

When Omitting End Index (e.g. my_list[start:])

Similarly, omitting the end index in a slice assumes that you want the slice to extend until the element with index len(my_list). This is equivalent to using my_list[start:], which is the same as my_list[start:len(my_list)]. Take a look at the following snippet:

my_list = [10, 8, 6, 4, 2]
new_list = my_list[3:]
print(new_list)

The output is [4, 2], as the slice includes elements with indices 3 and 4.

When Omitting Both Index (e.g. my_list[:])

Lastly, if both the start and end indices are omitted, it creates a copy of the entire list:

my_list = [10, 8, 6, 4, 2]
new_list = my_list[:]
print(new_list)

The output is [10, 8, 6, 4, 2], representing a copy of the original list.

The del Instruction: Deleting Elements and Slices in Python Lists

The previously described del instruction in Python can be used to delete not only individual elements from a list but also slices of elements. In the code snippet:

my_list = [10, 8, 6, 4, 2]
del my_list[1:3]
print(my_list)

We use del to remove a slice from my_list. The slice specified is [1:3], which corresponds to elements at indices 1 and 2 (excluding the element at index 3). The output of the snippet is [10, 4, 2], indicating that the elements within the specified slice have been deleted from the list.

Moreover, it is also possible to delete all the elements of a list at once using del:

my_list = [10, 8, 6, 4, 2]
del my_list[:]
print(my_list)

By specifying del my_list[:], we remove all the elements from my_list, resulting in an empty list. The output will be [].

However, it's important to note that if the del instruction is used to delete the list itself, rather than its content, it will lead to a runtime error when trying to access the list. Consider the following code:

my_list = [10, 8, 6, 4, 2]
del my_list
print(my_list)

Here, del my_list deletes the list itself. As a result, trying to access my_list in the print statement will cause a runtime error, indicating that the list no longer exists.

In Python, the "in" and "not in" operators are powerful tools for searching within a list to determine if a specific value is present or absent, respectively. The "in" operator checks if the left argument (an element) is stored somewhere inside the right argument (a list), returning True if the element is found. On the other hand, the "not in" operator checks if the left argument is absent in the list, returning True if the element is not found. Let's consider the following code snippet as an example:

my_list = [0, 3, 12, 8, 2]

print(5 in my_list)
print(5 not in my_list)
print(12 in my_list)

The output of this code will be:

In the first print statement, we check if 5 is present in my_list, which returns False since 5 is not an element of the list. The second print statement checks if 5 is not in my_list, which returns True as 5 is indeed absent. Finally, the third print statement checks if 12 is present in my_list, returning True as 12 is one of the elements in the list. Feel free to run the code and observe the results for yourself.

In Python, the :: syntax is used for slicing with extended functionality. It allows you to specify the start, stop, and step values for the slice.

The general syntax for slicing is [start:stop:step], where:

• start represents the starting index of the slice (inclusive). If not specified, it defaults to the beginning of the sequence.
• stop represents the ending index of the slice (exclusive). If not specified, it defaults to the end of the sequence.
• step represents the step value, which determines the increment between indices. If not specified, it defaults to 1.

When you use [::-1], it means:

• start is not specified, so it defaults to the beginning of the sequence.
• stop is not specified, so it defaults to the end of the sequence.
• step is -1, indicating that the indices are traversed in reverse order.

Here are a few examples to illustrate the usage of slicing with :: ->

Example 1:

sequence = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = sequence[::2]
print(result)

In this example, the slice [::2] selects elements from the sequence list starting from the beginning, incrementing by 2. It returns [1, 3, 5, 7, 9], which includes every other element.

Example 2:

string = "Hello, World!"
result = string[::3]
print(result)

In this example, the slice [::3] selects characters from the string starting from the beginning, incrementing by 3. It returns "HlWl", which includes every third character.

Example 3:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = numbers[::-1]
print(result)

In this example, the slice [::-1] selects elements from the numbers list in reverse order.

By adjusting the values of start, stop, and step in the slicing syntax, you can create custom slices and manipulate sequences in various ways.

In this section, we will showcase some simple programs that make use of lists to perform various tasks.

Finding the Largest Value in a List

The first program aims to find the largest value in a given list. Consider the following code:

my_list = [17, 3, 11, 5, 1, 9, 7, 15, 13]
largest = my_list[0]

for i in range(1, len(my_list)):
if my_list[i] > largest:
largest = my_list[i]

print(largest)

The concept behind this program is straightforward. We initially assume that the first element, my_list[0], is the largest value. Then, we compare this hypothesis with all the remaining elements in the list. The output of the code is 17, which is the expected result.

Improved Version with the for Loop

The program can be rewritten to take advantage of the simplified for loop syntax introduced earlier. Here's the modified code:

my_list = [17, 3, 11, 5, 1, 9, 7, 15, 13]
largest = my_list[0]

for i in my_list:
if i > largest:
largest = i

print(largest)

Although this version performs one extra comparison between the first element and itself, it doesn't pose any significant issues. The output remains the same, i.e., 17.

Optimizing Resource Usage with a Slice

If you're concerned about resource consumption, you can use a slice to iterate through a list. Consider the following code:

my_list = [17, 3, 11, 5, 1, 9, 7, 15, 13]
largest = my_list[0]

for i in my_list[1:]:
if i > largest:
largest = i

print(largest)

By using my_list[1:] as the iteration range, we exclude the first element from the loop, as it has already been assigned to largest. The output remains 17. However, it's worth considering whether the benefit of slicing outweighs the potential resource savings from omitting one comparison.

Locating an Element in a List

Next, let's explore a program that finds the location of a given element within a list. Here's the code:

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
to_find = 5
found = False

for i in range(len(my_list)):
found = my_list[i] == to_find
if found:
break

if found:
print("Element found at index", i)
else:
print("Absent")

In this program, the target value is stored in the to_find variable, and the search progress is tracked by the boolean variable found. The for loop iterates over the indices of my_list, checking if each element is equal to to_find. If a match is found, the loop is exited using break. The output displays either the index where the element was found or the message "Absent" if it is not present.

Counting Correct Answers in a Quiz:

Consider a scenario where you have taken a quiz, and you want to determine the number of correct answers you have obtained. Here's an example code:

quiz_answers = [True, False, True, True, False, True]
user_answers = [True, True, False, True, False, False]
correct_count = 0

for i in range(len(quiz_answers)):
if quiz_answers[i] == user_answers[i]:
correct_count += 1

print("Number of correct answers:", correct_count)

In this program, the quiz_answers list represents the correct answers for the quiz, while the user_answers list stores your responses. The variable correct_count keeps track of the number of correct answers. The program compares each element of quiz_answers with the corresponding element in user_answers. If the answers match, the correct_count is incremented. The output displays the total number of correct answers you have achieved.

Your task is to write a program that removes any repeated numbers from a simple list of integers. The objective is to have a new list where each number appears only once. Note that you can assume the source list is already given in the code and not entered by the user. You can create a separate temporary list as a workspace and there is no need to modify the original list directly. No test data is provided, as you can utilize the provided skeleton.

Possible Answer:

# Source list with repeated numbers
numbers = [2, 4, 6, 2, 8, 4, 10, 6]

# Create a new list to store unique numbers
unique_numbers = []

# Iterate over each number in the source list
for num in numbers:
# Check if the number is already present in the unique list
if num not in unique_numbers:
# Add the number to the unique list if it's not already present
unique_numbers.append(num)

# Print the resulting list with no repetitions
print(unique_numbers)

In conclusion, this section explored various operations and concepts related to lists in Python. We learned about list processing techniques such as slices and the in and not in operators. Understanding the difference between list references and memory was emphasized to avoid unexpected behavior. Slices were introduced as a powerful tool for creating copies of lists or extracting specific parts without modifying the original list. The slice syntax and behavior were explained, including examples of valid and invalid ranges. The del instruction was discussed for deleting elements and slices from a list. Additionally, the in and not in operators were introduced as useful tools for searching within a list. Finally, simple programs were presented to showcase the practical applications of lists, such as finding the largest value in a list. With this knowledge, you now have a solid understanding of list processing techniques and can leverage lists effectively in your Python projects.