Overview, Timeline, Problems & Solutions
Overview of Python Names and Keywords
What is a name in Python?
A Python name is also called an identifier. A name is a word you use to show a variable, a function, a class, or another object in Python code. A name works like a label you place on a box to show what is inside.
A Python name can use uppercase letters A through Z, lowercase letters a through z, digits 0 through 9, and the underscore character _. A name cannot begin with a digit. You can use names like player1, total_score, or X. A name like 1st_place is not allowed because it starts with a digit.
Python names are case-sensitive. The name Name is different from the name name. Each one is a separate name in Python.
Python does not set a limit on name length. You can use short names or long names. A short name can help you read and understand code.
Python lets you name a value.
This example shows a valid Python name that identifies a value:
score = 100The name score is a valid Python identifier. The name score stores the value 100.
What characters can you use in Python names?
A Python name is also called an identifier. A Python identifier can use letters, digits, and the underscore character _. Within the basic ASCII range, you can use uppercase letters A through Z, lowercase letters a through z, digits 0 through 9, and the underscore character _. A Python name cannot begin with a digit.
Python 3 also allows Unicode characters. Unicode characters include letters from other alphabets outside the English language. This means you can use characters like α from the Greek alphabet or Б from the Cyrillic alphabet, if your Python file uses UTF-8 encoding. UTF-8 is the default encoding in Python.
You cannot use spaces in a Python name. You can use an underscore _ to show a space. For example, a name like max_value can stand for “max value.”
Python does not allow symbols like @, $, &, or - in names. These symbols have other meanings in Python code and are not part of valid names.
You can use English letters, digits (after the first character), and the underscore to write Python names.
You can use underscores when naming in Python.
This example shows a valid Python name with an underscore:
max_value = 10The name max_value is a valid Python identifier. The underscore connects the two parts of the name. The name max_value stores the value 10.
What are Python keywords?
A Python keyword is a special word that has a fixed meaning in the language. Python keeps these words to control how code runs. You cannot use a keyword as a name for a variable, a function, or anything else.
Some common Python keywords are if, else, for, while, class, def, True, False, and None. When Python reads one of these words, it knows the word is part of the code structure. For example, the keyword if starts a condition. The keyword True means a truth value.
Python gives you an error when you name a keyword.
Python will not let you assign a value to a keyword. This line will not work:
True = 5The word True is a keyword. Using it as a name will cause a syntax error.
Python keywords are case-sensitive. The word True is a keyword. The word true is not. You can make a name called true, but it will not mean the same thing.
There are a few dozen keywords in Python. Some other examples are and, as, assert, break, continue, return, import, from, lambda, with, try, except, finally, pass, yield, in, is, not, and or.
What are soft keywords in Python?
A soft keyword is a word that works like a keyword only in special situations. In other places, you can use the word as a name.
Python added soft keywords to support new features without blocking names in older code. In Python 3.10, the words match and case were added as soft keywords. Inside a match block, they act like real keywords. Outside that block, they can still be used as names.
You use match and case with Python’s soft keywords.
This example shows how match and case work as soft keywords:
match value:
case 1:
print("one")The word match starts the block. The word case checks for a value.
The single underscore _ is also a soft keyword. In a match block, _ is used as a wildcard. In the Python interpreter, _ holds the last result. Outside those places, you can use _ as a name.
In Python 3.12, the word type became a soft keyword in pattern matching. You can still use type as a name outside that use.
Are there special patterns for Python names?
Python uses a few name patterns with special meaning.
A name that starts with one underscore, like _helper, is meant for internal use. Python skips these names when you write from module import *.
A name that is only one underscore, _, is used when the name is not important. For example, in a loop like for _ in range(5):, you do not use the name, but the loop still runs five times.
A name that starts and ends with two underscores, like __init__, is used by Python for built-in actions. These are called double-underscore names. You should not make your own names like this unless Python requires them.
A name that starts with two underscores but does not end with two underscores, like __secret, is changed by Python inside a class. Python adds the class name to it. This prevents name conflicts in subclasses.
Python hides a name when you use double underscores.
This example shows a double-underscore name inside a class:
class Example:
def __init__(self):
self.__secret = 42The name __secret will be changed by Python to make it harder to access from outside the class.
Why are names and keywords important to learn in Python?
Python names and Python keywords are the basic parts of the language. A name points to something you create. A keyword controls how code runs.
When you choose a name, you must follow Python rules. When you use a keyword, you must use it the right way. This helps your code work without errors.
Knowing keywords also helps you read code. You know what each part does. You avoid mistakes like using for as a name.
You loop through values with for in Python.
This example shows the keyword for and a name used together:
for number in range(3):
print(number)The keyword for starts the loop. The name number holds each value from the range.
Timeline of Python Names and Keywords
Where do Python’s naming and keyword rules come from?
Python’s names and keywords reflect a long history. Some parts come from programming languages like ALGOL, C, and ABC. Others come from grammar theory and early computing. This timeline shows how Python’s system of names and keywords took shape.
1956 — Phrase structure grammar, Noam Chomsky, gave programming languages formal rules for syntax and naming structure.
1960 — Structured control keywords, ALGOL 60, used clear control words like if, then, and begin, setting patterns for block-based code.
1964 — Long descriptive names, PL/I, introduced naming rules for large programs with business and scientific terms.
1972 — Case-sensitive identifiers, C language, treated Name and name as different and used short control keywords like for and if.
1980 — Clear syntax and indentation, ABC language, used readable keywords and indentation instead of braces, and shaped Python’s naming and line style.
1989 — Simple keyword set, Guido van Rossum, designed early Python to use indentation and a minimal keyword list inherited from ABC and C.
1991 — Core operators and constants, Python 0.9.0, introduced and, or, not, None, and used the naming rules still used today.
2000 — New control flow, Python 2.0, added the keyword yield for generator functions, and later with for resource cleanup.
2001 — Style rules for names, PEP 8, defined community rules for names like lower_case_with_underscores and CapWords.
2008 — Reserved truth values, Python 3.0, turned True, False, and None into keywords and allowed Unicode in names with PEP 3131.
2015 — Async syntax, Python 3.5, added async and await to support asynchronous programming using new keywords.
2021 — Context-based keywords, Python 3.10, introduced match and case as soft keywords for pattern matching blocks.
2023 — Type-matching keyword, Python 3.12, added type as a soft keyword in match statements, continuing Python’s flexible approach.
2025 — Slow and stable changes, Python core team, avoids full new keywords and maintains long-term support for existing names
Problems and Solutions with Python Names and Keywords
Good naming in Python helps you write code that runs without error and is easy to understand. Python has clear rules for names and reserved words called keywords. These rules prevent confusion. The problems below use everyday examples to explain how Python naming rules work and why they matter. Each problem shows a situation and each solution connects it to Python.
Problem 1: Following naming rules in a form
You are filling out a form that asks for a username. The form says the name must begin with a letter and can only include letters, numbers, or underscores. You type 12*Star, but the form rejects it. It begins with a number and uses *, which is not allowed. You try again with Star_12 and the form accepts it.
Python has the same rule for names. A Python name must begin with a letter or an underscore. After that, the name can include letters, numbers, or underscores. No other characters are allowed.
Python lets you begin names with letters or underscores.
This example shows two valid Python names:
player1 = "Alice"
_score = 95The name player1 begins with a letter. The name _score begins with an underscore. Both follow the rules.
Problem 2: Case-sensitive labels
You are sorting boxes and put a label on one that says Fragile. You label another box as fragile. You think they are the same. But a helper sees the capital F and puts the boxes in different groups. The labels are treated as separate.
Python also treats uppercase and lowercase letters as different. A name like Time is not the same as time. If you write Value = 10 and later use value, Python does not recognize it. Python sees value as a different name or as a name that does not exist.
You and Python treat name and Name as different.
This example shows how case affects names in Python:
Name = "box"
name = "crate"The name Name and the name name are separate. Python stores them as different names.
Problem 3: Using a reserved word as a name
You are playing a board game. The game says that if someone says the word Skip, the next player misses a turn. You choose the team name Skip. During the game, people get confused. They don’t know if you mean the team or the game rule.
Python also has special words called keywords. A keyword has a meaning in Python. You cannot use a keyword as a name. For example, for is a keyword used to start a loop. If you write for = 5, Python gives an error. It expects for to begin a loop, not store a value.
Python won’t let you name something for.
This example shows what happens when a keyword is used as a name:
for = 5Python does not allow this. The keyword for is reserved.
Problem 4: Words with special meaning in context
The word ace means different things in different places. In a card game, ace means a strong card. Outside the game, ace can be a nickname. The meaning changes based on the context.
Python uses soft keywords in the same way. A soft keyword is only treated like a keyword in certain places. The words match and case are soft keywords in Python 3.10 and later. Inside a match block, Python treats them as keywords. Outside the block, you can use them as names.
You can use match and case as names unless Python needs them.
This example shows how match and case work in context:
match value:
case 1:
print("one")The word match starts the pattern match. The word case checks the value. Python reads these words as keywords only in this block.
Problem 5: Understanding special name patterns
You see company project codes written as __DATA__. You are told not to make names like that. These names are used for official tools. You are also told that if a folder begins with _, it is marked as internal. These naming rules are not enforced by the computer, but everyone follows them.
Python uses similar patterns. A name like __init__ begins and ends with two underscores. This kind of name is used by Python itself. You should not make your own names in this format unless you are using one of Python’s built-in methods.
A name that begins with one underscore, like _data, means “internal use.” Python does not stop you from using it, but other programmers will understand that the name is not for general use.
A name that begins with two underscores, like __secret, is changed by Python when it is used inside a class. Python adds the class name to the front of the name. This is called name mangling. It protects the name from being used by mistake in other parts of the code.
When you use double underscores, Python rewrites the name.
This example shows a special name used inside a class:
class Vault:
def __init__(self):
self.__code = "1234"The name __code is changed by Python so it does not get mixed up with names in other classes. This keeps it protected inside Vault.
Like, Comment, and Subscribe
Did you find this helpful? Let me know by clicking the like button below. I'd love to hear your thoughts in the comments, too! If you want to see more content like this, don't forget to subscribe to my channel. Thanks for reading!
Mike Vincent is an American software engineer and writer based in Los Angeles. Mike writes about technology leadership and holds degrees in Linguistics and Industrial Automation. More about Mike Vincent
