Variables, objects and names in Python

A variable in Python is a name that refers to an object. The statement price = 120 does two things: Python gets an integer object with the value 120 (creating one if it needs to), and it binds the name price to that object. The name holds no number of its own; whenever you use price, Python follows the binding to the object. Keep that picture in mind and most of the surprises in this lesson stop being surprises.

Names refer to objects

Everything a program works with (a number, a piece of text, a list, even a function) is an object, and every object has three properties:

• a type, which decides what you can do with it: type(x) returns it;
• a value, which == compares;
• an identity, which never changes while the object exists: x is y is True when both names refer to the very same object, and id(x) returns the identity as a number.

Assignment never copies an object. Giving a list a second name gives you one list with two names:

scores = [72, 85]
marks = scores  # a second name for the same list, not a copy

marks.append(90)  # change the list through one name ...
print(scores)  # ... and the other name sees the change
print(marks is scores)  # True: one object, two names
print(id(marks) == id(scores))  # the same identity

marks = [50]  # rebinding: marks now names a brand-new list
print(scores)  # the first list is untouched
print(marks)
print(marks is scores)

[72, 85, 90]
True
True
[72, 85, 90]
[50]
False

marks.append(90) changes the list itself, so the change is visible through both names. marks = [50] is a different kind of step: it builds a new list and moves the name marks to it, and scores keeps the list it had. The program compares identities (id(marks) == id(scores)) instead of printing them, because the numbers themselves change from one run to the next.

Two words are worth keeping apart. To mutate an object is to change it in place, as append does to a list. To rebind a name is to point it at another object, which is what = does. Numbers and strings can never be mutated, so for them only rebinding exists. Lists, dictionaries and sets can be mutated, and that is when two names for one object start to matter.

Types belong to objects, not names

A name has no type of its own. The same name may refer to an integer now and to a string later; that is what dynamic typing means. The objects do have types, and every operation checks them when it runs:

reply = 42
print(type(reply))

reply = "forty-two"  # the same name, now bound to a str
print(type(reply))

print(type(3.5), type(True), type(None))

label = "Items: "
count = 3
print(label + str(count))  # convert on purpose, then join
print(label + count)  # Python will not convert for you

<class 'int'>
<class 'str'>
<class 'float'> <class 'bool'> <class 'NoneType'>
Items: 3

Traceback (most recent call last):
  File "name_and_type.py", line 12, in <module>
    print(label + count)  # Python will not convert for you
          ~~~~~~^~~~~~~
TypeError: can only concatenate str (not "int") to str

The last line stops with a TypeError. Joining text with + needs two strings, and + never quietly turns the number 3 into text for you. This is what people mean when they call Python strongly typed: you convert on purpose, as str(count) does on the line before. "3" + 4 fails in the same way.

Ways to assign

width, height = 1920, 1080  # one name for each value
print(width, height)

left, right = "tea", "coffee"
left, right = right, left  # swap: the right-hand side is built first
print(left, right)

first, *rest = [5, 8, 13, 21]  # the starred name collects the rest
print(first, rest)

retries = errors = 0  # two names for one int: fine, ints never change
retries = retries + 1  # rebinds retries only
print(retries, errors)

1920 1080
coffee tea
5 [8, 13, 21]
1 0

• width, height = 1920, 1080 assigns two names in one statement. The right-hand side is a tuple of two values, and the names on the left receive them in order; this is called unpacking. The counts must match: a, b = 1, 2, 3 stops with ValueError: too many values to unpack (expected 2, got 3).
• left, right = right, left swaps two values with no temporary variable. Python evaluates the whole right-hand side first, a tuple holding the two old objects, and only then binds the names on the left.
• In first, *rest = [5, 8, 13, 21], the starred name collects, as a list, whatever the other names do not take.
• retries = errors = 0 binds both names to one object. With a number that is harmless: retries = retries + 1 creates a new integer and rebinds retries alone, so errors is still 0.

A common mistake: one list with two names

The chained form that was harmless with a number is a trap with a list:

to_buy = bought = []  # looks like two empty lists, but it is one
to_buy.append("rice")
print("to buy:", to_buy)
print("bought:", bought)  # "rice" shows up here too

to_buy, bought = [], []  # two separate lists
to_buy.append("dal")
print("to buy:", to_buy)
print("bought:", bought)

to buy: ['rice']
bought: ['rice']
to buy: ['dal']
bought: []

to_buy = bought = [] creates a single empty list and gives it two names, so whatever is added to “to buy” also appears as “bought”. When you want two lists, create two: to_buy, bought = [], [], or two separate lines. Each [] always creates a new list.

Choosing names

The rules

A name, or identifier, is made of letters, digits and underscores, and it cannot start with a digit. Case matters: total, Total and TOTAL are three different names. Letters from any script count, so नाम = "Asha" is a valid assignment (Python 3 has accepted such names from its first release, PEP 3131), and there is no length limit.

The keywords are reserved and can never be names. The standard library’s keyword module lists them, together with the soft keywords, which act as keywords in one kind of statement and are ordinary names everywhere else:

import keyword

print(len(keyword.kwlist), "keywords:")
print(" ".join(keyword.kwlist))
print("Soft keywords:", keyword.softkwlist)

for text in ["total", "Total", "_draft", "नाम", "2fast", "first-name", "class", "match"]:
    print(repr(text), "identifier:", text.isidentifier(), "keyword:", keyword.iskeyword(text))

35 keywords:
False None True and as assert async await break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield
Soft keywords: ['_', 'case', 'match', 'type']
'total' identifier: True keyword: False
'Total' identifier: True keyword: False
'_draft' identifier: True keyword: False
'नाम' identifier: True keyword: False
'2fast' identifier: False keyword: False
'first-name' identifier: False keyword: False
'class' identifier: True keyword: True
'match' identifier: True keyword: False

Python 3.14 has 35 keywords. str.isidentifier() checks only the spelling rules, so it accepts class; keyword.iskeyword() is the second check. match passes both, because it is special only at the start of a match statement, so match = 3 is allowed, if confusing. When the name you want is a keyword, PEP 8 suggests adding an underscore at the end: class_.

The style

The rules say what Python accepts; style is about what people can read. PEP 8, Python’s style guide, recommends:

• Variables and functions: lower case, with underscores between words (snake_case), as in total_marks and send_report.
• Constants: capitals, with underscores between words, as in MAX_RETRIES and TAX_RATE.
• Classes: each word capitalised and no underscores (CapWords), as in ShoppingCart.

Python does not enforce constants: MAX_RETRIES = 5 can still be reassigned, and the capitals only ask other readers not to. PEP 8 also says never to use l, O or I as a one-letter name, because in many fonts they look like 1 and 0. Above all, choose names that say what a value means: seconds_left tells the next reader far more than s.

Names that look alike

Because names may use any script, two names can look identical and still be different:

import unicodedata

pay = 100
pаy = 0  # looks the same, but this "а" is not the Latin letter
print(pay)  # still 100: the line above created a second name

print("pay" == "pаy")
print(unicodedata.name("pay"[1]))
print(unicodedata.name("pаy"[1]))

100
False
LATIN SMALL LETTER A
CYRILLIC SMALL LETTER A

The second pаy is spelt with the Cyrillic letter а, which looks exactly like the Latin a, so Python sees a new name, and the line that was meant to reset the pay left it alone. Python does merge some look-alikes: names are converted to the Unicode normal form NFKC as the file is read, so a typographic ligature such as fi becomes the two letters fi. Latin and Cyrillic letters are different letters, though, and stay apart. Such characters get into code copied from documents, chat messages and web pages.

Don’t hide the built-ins

The built-in functions and types, such as list, str, sum, max, id, input and type, are names too, and Python looks them up only after your own names. Assign to one of them, and your object hides the built-in for the rest of the program or shell session:

>>> list = ["pen", "ink"]
>>> list("abc")
Traceback (most recent call last):
  File "<python-input-1>", line 1, in <module>
    list("abc")
    ~~~~^^^^^^^
TypeError: 'list' object is not callable
>>> del list
>>> list("abc")
['a', 'b', 'c']

'list' object is not callable means the name list now refers to a list, and a list cannot be called the way the list type can. Pick another name, such as supplies or items. In the shell, del list removes your binding, and the built-in becomes visible again. type is easy to hide by accident, because “type” is such a common word for a setting, and being a soft keyword does not protect it: type = "admin" is allowed, and every later type(x) then fails.

Key takeaways

• A variable is a name bound to an object. Assignment binds a name; it never copies the object.
• Every object has a type, a value and an identity: type() shows the first, == compares values, and is compares identities.
• Rebinding a name (x = …) and mutating an object (items.append(…)) are different operations, and only a mutation is seen through the object’s other names.
• a, b = b, a swaps two values; a = b = [] gives one list two names.
• Names are case-sensitive and may use letters of any script. Keywords cannot be names, soft keywords can, and PEP 8 asks for snake_case.
• Never use the names of built-ins such as list, str, id or type for your own values.