In Python development, proper naming conventions are crucial not only for code readability but also for helping team members better understand and maintain the codebase. This article explores the various uses of underscores in Python, with practical examples from machine learning and deep learning projects.

Why Do Naming Conventions Matter?

In software development, code readability and maintainability often take precedence over execution efficiency. As Tim Peters states in “The Zen of Python”:

Explicit is better than implicit.
Simple is better than complex.
Readability counts.

Good naming conventions help us achieve these principles.

Six Forms of Underscore Naming in Python

Snake Case Naming

In Python, we use underscores to separate words, known as Snake Case. This is the most recommended naming convention in the Python community.

# Recommended naming
learning_rate = 0.001
batch_size = 32

def train_model(data_loader, model, optimizer):
    pass

# Not recommended
learningRate = 0.001  # This is camelCase, not Python style

Single Leading Underscore

When we want to indicate that a variable or method is for internal use, we can use a single underscore prefix.

class NeuralNetwork:
    def __init__(self):
        self._hidden_layer = 64  # Indicates internal use
        
    def _preprocess_data(self, data):
        # Internal method
        pass

This naming convention indicates:

• This is an implementation detail
• External access is discouraged
• Won’t be imported by from module import *

Double Leading Underscore

Python’s name mangling mechanism automatically modifies variable names with double leading underscores.

class BaseModel:
    def __init__(self):
        self.__version = "1.0"  # Becomes _BaseModel__version

class SubModel(BaseModel):
    def __init__(self):
        super().__init__()
        self.__version = "2.0"  # Becomes _SubModel__version

This mechanism:

• Prevents accidental override by subclasses
• Provides stronger encapsulation
• Prevents naming conflicts

Trailing Underscore

When variable names conflict with Python keywords, we can add an underscore suffix.

class_ = "positive"  # class is a Python keyword
type_ = "numeric"    # type is a built-in function

def process_data(data, class_):
    return data[class_]

Common examples include:

• class_
• type_
• lambda_
• filter_

Single Underscore

A single underscore is typically used for temporary or unimportant variables.

# Ignoring loop counter
for _ in range(100):
    train_model()

# Ignoring values during unpacking
name, _, age = ("John", "unused", 25)

# Ignoring unwanted outputs in machine learning
predictions, _ = model.predict(data)

This is particularly useful in:

• Loop counters
• Unpacking assignments
• Ignoring function returns
• Temporary variables

Double Leading and Trailing Underscores (Magic Methods)

Special methods in Python (also called magic methods) use double underscores as prefixes and suffixes.

class Dataset:
    def __init__(self, data):
        self.data = data
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        return self.data[idx]
    
    def __call__(self, x):
        return self.process(x)

Common magic methods include:

• __init__: Initialize object
• __len__: Define length
• __getitem__: Allow index access
• __call__: Make object callable
• __str__: String representation

Best Practice Recommendations

1. Consistency
   • Maintain consistent naming style throughout the project
   • Follow team-agreed naming conventions
2. Clarity
   • Choose meaningful variable names
   • Avoid excessive abbreviations
3. Moderate Usage
   • Don’t overuse double leading underscores
   • Single leading underscores are often sufficient
4. Documentation
   • Add comments for complex naming decisions
   • Document naming conventions in project documentation

Application in Machine Learning Projects

Common naming patterns in machine learning projects:

class NeuralNetwork:
    def __init__(self):
        self._learning_rate = 0.001
        self._hidden_size = 64
        self.__checkpoint = None
    
    def _normalize_input(self, x):
        return (x - self._mean) / self._std
    
    def __save_state(self):
        # Internal state saving
        pass

class DataLoader:
    def __init__(self, batch_size):
        self.batch_size = batch_size
        self._buffer = []
    
    def __len__(self):
        return len(self._buffer)
    
    def __getitem__(self, idx):
        return self._buffer[idx]

Conclusion

Python’s underscore naming conventions are powerful tools that:

• Enhance code readability
• Express developer intentions
• Prevent naming conflicts
• Achieve better encapsulation

By properly using these naming conventions, we can write more maintainable and professional Python code.

Further Reading

• PEP 8 – Style Guide for Python Code
• Python Official Documentation - Naming Conventions
• The Zen of Python (PEP 20)