When to Use Constants in Python: Absolute Beginners Tutorial

You have probably seen variable names written in all capital letters in Python code. That uppercase style is not random. It is the community's way of marking a value as a constant — something that should stay the same for the life of the program. This tutorial explains what that means in practice, when to reach for a constant, and how to write one correctly from your very first Python project.

Python does not have a built-in const keyword the way some other languages do. Any name you assign a value to can technically be reassigned later. Constants in Python are an agreement between developers: write the name in uppercase letters, and everyone understands it should not change. That agreement, documented in PEP 8, is what makes Python code readable and safe to maintain.

What Is a Constant?

A constant is a name that holds a value you do not intend to change. In Python, you signal that intent by writing the name entirely in uppercase letters, with underscores separating words. This pattern is called the ALL_CAPS convention, and it comes directly from PEP 8, Python's official style guide.

Here is a straightforward example. Imagine your program needs to know the maximum number of login attempts before locking an account:

# Define a constant at the top of the module
MAX_LOGIN_ATTEMPTS = 5

def check_login(attempts):
    if attempts >= MAX_LOGIN_ATTEMPTS:
        return "Account locked."
    return "Try again."

The name MAX_LOGIN_ATTEMPTS tells any reader immediately what the number means. If the security policy changes and the limit becomes 10, you update exactly one line instead of hunting through the entire file.

"Constants should be written in all capital letters with underscores separating words." — PEP 8, Python Software Foundation

When Should You Use a Constant?

The most common signal that a value belongs in a constant is when that value appears more than once, has a meaning that raw text or a number does not communicate, or could change in the future and would be painful to update in multiple places. Three practical triggers help beginners decide:

The value never changes during a program run. Things like the speed of light, a tax rate, a maximum upload size, or a default timeout belong in constants. They are facts about the problem domain, not state that your program manipulates.

The raw value has no obvious meaning. If you encounter if retries > 5 in a code review, you immediately wonder: why five? What happens at six? Replacing it with if retries > MAX_RETRIES answers the question before it is asked.

The value appears in more than one place. Duplicating a literal integer or string in three functions means changing it requires touching three places and risking that you miss one. A constant gives you a single source of truth.

Where to Put Your Constants

PEP 8 recommends placing constants at the module level — that means at the top of your Python file, after the import statements and before any function or class definitions. This placement makes them easy to find, easy to update, and straightforward to import into other modules.

A typical module looks like this:

For projects with many constants, a dedicated constants.py file is a common pattern. Any module in the project can then import exactly what it needs:

# constants.py
MAX_RETRIES = 5
TIMEOUT_SECONDS = 30
API_BASE_URL = "https://api.example.com/v1"
DEFAULT_PAGE_SIZE = 20

# api_client.py
from constants import API_BASE_URL, TIMEOUT_SECONDS, MAX_RETRIES

def fetch_user(user_id):
    url = f"{API_BASE_URL}/users/{user_id}"
    for attempt in range(MAX_RETRIES):
        response = requests.get(url, timeout=TIMEOUT_SECONDS)
        if response.ok:
            return response.json()
    return None

"Example quote goes here." — Source

Python Learning Summary Points

1. Python does not enforce constants at the language level. The ALL_CAPS naming convention communicates intent to other developers and to static analysis tools like mypy and pylint.
2. Use a constant when a value is fixed for the life of the program, when a raw literal has no obvious meaning on its own, or when the same literal appears in more than one location.
3. Define constants at module level, after imports and before function or class definitions. For larger projects, collect all constants in a dedicated constants.py or config.py file and import from there.
4. Avoid reassigning a constant name inside a function or method. If you need a locally different value, assign it to a regular lowercase variable instead.
5. If you need runtime enforcement, use typing.Final to tell static type checkers that a name must not be reassigned after its initial definition.

The habit of reaching for a named constant instead of an inline literal is one of the smallest changes you can make with the largest payoff in readability. The next time you write a number or string that "just works," ask yourself: does this value have a name? If the answer is yes, give it one.