List mutability in Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean that lists in Python are mutable?

It means you can change, add, or remove items in a list after it is created without making a new list.

beginner

Which of these operations changes a list in place?

my_list = [1, 2, 3]

Operations like my_list.append(4) or my_list[0] = 10 change the list without creating a new one.

intermediate

What happens if you assign a new list to a variable that held a list before?

The variable now points to a new list. The old list stays unchanged unless other variables also point to it.

beginner

True or False: Strings in Python are mutable like lists.

False. Strings are immutable, meaning you cannot change them after creation, unlike lists.

intermediate

How does list mutability affect function arguments when you pass a list?

If you change the list inside the function, the change affects the original list outside the function because both refer to the same list.

Which method changes a list by adding an item at the end?

A replace()

B append()

C insert_at_end()

D add()

The append() method adds an item to the end of a list. The others are not valid list methods.

What will this code print?

lst = [1, 2, 3]
lst[1] = 5
print(lst)

A [1, 2, 3]

B Error

C [5, 2, 3]

D [1, 5, 3]

Changing lst[1] to 5 updates the second item. Lists are mutable, so the change is allowed.

If you do new_list = old_list and then change new_list, what happens to old_list?

A old_list changes too

B old_list stays the same

C old_list is deleted

D Error

Both variables point to the same list, so changes via new_list affect old_list.

Which of these types is immutable in Python?

A list

B dictionary

C string

D set

Strings cannot be changed after creation, unlike lists, dictionaries, and sets.

What does mutability allow you to do with a list?

A Change its contents without making a new list

B Prevent any changes to the list

C Make the list read-only

D Convert the list to a string automatically

Mutability means you can change the list's contents directly.

Explain what list mutability means and give an example of changing a list item.

Think about how you can change a list after you create it.

Describe how passing a list to a function can lead to changes outside the function.

Consider what happens if you add or remove items inside the function.

Practice

1. Which of the following statements about Python lists is true?

easy

A. Lists cannot be changed once created.

B. Lists can be changed after they are created.

C. Lists are immutable like strings.

D. Lists can only store numbers.

Solution

1. Step 1: Understand list mutability

   Python lists are mutable, meaning you can change their contents after creation.

2. Step 2: Compare options

   Lists can be changed after they are created. ("Lists can be changed after they are created.") correctly states that lists are mutable. Options A and C incorrectly claim lists cannot be changed or are immutable like strings. Lists can only store numbers. is wrong because lists can store any data type.

3. Final Answer:

   Lists can be changed after they are created. -> Option B

4. Quick Check:

   List mutability = True [OK]

Hint: Remember: lists are like clay, easy to reshape [OK]

Common Mistakes:

• Confusing lists with strings (immutable)
• Thinking lists only hold numbers
• Believing lists cannot be changed

2. Which of the following is the correct way to change the first item of a list my_list to 10?

easy

A. my_list[0] = 10

B. my_list(0) = 10

C. my_list{0} = 10

D. my_list.set(0, 10)

Solution

1. Step 1: Recall list item assignment syntax

   In Python, list items are accessed and assigned using square brackets and index, like my_list[0].

2. Step 2: Check each option

   my_list[0] = 10 uses correct syntax. Options B and C use wrong brackets. my_list.set(0, 10) uses a method that does not exist for lists.

3. Final Answer:

   my_list[0] = 10 -> Option A

4. Quick Check:

   Use square brackets for list item assignment [OK]

Hint: Use square brackets [] to access or change list items [OK]

Common Mistakes:

• Using parentheses instead of brackets
• Trying to use curly braces for indexing
• Assuming lists have a set() method

3. What will be the output of this code?

numbers = [1, 2, 3]
numbers[1] = 5
print(numbers)

medium

A. [1, 5, 3]

B. [1, 2, 3]

C. [5, 2, 3]

D. Error

Solution

1. Step 1: Understand list item update

   The code changes the item at index 1 (second item) from 2 to 5.

2. Step 2: Check the final list

   After update, the list becomes [1, 5, 3]. The print statement outputs this list.

3. Final Answer:

   [1, 5, 3] -> Option A

4. Quick Check:

   Updated list = [1, 5, 3] [OK]

Hint: Index 1 means second item in list [OK]

Common Mistakes:

• Thinking index 1 is first item
• Expecting original list unchanged
• Assuming code causes error

4. Find the error in this code that tries to change a list item:

my_list = [10, 20, 30]
my_list(1) = 15
print(my_list)

medium

A. Missing colon after assignment

B. List cannot be changed after creation

C. Using parentheses instead of square brackets for indexing

D. print statement syntax error

Solution

1. Step 1: Identify indexing syntax error

   The code uses parentheses () instead of square brackets [] to access list item.

2. Step 2: Confirm correct syntax

   List items must be accessed with square brackets, so my_list[1] = 15 is correct.

3. Final Answer:

   Using parentheses instead of square brackets for indexing -> Option C

4. Quick Check:

   Use [] not () for list indexing [OK]

Hint: Remember: () calls functions, [] accesses list items [OK]

Common Mistakes:

• Using () instead of [] for list indexing
• Thinking lists are immutable
• Looking for syntax errors elsewhere

5. Given the list data = [5, 10, 15, 20], which code snippet correctly doubles each item in the list using mutability?

hard

A. data = [item * 2 for item in data]
print(data)

B. for item in data:
item = item * 2
print(data)

C. data.map(lambda x: x*2)
print(data)

D. for i in range(len(data)):
data[i] = data[i] * 2
print(data)

Solution

1. Step 1: Understand mutability and iteration

   To change items in place, we must assign new values to each index in the list.

2. Step 2: Analyze each option

   for i in range(len(data)): data[i] = data[i] * 2 print(data) updates each item by index, correctly doubling values in place.
   for item in data: item = item * 2 print(data) changes only the loop variable, not the list.
   data = [item * 2 for item in data] print(data) creates a new list and assigns it to data (not in-place mutation).
   data.map(lambda x: x*2) print(data) uses map which returns an iterator and does not modify list in place.

3. Final Answer:

   for i in range(len(data)): data[i] = data[i] * 2 print(data) -> Option D

4. Quick Check:

   In-place update requires index assignment [OK]

Hint: Use index to update list items for true mutability [OK]

Common Mistakes:

• Modifying loop variable instead of list items
• Using map without converting result
• Replacing list instead of mutating it