List Methods and Modifications

One List, Two Names

Suppose a list is stored under the name a, and then you write b = a. It is tempting to think that b receives its own separate list. In Python, that assignment creates an alias instead: a and b refer to the same list object. This matters because lists are mutable. A modification made through b can therefore be seen through a as well.

a = ["red", "blue"]
b = a

print(a)
print(b)

["red", "blue"]
["red", "blue"]

Testing Object Identity

Use the is operator when you want to know whether two variables refer to the exact same object. The expression a is b returns True when both names refer to one object and False when they refer to different objects. This is different from ==. The equality operator compares values, so two separate lists can contain equal values without being the same object.

a = [1, 2, 3] b = a c = [1, 2, 3] print(a is b) print(a == c) print(a is c)

Tracing a Shared Modification

a = ["start"]
b = a
b.append("added")

print(a)
print(b)
print(a is b)

["start", "added"]
["start", "added"]
True

The important point is not which variable was used to make the modification. There is only one list object in this example. Since both names refer to it, both names show the changed contents afterward. This is why aliasing can make a list appear to change unexpectedly.

Making an Independent Copy

If two variables must hold separate lists, create a copy explicitly. The source identifies two ways to do this: b = a[:] and b = list(a). These operations create an independent list. Afterward, modifying one list does not affect the other.

a = ["first"]
b = a[:]
b.append("second")

print(a)
print(b)
print(a is b)

["first"]
["first", "second"]
False

Finding the Source of an Unexpected Change

When a list changes unexpectedly, first identify every variable that may refer to it. Then use is to test suspected pairs. If a is b is True, a modification through either name affects the same list. If you need the variables to change independently, replace the aliasing assignment with a copy such as a[:] or list(a).

items = ["notebook"] backup = items backup.append("pen") print(items) print(items is backup)

Common Aliasing Mistakes

• Assuming b = a creates an independent list

  The assignment gives both names a reference to the same list object.

  Fix: Use b = a[:] or b = list(a) when b must refer to an independent copy.

• Using == when the question is whether two variables are aliases

  The == operator tests equality of values, not whether the objects are identical.

  Fix: Use a is b to test whether both variables refer to the same object.

• Looking only at the variable used for the modification

  If backup and items are aliases, the modification changes the one shared list and is visible through items.

  Fix: Check suspected aliases with is and copy the list when independent changes are required.

Practice the Trace

["A", "B"]
["A"]
False

Key Takeaways

1. b = a creates an alias: both names refer to the same list object.
2. Use is to test object identity and == to test equality of values.
3. Because lists are mutable, a modification through one alias is visible through every other alias.
4. Use a[:] or list(a) to create an independent list copy.
5. When a list changes unexpectedly, trace assignments and use is to locate unintended aliasing.