What Are Constants in Python: Absolute Beginners Tutorial

If you have written even a handful of Python scripts, you have probably assigned a value to a name and expected it to stay the same for the rest of the program. That name is a constant. Understanding how Python handles constants, and why it does so differently from languages like C++ or Java, is one of the first building blocks of writing clean, readable code.

Every program contains values that should never change while the code runs. A database port number, the mathematical value of pi, or the maximum number of login attempts are all examples. In many languages these values are locked down with a keyword like const or final. Python takes a different path: it relies on a naming convention and the discipline of every developer on the team. This tutorial walks through the concept from scratch, shows you the convention, introduces the tools that can add guardrails, and gives you practice exercises along the way.

What Is a Constant and Why Does Python Need One?

A constant is a value that stays fixed for the entire lifetime of a program. Think of it as a label you attach to a piece of data with an agreement that the label will always point to the same thing. In contrast, a regular variable can be reassigned to a new value at any time.

Consider a program that calculates the area of a circle. The formula requires pi, and pi never changes. If you wrote 3.14159 directly into every formula, you would have a "magic number" scattered across your code. If you later needed more decimal places, you would have to hunt down every occurrence and update it. A constant solves this by giving that value a single, descriptive name.

# Without a constant — magic number scattered in code
area = 3.14159 * radius ** 2
circumference = 2 * 3.14159 * radius

# With a constant — single source of truth
PI = 3.14159
area = PI * radius ** 2
circumference = 2 * PI * radius

Constants improve readability because a reader can see PI and immediately understand what the value represents. They improve maintainability because changing the value requires editing a single line. And they reduce errors because there is no risk of mistyping a number deep inside a formula.

Variables vs. Constants at a Glance

A variable is a name you expect to reassign during execution. A constant is a name you expect to remain fixed. Both are created the same way in Python, with a simple assignment statement, but they follow different naming conventions so readers can tell them apart.

# Variable — lowercase with underscores (snake_case)
user_count = 0
user_count = user_count + 1  # reassignment is expected

# Constant — ALL UPPERCASE with underscores
MAX_USERS = 500
# MAX_USERS should never be reassigned

How Python Handles Constants: Convention Over Enforcement

Python's philosophy leans toward trusting developers rather than restricting them. Instead of a compiler refusing to let you change a value, Python relies on the ALL_UPPERCASE naming convention described in PEP 8, the official style guide. When you see a name written entirely in capital letters with underscores between words, you know the author intends it to be a constant.

# PEP 8 constant naming convention
MAX_RETRIES = 3
DATABASE_PORT = 5432
DEFAULT_TIMEOUT = 30
API_BASE_URL = "https://api.example.com/v2"

Nothing in the Python interpreter stops you from writing MAX_RETRIES = 99 later in the same file. The convention is a social contract: every developer on the team agrees to treat uppercase names as read-only. This approach is sometimes called "convention over enforcement," and it fits naturally with Python's dynamic nature.

Organizing Constants in Larger Projects

For small scripts, keeping constants at the top of a single file works well. As a project grows, a dedicated constants.py module is a common pattern. Other modules import the values they need, and the entire team knows exactly where to look when a configuration value needs reviewing.

# constants.py
MAX_CONNECTIONS = 100
TIMEOUT_SECONDS = 30
LOG_LEVEL = "INFO"

# app.py
from constants import MAX_CONNECTIONS, TIMEOUT_SECONDS

Built-in Constants and typing.Final

Python ships with a handful of built-in constants that you use every day, even if you have not thought of them that way. True, False, and None are all constant values. They are singletons, meaning each exists as exactly one object in memory, and they cannot be reassigned in modern Python.

The standard library also provides mathematical constants through the math module. math.pi returns 3.141592653589793, math.e returns Euler's number, math.tau gives the full circle constant (2 times pi), and math.inf represents positive infinity.

import math

print(math.pi)    # 3.141592653589793
print(math.e)     # 2.718281828459045
print(math.tau)   # 6.283185307179586
print(math.inf)   # inf

Enforcing Constants with typing.Final

Starting with Python 3.8, PEP 591 introduced typing.Final as a way to tell type checkers that a name should not be rebound. When you annotate a name with Final, tools like mypy will report an error if any later line tries to reassign it. The Python interpreter itself does not enforce this at runtime, but a type checker running as part of your development workflow will catch the mistake before the code ships.

from typing import Final

MAX_CONNECTIONS: Final = 100
DATABASE_PORT: Final[int] = 5432

# This runs fine in Python, but mypy will flag it:
MAX_CONNECTIONS = 200  # error: Cannot assign to final name

Other Approaches to Immutability

Beyond typing.Final, Python offers several ways to make values harder to change. The enum module lets you define a group of named constants as members of a class, and those members cannot be reassigned. A namedtuple produces a lightweight, immutable object. A frozen dataclass, created with @dataclass(frozen=True), raises an error if you try to modify any attribute after creation.

from enum import Enum

class Direction(Enum):
    NORTH = "N"
    SOUTH = "S"
    EAST = "E"
    WEST = "W"

print(Direction.NORTH)        # Direction.NORTH
print(Direction.NORTH.value)  # N

# Direction.NORTH = "UP"  # raises AttributeError

Python Learning Summary Points

1. A constant is a value intended to remain unchanged. Python signals this through the ALL_UPPERCASE naming convention described in PEP 8, not through a language keyword.
2. Python's built-in constants include True, False, None, and values from the math module like math.pi and math.e.
3. typing.Final (Python 3.8+) lets type checkers catch reassignment errors, but it does not enforce immutability at runtime. For full protection, pair it with immutable containers or use Enum and frozen dataclasses.
4. Place constants at the top of your module or in a dedicated constants.py file, and always use descriptive names that make the value's purpose clear without needing a comment.

Constants are a small concept with outsized impact on code quality. Getting into the habit of naming fixed values in ALL_UPPERCASE, placing them prominently at the top of your files, and reaching for Final when type checking is available will make your programs easier to read, maintain, and trust.