Names, Objects and Memory

Variables are names, not boxes

In many languages a variable is a box that holds a value. In Python it is closer to a label attached to an object. The object lives in memory, and a name is just a way of finding it. Assignment does not copy anything. It attaches a name.

a = [1, 2, 3]
b = a                     # no copy: b is a second name for the same list
b.append(4)

print(a)                  # the change shows up under both names
print(a is b)             # True: one object with two names

c = [1, 2, 3, 4]
print(a == c)             # True: the values are equal
print(a is c)             # False: but they are two different objects

Two operators answer two different questions:

Use == to compare values. Use is only to check for None (if x is None:), because there is only ever one None.

Rebinding is not mutating

These two lines look the same and behave differently. Adding with + builds a new list and rebinds a to it. The shorthand += on a list changes the existing list, so every name for it sees the change.

a = [1, 2]
b = a
a = a + [3]               # a new list is made, and the name a is moved to it
print(a, b)

a = [1, 2]
b = a
a += [3]                  # the same list is extended in place
print(a, b)

Some objects can never change

An immutable object cannot be altered after it is made. Numbers, strings and tuples are immutable, so something that looks like a change always makes a new object and rebinds the name:

s = "cat"
t = s
s += "s"                  # builds a new string "cats"; the old one is untouched
print(s, t)

That is why t is still cat. With a list, both names would have seen the change.

Mutable or immutable, and why it matters

Dictionary keys must be immutable

A dictionary finds a key from its hash, a number worked out from its value. If a key could change, its hash would change and the dictionary could never find it again. So only hashable (in practice, immutable) objects may be keys:

# raises: TypeError
scores = {[1, 2]: "a list cannot be a key"}

A tuple is a perfectly good key, which is handy for coordinates: grid[(3, 4)].

Immutable containers can hold mutable things

A tuple stops its own contents being swapped, but if one item is a list, that list can still be changed:

t = ([1], 2)
t[0].append(9)            # allowed: the list inside is mutable
print(t)

try:
    t[0] = [5]            # not allowed: this tries to replace what the tuple holds
except TypeError as problem:
    print(problem)

The mutable default argument trap

Python makes a default value once, when the function is defined, not each time it is called. If the default is a list, every call that uses it shares that one list:

def add_item(item, basket=[]):
    basket.append(item)
    return basket

print(add_item("apple"))
print(add_item("bread"))         # the apple is still there!

The standard fix is None as a signal, with a new list made inside the function each time:

def add_item(item, basket=None):
    if basket is None:
        basket = []
    basket.append(item)
    return basket

print(add_item("apple"))
print(add_item("bread"))

By value or by reference?

Exams ask how a parameter is passed. By value means the subprogram gets a copy, so changing the parameter never affects the caller. By reference means it gets a link to the caller's variable itself, so changes do. Python does neither exactly. It passes a reference to the object, sometimes called call by object reference, so what happens depends on whether the object is mutable and on what the function does with it:

def change(numbers, count):
    numbers.append(99)        # mutates the object the caller also has
    count = count + 1         # rebinds a local name; the caller's name is unaffected

data = [1]
total = 5
change(data, total)
print(data, total)

The list was altered, because the function changed the one shared object. The number was not, because count + 1 made a new integer and attached the local name to it.

Copying: aliases, shallow and deep

Because assignment only attaches a name, getting a real copy needs a deliberate step. There are three levels:

For a list of numbers or strings, a shallow copy is enough, because those items are immutable. The difference only shows when the items are themselves mutable, such as a grid made of lists:

import copy

grid = [[0, 0], [0, 0]]
alias = grid
shallow = grid[:]
deep = copy.deepcopy(grid)

grid[0][0] = 9

print("grid   ", grid)
print("alias  ", alias)
print("shallow", shallow)           # the outer list is new, but the rows are shared
print("deep   ", deep)

The shallow copy has its own outer list, but both outer lists hold the same two row objects, so changing a row through one is visible through the other. Only the deep copy is fully independent.

The grid bug

This is one of the most common bugs in student programs. Multiplying a list repeats the reference, not the contents:

bad = [[0] * 3] * 3             # three names for the SAME row
bad[0][0] = 1
print(bad)

good = [[0] * 3 for _ in range(3)]    # a new row is built each time round
good[0][0] = 1
print(good)

[0] * 3 is safe because the zeros are immutable. But [[0] * 3] * 3 repeats one row, so all three rows are the same object. A comprehension builds a fresh row each time.

Copying your own objects

An object made from your own class is also shared by default. copy.copy makes a shallow copy of it, and copy.deepcopy a full one. For a class built with @dataclass, dataclasses.replace makes a modified copy in one line.

import copy

class Player:
    def __init__(self, name, items):
        self.name = name
        self.items = items

hero = Player("Ana", ["sword"])
twin = copy.copy(hero)              # a new Player, but the SAME items list
clone = copy.deepcopy(hero)         # a new Player with its own items list

hero.items.append("shield")
print(twin.items)
print(clone.items)

How Python manages memory

Python never asks you to free memory. It keeps track of every object by counting how many references it has. This is reference counting:

• binding a name, putting it in a list, or passing it to a function adds a reference
• deleting a name, leaving a function, or removing it from a list removes one
• when the count reaches zero, nothing can reach the object any more, so Python frees it at once

import sys

items = [1, 2, 3]
before = sys.getrefcount(items)

second = items                           # one more reference
third = items                            # and another
print("added:", sys.getrefcount(items) - before)

del second                               # removes the name, not the list
print("added:", sys.getrefcount(items) - before)

(getrefcount itself holds a temporary reference while it runs, which is why programs compare two counts rather than reading one.)

del removes a name. The object is only freed if that was its last reference. You can watch an object disappear using a weak reference, which does not keep it alive:

import weakref

class Node:
    def __init__(self, name):
        self.name = name

node = Node("a")
watcher = weakref.ref(node)
print("alive:", watcher() is node)

del node                                  # the last reference goes, and so does the object
print("after del:", watcher())

Reference cycles and the garbage collector

Reference counting has one weakness. If two objects refer to each other, each keeps the other's count above zero, even when nothing else in the program can reach either of them. Python adds a garbage collector that periodically looks for such cycles and frees them.

import gc
import weakref

class Node:
    def __init__(self, name):
        self.name = name
        self.other = None

gc.disable()                              # so that nothing happens until we choose

first, second = Node("p"), Node("q")
first.other, second.other = second, first         # a cycle
watcher = weakref.ref(first)

del first, second
print("after del:", watcher() is not None, "(the cycle keeps itself alive)")

gc.collect()                              # run the cycle detector now
print("after gc.collect():", watcher() is not None)
gc.enable()

Garbage collection is automatic memory management: the language finds the memory that is no longer needed and reclaims it, so there are no dangling pointers and no forgotten free calls. The costs are some time spent counting and collecting, and less control over when memory is released.

Memory leaks still happen

If something still holds a reference, the object is never freed, even if you have forgotten about it. A global list or cache that only ever grows is the usual cause.

Saving memory with __slots__

An ordinary object keeps its attributes in a hidden dictionary, which is flexible but takes space. Declaring __slots__ gives a class a fixed set of attributes instead, and no dictionary:

import tracemalloc

class Plain:
    def __init__(self, a, b):
        self.a = a
        self.b = b

class Slim:
    __slots__ = ("a", "b")
    def __init__(self, a, b):
        self.a = a
        self.b = b

def memory_used(cls):
    tracemalloc.start()
    objects = [cls(i, i) for i in range(5000)]
    current, peak = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    return current

print("slots use less memory:", memory_used(Slim) < memory_used(Plain))

slim = Slim(1, 2)
try:
    slim.c = 3                           # not in __slots__
except AttributeError as problem:
    print(type(problem).__name__)

The saving matters when a program makes hundreds of thousands of small objects. The price is that you cannot add attributes that were not declared.

Hunting an aliasing bug

Almost every aliasing bug looks the same: a change in one place shows up somewhere you did not touch. Here is a noughts and crosses board that does it. Read it, predict the output, then run it.

class Board:
    def __init__(self):
        self.cells = [["."] * 3] * 3

    def place(self, row, col, mark):
        self.cells[row][col] = mark

    def show(self):
        for row in self.cells:
            print(" ".join(row))

board = Board()
board.place(0, 0, "X")
board.show()

One X was placed, but three appear. The method did nothing wrong: the fault is in __init__, where [["."] * 3] * 3 makes three names for one row.

A method for finding these bugs

1. Reproduce it with the smallest program you can. Here, three lines.
2. Ask whether two names are the same object, using is, or compare the identity of two rows:

board_cells = [["."] * 3] * 3
print(board_cells[0] is board_cells[1])
print(board_cells[0] is board_cells[2])

1. Fix the construction so that every row is its own object, and prove it with a test:

class Board:
    def __init__(self):
        self.cells = [["."] * 3 for _ in range(3)]

    def place(self, row, col, mark):
        self.cells[row][col] = mark

    def show(self):
        for row in self.cells:
            print(" ".join(row))

board = Board()
board.place(0, 0, "X")
board.show()
print("rows are separate objects:", board.cells[0] is not board.cells[1])

A checklist for the next time

Key terms you must be able to define

Reference

A link from a name (or another object) to an object in memory. A Python variable holds a reference, not the object.

Identity

Whether two names refer to the very same object, tested with is.

Mutable

An object that can be changed in place after it is created, such as a list or dictionary.

Immutable

An object that cannot be changed after it is created, such as a number, string or tuple.

Alias

A second name for an object that already has one.

Shallow copy

A copy of a container that creates a new outer object but shares the items inside it.

Deep copy

A copy that duplicates the container and everything inside it, to any depth.

Call by object reference

How Python passes arguments: the parameter is bound to the same object the caller passed.

Reference counting

Keeping a count of how many references an object has, and freeing it when the count reaches zero.

Garbage collection

Automatic recovery of memory that a program can no longer reach, including objects in reference cycles.

Heap

The area of memory where objects are created.

Flashcards

Say the definition out loud before you flip the card. Retrieving it from memory is what builds recall, reading it again is not.

Reach the top grade on this topic

This topic produces unexpected-output questions. The marks are for explaining the cause in terms of objects and names.

• Use the words object, name and reference, rather than saying a variable 'contains' a list
• Say whether an operation mutates an existing object or rebinds a name to a new one
• For parameter passing, say what is passed (a reference to an object) and give the mutate or rebind consequence
• For copies, name the level: alias, shallow or deep, and say which parts are shared
• For memory, name the mechanism: reference counting, and a cycle detector for the cases it cannot handle

Mistakes that cost marks here

a = [1, 2, 3]
b = a
c = a[:]
b.append(4)
c.append(5)
print(a)
print(c)

def add(item, basket=[]):
    basket.append(item)
    return basket

def add(item, basket=None):
    if basket is None:
        basket = []
    basket.append(item)
    return basket

print(add("apple"))
print(add("bread"))