What’s the convention for naming variables referencing classes?

General Discussions
, ,
1

What is the naming convention for a variable referencing a class in Python class naming convention?

Consider the following example:

class MyClass(object):
    pass

# Which of these is the correct convention?
reference_to_class = MyClass

# or
ReferenceToClass = MyClass

Here’s another scenario:

cars.py

class Car(object):
    pass

class Sedan(Car):
    pass

class Coupe(Car):
    pass

class StationWagon(Car):
    pass

class Van(Car):
    pass

def get_car_class(slug, config):
    return config.get(slug)

config.py

CONFIG = {
    'ford-mustang': Coupe,
    'buick-riviera': Coupe,
    'chevrolet-caprice': Sedan,
    'chevy-van': Van,
    'ford-econoline': Van
}

main.py

from config import CONFIG
from cars import get_car_class

MyCarClass = get_car_class('buick-riviera', CONFIG)
my_car = MyCarClass()

I prefer naming it ReferenceToClass, as it clearly indicates that it is a class and not an instance. Is there any literature or widely accepted standard for this practice in the context of Python class naming convention?

2

I’ve spent quite some time working with Python, and one thing I’ve consistently followed is the CapWords convention for class names—it’s a cornerstone of the Python class naming convention. When you reference a class, it’s a good idea to use capitalized variable names. This visually distinguishes class references from instance variables, which typically use lowercase or underscores.

Here’s an example:

class MyClass:
    pass

# Correct convention
ReferenceToClass = MyClass

This makes it immediately clear that ReferenceToClass is a class and not an instance, adhering to clean, readable code practices.

3

I totally agree with @akanshasrivastava.1121 point about clarity. Building on that, I’ve also noticed a trend in some codebases where underscores are used for temporary or internal references to classes. This subtle addition is still part of the Python class naming convention, but it signals that the variable is more of an implementation detail.

Take a look:e

class MyClass:
    pass

# Internal variable with reference to a class
_ReferenceToClass = MyClass

The underscore acts as a quiet reminder that this variable is intended for internal purposes and might not be relevant outside the immediate context. It’s a simple yet effective way to enhance readability.

4

Adding to what @akanshasrivastava.1121 @priyankasharma mentioned, another practice I’ve found immensely helpful is using descriptive names for class references. This approach aligns with the Python class naming convention while ensuring your code remains clear, especially in larger or more collaborative projects.

For example:

class Car:
    pass

# Descriptive name indicating the class reference
CarClass = Car

Using CarClass instantly conveys the purpose of the reference, reducing ambiguity. This is particularly useful in dynamic or factory design patterns, where clarity is key to avoid confusion for team members or future maintainers.