Naming Conventions in Python¶

Naming conventions are an important part of writing clean and readable code. In Python, the PEP 8 style guide provides recommendations on naming conventions. Here’s a summary of the conventions along with special cases and additional tips:

Naming Conventions¶

Variables:
Use snake_case for variable names.
Example: my_variable, total_count, is_valid.
Functions:
Use snake_case for function names.
Example: def calculate_total(), def get_user_name().
Classes:
Use PascalCase (also known as CamelCase).
Example: class MyClass, class UserProfile.
Modules:
Use snake_case for module names (file names).
Example: import my_module, from user_profile import get_user_name.
Constants:
Use UPPER_CASE for constants.
Example: PI = 3.14159, MAX_CONNECTIONS = 10.

Special Cases¶

Abbreviations:
Treat abbreviations as normal words and follow the same naming convention.
Variables and functions: html_parser, parse_html.
Classes: HtmlParser.
Dashes (-):
Dashes are not allowed in Python identifiers. Use underscores instead.
Example: short_term instead of short-term.
Names:
Follow the same naming conventions for names. Treat them as any other word.
Example: jack_smith for a variable or function, class JackSmith for a class.
Numbers:
Numbers can be included, but they should not start with a number.
Variables and functions: user_123, find_25th_element.
Classes: User123, Element25th.

Additional Tips¶

Descriptive Names:
Choose names that clearly describe the purpose of the variable, function, or class.
Avoid single-character names except for counters or iterators (e.g., i, j, k).
Avoid Ambiguity:
Ensure that names are not ambiguous and convey the intended meaning.
Example: calculate_total_price is more descriptive than calculate.
Consistency:
Be consistent with your naming conventions throughout your codebase.
Stick to the same style to improve readability and maintainability.
Avoid Using Reserved Keywords:
Do not use Python reserved keywords as names for variables, functions, or classes.
Example: class, def, return, etc.

Summary¶

Here's a summary of the recommended naming conventions:

Variables: snake_case
Functions: snake_case
Classes: PascalCase
Modules: snake_case
Constants: UPPER_CASE

Examples¶

# Variables
user_name = "JohnDoe"
total_count = 10

# Functions
def calculate_total(price, tax):
    return price + tax

def get_user_name():
    return "John Doe"

# Classes
class UserProfile:
    def __init__(self, name):
        self.name = name

# Constants
MAX_CONNECTIONS = 100
PI = 3.14159

# Modules (file names)
# user_profile.py
# html_parser.py

# Example with abbreviations, names, and numbers
html_parser = HtmlParser()
jack_smith = "Jack Smith"
user_123 = User123()
find_25th_element = find_25th_element()

Underscores¶

Underscores are used in Python for various special naming conventions. Understanding when and how to use underscores is important for writing idiomatic Python code. Here's a detailed explanation of the different uses of underscores in Python:

Single Leading Underscore `_var`¶

Purpose: Indicates a weak "internal use" indicator. This is a convention to tell other programmers that the variable or method is intended for internal use. It does not prevent access but suggests that it should be treated as a non-public part of the API.

Example:

class MyClass:
    def __init__(self):
        self._internal_variable = 42

Single Trailing Underscore `var_`¶

Purpose: Used to avoid conflicts with Python keywords or built-in names.

Example:

def function_(parameter):
    return parameter + 1

Double Leading Underscore `__var`¶

Purpose: Triggers name mangling, where the interpreter changes the name of the variable in a way that makes it harder to create subclasses that accidentally override the private attributes and methods. This is used to avoid name conflicts in subclasses.

Example:

class MyClass:
    def __init__(self):
        self.__private_variable = 42

Double Leading and Trailing Underscore `var`¶

Purpose: Indicates special methods (also known as "magic methods" or "dunder methods") that have special meaning in Python. These are predefined methods used to perform operator overloading, object creation, and other fundamental behaviors.

Example:

class MyClass:
    def __init__(self):
        pass

    def __str__(self):
        return "MyClass instance"

Single Underscore `_`¶

Purpose: Used as a throwaway variable name. This is a convention for variables that are temporary or insignificant.

Example:

for _ in range(5):
    print("Hello, World!")

References¶

PEP 8 - Style Guide for Python Code:
The official Python style guide, PEP 8, covers naming conventions, formatting, and best practices for writing Python code.
Link: PEP 8 - Style Guide for Python Code
Python Documentation:
The official Python documentation provides guidelines on naming conventions and special methods (also known as magic methods or dunder methods).
Link: Python Documentation

Specific Sections in PEP 8¶

Naming Conventions:
PEP 8 includes a section on naming conventions that describes how to name variables, functions, classes, constants, modules, and packages.
Link: PEP 8 - Naming Conventions
Method Names and Instance Variables:
This section discusses conventions for naming methods and instance variables, including the use of single and double underscores.
Link: PEP 8 - Method Names and Instance Variables
Public and Internal Interfaces:
Guidelines on how to distinguish between public and internal interfaces using naming conventions.
Link: PEP 8 - Public and Internal Interfaces

Summary of Naming Conventions from PEP 8¶

Variables and Functions:
Use snake_case for variables and function names.
Example: my_variable, calculate_total.
Classes:
Use PascalCase for class names.
Example: MyClass, UserProfile.
Modules and Packages:
Use snake_case for module and package names.
Example: my_module, user_profile.
Constants:
Use UPPER_CASE for constants.
Example: MAX_CONNECTIONS, PI.
Private Variables and Methods:
Use a single leading underscore _ for weak internal use.
Example: _internal_variable, _internal_method.
Name Mangling:
Use double leading underscores __ to invoke name mangling.
Example: __private_variable, __private_method.
Special Methods:
Use double leading and trailing underscores __ for special methods.
Example: __init__, __str__.
Throwaway Variables:
Use a single underscore _ for throwaway variables.
Example: for _ in range(10):.

Naming Conventions in Python¶