What Are the Rules for Python Identifiers?

An identifier in Python is any name that you give to something. That covers variables, functions, classes, methods, and module names. The rules are short enough to state in full. A name has to start with a letter or an underscore. Every character after that has to be a letter, a digit, or an underscore. The name cannot be a keyword. Python treats upper and lower case as different, so Name and name are two different identifiers. And since Python 3, letters outside the plain ASCII range are allowed, so café is a legal identifier.

You can check all of this in your program instead of guessing.

import keyword

candidates = ['user_name', '2fast', 'class', 'my-name', '_private', 'café']

for name in candidates:
    print(repr(name), 'valid:', name.isidentifier(), 'reserved:', keyword.iskeyword(name))

# This is the message the interpreter gives you itself.
try:
    compile('class = 1', '', 'exec')
    print('no error')
except SyntaxError as error:
    print('SyntaxError:', error.msg)

The first block reports user_name, _private, and café as valid. It reports 2fast and my-name as invalid, because they break the rules about which characters are allowed. It reports class as the right shape but reserved. The compile call then raises the interpreter's own message, which says that you cannot assign to class.

Notice that isidentifier() only checks the shape of the name. It returns True for class, and that is why the keyword check has to be a separate step. In a linter or in a form, the two checks are always done together.

Python 3 has 35 reserved keywords, and the keyword module is the true source of that list instead of a list you memorised.

import keyword

print(len(keyword.kwlist))
for word in sorted(keyword.kwlist):
    print(word, end=' ')
print()

print(keyword.iskeyword('def'))      # True
print(keyword.iskeyword('my_def'))   # False
print(keyword.softkwlist)            # ['_', 'case', 'match']

The reserved words fall into several families. Control flow words are if, elif, else, for, while, break, continue, match, and case. Definition words are def, class, lambda, async, and await. Import words are import, from, and as. Values and operators are True, False, None, not, and, or, is, in, and del. Error handling words are try, except, finally, and raise. And there are a few others, such as assert, pass, global, nonlocal, yield, and with.

The practical point that matters is that keyword.iskeyword() answers exactly one question, which is whether the word is a hard reserved word. It deliberately returns False for match, case, and the single underscore, because those are only meaningful in a particular place.

It is also worth knowing that keywords are always written in lower case. You are free to create a variable called Class or IF, because Python does not treat them as keywords. The convention is still to keep your own names in lower case, so that the real keywords stay easy to spot.

A hard keyword is one that the tokenizer reserves everywhere, so you can never use it as an identifier. If match and case had been made hard keywords in Python 3.10, every existing program that used one of them as a variable, as a function parameter, or as an attribute name would have broken when it was upgraded. Lookups like config.match, loop variables called match, and function arguments named case are all common, so reserving those words outright would have caused a serious amount of breakage in a language that is proud of its promise to keep old code working.

Soft keywords solve that problem by making the word meaningful in one specific place in the syntax. The parser recognises a match statement when it sees the word match followed by a subject and a block of case arms. Everywhere else, match is an ordinary name, and you can still write match = 3 or def match(x). The keyword module shows this by listing them separately in softkwlist instead of in kwlist.

The price of that choice is that the grammar has to be a little more careful. The parser first tries to read the text as a match statement, and it falls back to treating match as a name when that reading does not fit. That is why some code that looks like a match statement can still be read as an assignment.

If an interviewer pushes you on language design, this is a good answer. Soft keywords let a language add new syntax without breaking the code that already exists, and they do it at the price of a grammar that is slightly more open to two readings.