Python Lists Exercises

Which of the following statements about Python lists is correct?

Lists can store elements of different data types in the same list.

Lists can only store integers or floats.

Once created, a list cannot be modified.

Lists are immutable like strings.

Python lists are a versatile data structure that allow you to store multiple items in a single variable. Here’s what makes lists special:

Heterogeneous elements: Lists can store elements of different data types, e.g., integers, strings, floats, and even other lists.
Mutable: Unlike strings or tuples, you can modify a list after it is created by adding, removing, or changing elements.
Ordered: The elements in a list maintain the order in which they were added, allowing access by index.

Example:

my_list = [10, "hello", 3.14, True]
print(my_list[1])  # Output: hello

Key Takeaways:

Use lists when you need a collection of items that can change over time.
You can mix different data types in the same list.
Remember: Lists are ordered, mutable, and versatile.

What will be the content of `my_list` after executing the following code?

my_list = [1, 2, 3]
my_list.append(4)

[1, 2, 3]

[1, 2, 3, 4]

[4, 1, 2, 3]

[1, 2, 3, [4]]

In Python, the append() method adds a single element to the end of a list.

The original list is [1, 2, 3].
my_list.append(4) adds the element 4 at the end of the list.
The updated list becomes [1, 2, 3, 4].

Key Points:

append() always adds a single item to the end.
If you want to add multiple elements, use extend() instead.
Remember, append() modifies the list in place; it does not return a new list.

Which of the following methods can be used to insert an element at a specific position in a Python list?

append()

insert()

extend()

remove()

Python provides several methods to modify lists. To insert an element at a specific index, you can use the insert() method.

Syntax: list.insert(index, element)
Example:

my_list = [10, 20, 30]
my_list.insert(1, 15)  # Insert 15 at index 1
print(my_list)  # Output: [10, 15, 20, 30]

append() adds at the end.
extend() adds multiple elements from another iterable.
remove() deletes an element.

Tip: Use insert() when you need precise placement of an element in the list.

What will be the result of the following slicing operation?

my_list = [10, 20, 30, 40, 50]
print(my_list[1:4])

[10, 20, 30, 40]

[20, 30, 40]

[20, 30, 40, 50]

[10, 20, 30]

Python list slicing allows you to extract a portion of the list using the syntax list[start:end]. The start index is inclusive, and the end index is exclusive.

Here, my_list[1:4] starts at index 1 (value 20) and goes up to, but not including, index 4 (value 50).
So the sliced list is [20, 30, 40].

Key Takeaways:

Remember: slicing does not modify the original list.
Negative indices can be used to slice from the end.
Omitting start or end defaults to the beginning or end of the list.

Which of the following methods can be used to find the number of elements in a Python list?

length()

count()

size()

len()

To find the number of elements in a Python list, we use the built-in len() function. This function works for lists, strings, tuples, dictionaries, and other iterable objects.

Example:

my_list = [5, 10, 15, 20]
print(len(my_list))  # Output: 4

length() and size() are not valid Python functions for lists.
count() counts how many times a specific element appears in the list, not the total number of elements.

Tip: Use len() whenever you need the size of a list. It’s fast, simple, and built-in.

Which of the following statements about iterating through Python lists is correct?

You can only iterate using a while loop.

You cannot use the enumerate() function with lists.

Lists are not iterable, so you cannot use a for loop.

You can use both for and while loops to iterate through a list.

Python lists are iterable objects, meaning you can loop through their elements in multiple ways.

For loops: The most common way to iterate through a list.
While loops: Can also be used by manually managing an index.
Enumerate: Provides both the index and value while iterating.

Examples:

# Using for loop
my_list = [10, 20, 30]
for item in my_list:
    print(item)

# Using while loop
i = 0
while i < len(my_list):
    print(my_list[i])
    i += 1

# Using enumerate
for index, value in enumerate(my_list):
    print(index, value)

Key Takeaways:

Lists are iterable, so for loops are simple and readable.
While loops give you more control over indices.
Use enumerate() when you need the index alongside the value.

What will be the output of the following code?

[10, 15, 20]

[5, 10, 15, 20]

[5, 15, 20]

[5, 15, 20, 10]

The remove() method removes the first occurrence of the specified element from the list.

Original list: [5, 10, 15, 20]
my_list.remove(10) removes the value 10 from the list.
The resulting list is [5, 15, 20].

Key Points:

remove() only removes the first matching element.
If the element is not found, Python raises a ValueError.
To remove by index, use pop(index) instead.

Which of the following expressions checks if the value `50` exists in the list `my_list`?

50 in my_list

my_list.has(50)

my_list.contains(50)

my_list[50]

In Python, the in operator is used to check whether an element exists in a list.

It returns True if the element is present, False otherwise.
Example:

my_list = [10, 20, 30, 50]
print(50 in my_list)  # Output: True
print(100 in my_list) # Output: False

Methods like has() or contains() do not exist for Python lists.
Accessing my_list[50] will try to access the element at index 50, which may raise an IndexError.

Tip: Use the in operator for simple and readable membership checks.

Which of the following operations combines two lists `list1` and `list2` into a single list?

list1.append(list2)

list1 + list2

list1.remove(list2)

list1.pop(list2)

There are multiple ways to combine lists in Python, but using the + operator concatenates them into a new list.

list1 + list2 returns a new list containing all elements from both lists.
Example:

list1 = [1, 2, 3]
list2 = [4, 5]
combined = list1 + list2
print(combined)  # Output: [1, 2, 3, 4, 5]

append() adds the entire list as a single element, e.g., [1, 2, 3, [4, 5]].
remove() deletes a specific element.
pop() removes an element by index.

Tip: Use + for combining lists into a new list, or extend() to add elements in place.

What will be the content of `my_list` after executing the following code?

my_list = [10, 20, 30, 40]
del my_list[1]

[20, 30, 40]

[10, 20, 30, 40]

[10, 20, 40]

[10, 30, 40]

The del statement in Python is used to delete an element at a specific index from a list.

Original list: [10, 20, 30, 40]
del my_list[1] removes the element at index 1 (value 20).
Resulting list: [10, 30, 40]

Key Points:

pop(index) also removes an element but returns it.
del list[index] removes the element without returning it.
Using del with slicing can remove multiple elements at once, e.g., del my_list[1:3].

Which of the following statements about nested lists in Python is correct?

Nested lists cannot contain other lists.

All elements of a nested list must be of the same data type.

You can access elements in nested lists using multiple indices.

Nested lists are immutable like tuples.

Nested lists are lists that contain other lists as elements. They allow creating multi-dimensional data structures, like matrices.

You can access elements in a nested list using multiple indices. The first index selects the sublist, and the second index selects the element within that sublist.
Example conceptual understanding:
- Consider a nested list representing a 2x2 matrix: [[1, 2], [3, 4]]
- Access element 4: first select the second sublist, then the second element → matrix[1][1]

Key Points:

Nested lists can contain lists of any length and any data type.
They are mutable, so elements within can be modified.
Multiple indexing allows precise access to deeply nested elements.

What will be the output of the following code?

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
matrix[1][0] = matrix[2][2]
matrix[2] = [0, 0, 0]
print(matrix[1][0], matrix[2][2])

6 9

4 9

9 0

9 9

This question tests your understanding of **nested list references** and assignment in Python.

[[1, 2, 3],
 [4, 5, 6],
 [7, 8, 9]]

matrix = [[1, 2, 3],
 [9, 5, 6],
 [0, 0, 0]]

Original matrix:
matrix[1][0] = matrix[2][2] sets the element at row 1, column 0 to the value of matrix[2][2], which is 9.
matrix[2] = [0, 0, 0] replaces the entire third row with zeros.
Now:
So matrix[1][0] is 9 and matrix[2][2] is 0.

Key Takeaways:

Assignment to individual elements copies the value, not the reference.
Assigning a new list to matrix[2] replaces the entire sublist.
Nested list operations require careful tracking of indices and assignments.

Which of the following methods sorts the list `numbers` in descending order?

numbers.sort()

sorted(numbers)

numbers.reverse()

numbers.sort(reverse=True)

Sorting lists in Python can be done using either the sort() method or the sorted() function.

numbers.sort() sorts the list in place in ascending order by default.
sorted(numbers) returns a new sorted list in ascending order without modifying the original.
numbers.reverse() simply reverses the current order of elements without sorting.
numbers.sort(reverse=True) sorts the list in place in descending order.

Example:

numbers = [5, 2, 9, 1]
numbers.sort(reverse=True)
print(numbers)  # Output: [9, 5, 2, 1]

Tips:

Use sort(reverse=True) for descending sort in place.
Use sorted() if you need a new sorted list and want to keep the original unchanged.
Remember, reverse() does not sort; it just reverses the current order.

Which of the following code snippets creates a new list containing the sum of elements from `list1` and `list2` at the same indices?

result = []
for i in range(len(list1)):
    result.append(list1[i] * list2[i])

result = [list1[i] - list2[i] for i in range(len(list1))]

result = [list1[i] + list2[i] for i in range(len(list1))]

result = list1 + list2

This question tests **index-based operations on multiple lists** and understanding list comprehensions.

We want to sum elements at the same indices from two lists.
Option 3 correctly uses a list comprehension with index iteration: [list1[i] + list2[i] for i in range(len(list1))]
Option 1 multiplies elements instead of adding.
Option 2 subtracts elements.
Option 4 concatenates the lists rather than summing element-wise.

Example:

list1 = [1, 2, 3]
list2 = [4, 5, 6]
result = [list1[i] + list2[i] for i in range(len(list1))]
print(result)  # Output: [5, 7, 9]

Key Takeaways:

Use list comprehensions for concise element-wise operations.
Ensure both lists have the same length when using index-based operations.
Remember: + on lists concatenates, it doesn’t sum elements element-wise.

Which of the following code snippets correctly calculates the sum of all elements in the list `numbers`?

total = sum(numbers)

total = numbers.add()

total = 0
for n in numbers:
    total *= n

total = reduce(lambda x, y: x - y, numbers)

To calculate the sum of all elements in a Python list, the built-in sum() function is the simplest and most efficient method.

Option 1: Correct – total = sum(numbers) sums all elements in the list.
Option 2 – add() does not exist for lists.
Option 3 – multiplies elements instead of adding.
Option 4 – uses reduce with subtraction, which is incorrect for summing.

Example:

numbers = [1, 2, 3, 4]
total = sum(numbers)
print(total)  # Output: 10

Tips:

Use sum() for simple and readable code.
For advanced aggregations, reduce() can be used, but ensure the operation is correct.

Which of the following statements about list references and mutability in Python is correct?

Assigning one list to another creates a completely independent copy.

Modifying a list never affects another list, even if assigned previously.

If two variables reference the same list, modifying it through one variable affects the other.

This question tests your understanding of **how Python handles list references and mutability**.

Lists are **mutable**, meaning their elements can be changed.
When you assign one list to another, e.g., list2 = list1, both variables reference the **same list object** in memory.
Therefore, modifying the list through one variable will affect the other.

Example:

list1 = [1, 2, 3]
list2 = list1
list2.append(4)
print(list1)  # Output: [1, 2, 3, 4]
print(list2)  # Output: [1, 2, 3, 4]

Key Takeaways:

Option 3 – Correct: Both variables point to the same list, so changes are reflected in both.
Use list.copy() or copy.deepcopy() to create independent copies.
Remember: Python variables hold references to objects, not the objects themselves.

What will be the output of the following code?

a = [1, 2, 3]
b = a
b[0] = 100
print(a)

[1, 2, 3]

[100, 2, 3]

[0, 2, 3]

Error

This question tests your understanding of **list references and mutability** in Python.

Variable a references a list [1, 2, 3].
When we assign b = a, both a and b reference the **same list object**.
Modifying b[0] = 100 changes the first element of the shared list.
Therefore, printing a also shows the updated list.

Key Takeaways:

Option 2 – Correct: The first element is updated to 100 in both a and b.
To avoid modifying the original list, use b = a.copy() to create a shallow copy.
Remember: Python variables store references, not independent copies.

Which of the following code snippets correctly flattens a nested list `nested_list = [1, [2, [3, 4], 5], 6]` into a single-level list?

flat = []
for i in nested_list:
    flat.append(i)

flat = []
for i in nested_list:
    if type(i) == list:
        flat.append(i)
    else:
        flat.append(i)

def flatten(lst):
    result = []
    for i in lst:
        if isinstance(i, list):
            result.extend(flatten(i))
        else:
            result.append(i)
    return result

flat_list = flatten(nested_list)

flat_list = [nested_list[i] for i in range(len(nested_list))]

This question tests **recursion and nested list handling** in Python.

Option 3 – Correct: Uses a recursive function to flatten nested lists of any depth.
It checks if an element is a list. If yes, it recursively flattens it using extend(); otherwise, it appends the element.
Other options fail:
- Option 1 just appends sublists as-is.
- Option 2 still keeps nested lists inside.
- Option 4 only iterates over the top-level elements without flattening.

Example output:

nested_list = [1, [2, [3, 4], 5], 6]
flat_list = flatten(nested_list)
print(flat_list)  # Output: [1, 2, 3, 4, 5, 6]

Key Takeaways:

Recursion is powerful for handling nested structures.
Use isinstance() to check types safely.
extend() is crucial to merge lists instead of nesting them.

Which of the following code snippets correctly creates a list of all even numbers from a nested list `nested_list = [[1, 2], [3, 4, 5], [6]]`?

evens = [i for i in nested_list]

evens = [num for sublist in nested_list for num in sublist if num % 2 == 0]

evens = []
for sublist in nested_list:
    evens.append(sublist)

evens = list(filter(lambda x: x % 2 == 0, nested_list))

This question tests understanding of **nested iteration and filtering** in Python lists.

Option 2 – Correct: Uses a nested list comprehension to iterate through each sublist and pick only even numbers.
Other options fail:
- Option 1 just copies sublists without flattening or filtering.
- Option 3 appends the entire sublist as elements, not individual numbers.
- Option 4 fails because filter() operates on the top-level list and cannot directly access elements in nested lists.

Example output:

nested_list = [[1, 2], [3, 4, 5], [6]]
evens = [num for sublist in nested_list for num in sublist if num % 2 == 0]
print(evens)  # Output: [2, 4, 6]

Key Takeaways:

Nested list comprehensions are concise and powerful for flattening and filtering.
Pay attention to the order of for loops inside the comprehension.
Use the if condition at the end to filter elements.

Which of the following code snippets correctly modifies only the inner list of a nested list without affecting the outer list references?

outer = [[1, 2], [3, 4]]
inner = outer[0]
inner[0] = 100

outer = [[1, 2], [3, 4]]
inner = outer
inner[0][0] = 100

outer = [[1, 2], [3, 4]]
inner = outer.copy()
inner[0][0] = 100

import copy
outer = [[1, 2], [3, 4]]
inner = copy.deepcopy(outer)
inner[0][0] = 100

This is a highly tricky question testing **deep vs shallow copies** and **nested list mutability**.

Option 4 – Correct: Using copy.deepcopy() creates a completely independent copy of the nested list. Modifying inner does not affect outer.
Other options fail:
- Option 1 – inner = outer[0] references the inner list directly, so changes reflect in outer.
- Option 2 – inner = outer references the whole outer list; any change affects outer.
- Option 3 – inner = outer.copy() creates a shallow copy; inner lists are still referenced, so modifying them affects outer.

Example output:

import copy
outer = [[1, 2], [3, 4]]
inner = copy.deepcopy(outer)
inner[0][0] = 100
print(outer)  # Output: [[1, 2], [3, 4]]
print(inner)  # Output: [[100, 2], [3, 4]]

Key Takeaways:

Shallow copies (copy()) do not copy nested objects.
Deep copies (copy.deepcopy()) create full independent copies of nested structures.
Always be cautious with nested lists when modifying copies to avoid unintended side effects.

Which of the following statements about Python lists is correct?

What will be the content of my_list after executing the following code?

Which of the following methods can be used to insert an element at a specific position in a Python list?

What will be the result of the following slicing operation?

Which of the following methods can be used to find the number of elements in a Python list?

Which of the following statements about iterating through Python lists is correct?

What will be the output of the following code?

Which of the following expressions checks if the value 50 exists in the list my_list?

Which of the following operations combines two lists list1 and list2 into a single list?

What will be the content of my_list after executing the following code?

Which of the following statements about nested lists in Python is correct?

What will be the output of the following code?

Which of the following methods sorts the list numbers in descending order?

Which of the following code snippets creates a new list containing the sum of elements from list1 and list2 at the same indices?

Which of the following code snippets correctly calculates the sum of all elements in the list numbers?

Which of the following statements about list references and mutability in Python is correct?

What will be the output of the following code?

Which of the following code snippets correctly flattens a nested list nested_list = [1, [2, [3, 4], 5], 6] into a single-level list?

Which of the following code snippets correctly creates a list of all even numbers from a nested list nested_list = [[1, 2], [3, 4, 5], [6]]?

Which of the following code snippets correctly modifies only the inner list of a nested list without affecting the outer list references?

About This Exercise: Python – Lists

What will be the content of `my_list` after executing the following code?

Which of the following expressions checks if the value `50` exists in the list `my_list`?

Which of the following operations combines two lists `list1` and `list2` into a single list?

What will be the content of `my_list` after executing the following code?

Which of the following methods sorts the list `numbers` in descending order?

Which of the following code snippets creates a new list containing the sum of elements from `list1` and `list2` at the same indices?

Which of the following code snippets correctly calculates the sum of all elements in the list `numbers`?

Which of the following code snippets correctly flattens a nested list `nested_list = [1, [2, [3, 4], 5], 6]` into a single-level list?

Which of the following code snippets correctly creates a list of all even numbers from a nested list `nested_list = [[1, 2], [3, 4, 5], [6]]`?