Python Naming and Multiple Assignment

Rules (break these and you get a SyntaxError):

• Use letters, digits and underscores only; no spaces, hyphens or other symbols.
• Don't start with a digit: 2nd_ferry is invalid, second_ferry is fine.
• Don't use a keyword such as class, for, return, lambda or None. import keyword; print(keyword.kwlist) lists them all.
• Names are case-sensitive: berth, Berth and BERTH are three different names.

Conventions from PEP 8 (break these and the code still runs, but reads oddly to other Python developers):

Prefer descriptive names over short ones: seats_remaining beats sr and x. Avoid reusing built-in names such as list, str, sum or id; Python allows it, but the built-in function becomes unavailable in that scope.

Multiple assignment matches each name on the left with the value in the same position on the right:

route, departure, berth = ("Harbor loop", "09:40", 3)

The right side can be any iterable: a tuple, list, string or the result of a function that returns several values. The number of names must equal the number of values, or Python raises ValueError: too many values to unpack (expected 2) or not enough values to unpack.

A starred name collects the leftovers into a list, so the counts no longer need to match exactly:

first, *middle, last = ["09:40", "10:10", "10:40", "11:10"]
print(first, middle, last)   # 09:40 ['10:10', '10:40'] 11:10

Unpacking also works in for loops, which is why for name, time in departures: reads each pair cleanly, and with the underscore convention for values you don't need: route, _, berth = record.

a, b = b, a swaps two values in one line. It works because Python evaluates the whole right-hand side first, building a temporary tuple (b's value, a's value), and only then assigns to the targets from left to right.

Doing the same thing with two separate assignments loses data:

a, b = 2, 5
a = b        # a is 5, the original 2 is gone
b = a        # b is 5 too
print(a, b)  # 5 5

Languages without tuple assignment need a third temporary variable (temp = a; a = b; b = temp). In Python the one-liner is both shorter and safer. The same right-side-first rule lets you update related variables together, such as the Fibonacci step a, b = b, a + b, without the new a leaking into the calculation of b.

Variables in Python are names that refer to objects; assignment never copies an object. That's invisible for numbers and strings, which can't change, but it matters for lists and dictionaries:

passengers_a = passengers_b = []      # one list, two names
passengers_a.append("Ana")
print(passengers_b)                   # ['Ana']

boat_1, boat_2 = [], []               # two separate lists
boat_1.append("Ben")
print(boat_2)                         # []

Chained assignment a = b = value binds both names to the same object. For an immutable value like 0 or "" that is harmless, because "changing" one name rebinds it to a new object. For a list, every change made through either name is visible through both. a is b confirms whether two names point at the same object. Use separate literals, or .copy(), when you need independent lists.

Task: unpack a departure record, swap berths and demonstrate independent passenger lists.

record = ("Island run", "10:15", 1, 4)
route, time, berth_a, berth_b = record
berth_a, berth_b = berth_b, berth_a
print(route, time, berth_a, berth_b)     # Island run 10:15 4 1

shared = also_shared = []
separate_1, separate_2 = [], []
shared.append("Ana")
separate_1.append("Ben")
print(also_shared, separate_2)           # ['Ana'] []
print(shared is also_shared)             # True

The last line proves that chained assignment produced one object. For the worked check, a = b = [] creates two references to one list, not two lists.

PEP 8's naming conventions and the reference on assignment statements cover the rules in full. Continue with copying and joining collections and tuples and sets. Practise with the Python exercises and Python quiz.