Python Naming Conventions: Best Practices and Examples

Python, known for its readability and simplicity, has a set of naming conventions that help maintain consistency and clarity in code. Adhering to these conventions not only makes your code more understandable to others but also enhances its maintainability. In this article, we’ll delve into the Python naming conventions, provide numerous examples, and highlight discouraged practices.

Variable Names

Lowercase with Underscores: Variables should be lowercase with underscores separating words. This convention, known as snake_case, improves readability.

# Good
my_variable = 42
user_name = "JohnDoe"

Descriptive Names

Use meaningful and descriptive names for variables to convey their purpose.

# Good
total_students = 100
average_grade = 85.5

Avoid Single Letters: Unless used in loop indices, avoid single-letter variable names as they lack clarity.

# Discouraged
x = 10

Function Names

Lowercase with Underscores: Similar to variables, function names should also be in snake_case.

# Good
def calculate_total(items):

Verb-Noun Format

Use verbs to describe the action followed by a noun representing the object or subject.

# Good

Underscores for Private Functions

Functions intended for internal use within a module can start with a single underscore.

# Good
def _internal_function():

Class Names

CamelCase: Class names should capitalize the first letter of each word without underscores (known as CamelCase).

# Good
class MyClass:

Descriptive and Noun Phrases

Class names should be descriptive and represent a noun or noun phrase.

# Good
class Car:


Uppercase with Underscores

Constants should be all uppercase with underscores separating words.

# Good
PI = 3.14159

Module Names

Short, Lowercase Names: Module names should be short, all lowercase, and preferably single words.

# Good
import math
import os

Avoid Hyphens

Hyphens are not allowed in module names; use underscores instead.

Discouraged Practices

Single-Character Names

Avoid using single-character names for variables, except for loop indices.

# Discouraged
x = 5


Avoid using mixed-case names; stick to snake_case for variables and CamelCase for classes.

# Discouraged
myVariable = 10

Reserved Keywords

Avoid using Python reserved keywords as variable names.

# Discouraged
class = "Python101"

Overly Generic Names

Avoid overly generic names that don’t convey the purpose of the variable or function.

# Discouraged
data = [1, 2, 3]

Example Program: Calculating the Average of Numbers

Let’s consider a simple program that calculates the average of a list of numbers. We’ll provide two versions of the program: one following Python naming conventions and another that doesn’t, for comparison.

Version Following Conventions:

def calculate_average(numbers):
    Calculates the average of a list of numbers.
    total = sum(numbers)
    return total / len(numbers)

numbers_list = [10, 20, 30, 40, 50]
average = calculate_average(numbers_list)
print("The average is:", average)

Version Not Following Conventions

def calcAvg(nums):
    Computes average of a list of numbers.
    total = sum(nums)
    return total / len(nums)

list_of_numbers = [10, 20, 30, 40, 50]
avg = calcAvg(list_of_numbers)
print("The average is:", avg)


In the version following conventions:

  • Function name calculate_average is in snake_case and descriptive.
  • Variable names numbers_list, total, and average are in snake_case and descriptive.
  • Clear docstring provided for the function.
  • Consistent indentation and spacing.

In the version not following conventions:

  • Function name calcAvg violates conventions by using CamelCase and abbreviation.
  • Variable names list_of_numbers and avg are less descriptive and violate snake_case convention.
  • Docstring is present but less descriptive.
  • Inconsistent indentation and spacing.

Following conventions makes the code more readable and understandable, while violating them can lead to confusion and maintenance issues.


By following these naming conventions, your Python code will become more readable, maintainable, and consistent. Remember, clarity and consistency are key principles in writing high-quality code.

Sharing is caring!

Leave a Reply

Your email address will not be published. Required fields are marked *