2.2 Naming Rules and Conventions for Variables

Introduction

In Python, variable names must follow specific rules to ensure that the code is valid, readable, and maintainable. Choosing good variable names improves code clarity and makes it easier for others (and yourself) to understand your programs.

In this section, you will learn:
The rules for naming variables in Python
The best practices for writing clean and readable variable names
The difference between valid and invalid variable names
Naming conventions for constants and private variables

By the end of this lesson, you will be able to write well-structured and professional-looking code!

2.2.1 Rules for Naming Variables in Python

Python has a few strict naming rules that must be followed when creating variables.

Allowed Naming Rules

Variable names must start with a letter (A-Z or a-z) or an underscore (_).
After the first character, variables can contain letters, numbers (0-9), and underscores (_).
Variable names are case-sensitive. (myVar, MYVAR, and myvar are different.)
Variable names cannot be Python reserved keywords. (if, class, return, while, etc.)

Invalid Variable Names

Python will raise an error if these rules are not followed.

Valid Variable Names

name = "Alice"  # Starts with a letter
_age = 25  # Starts with an underscore
student_name = "Bob"  # Uses underscores
score123 = 98  # Contains numbers (but doesn't start with one)

These names follow Python’s naming rules and will work without errors.

2.2.2 Best Practices for Naming Variables (Conventions)

Following consistent naming conventions makes your code more readable and professional.

Use Descriptive and Meaningful Names

Good variable names describe their purpose clearly.

Bad Naming (Too Generic or Confusing)

x = "Alice"  # What does x represent?
y = 25  # Unclear meaning

Good Naming (Descriptive and Meaningful)

user_name = "Alice"  # Clearly represents a user's name
user_age = 25  # Clearly represents the user's age

Use Snake Case for Variable Names (snake_case)

Python follows the snake_case convention: words are separated by underscores (_).

Preferred (Snake Case)

first_name = "Alice"
total_score = 95
user_email = "alice@email.com"

Avoid Camel Case (Used in Java/JavaScript)

firstName = "Alice"  # Not Pythonic
totalScore = 95  # Not Pythonic

Avoid Pascal Case (Used for Class Names in Python)

FirstName = "Alice"  # Not used for variables
TotalScore = 95

Use Pascal Case only for Class Names in Python, NOT variables.

Use UPPERCASE for Constants

A constant is a variable whose value should not change.
Python doesn’t have built-in constants, but by convention, constants are written in uppercase.

PI = 3.14159  # Constant value
MAX_USERS = 1000
DATABASE_URL = "https://example.com"

Note: Python does not enforce constants, so PI = 3.14 will not cause an error, but it is bad practice to change a constant.

Use Leading Underscore for Private Variables (_var)

In Python, a leading underscore (_variable) indicates a variable is intended for internal use (private).

_private_variable = "This is private"

This is not enforced by Python, but it signals to other programmers that the variable should not be modified externally.

Use Double Underscore (__var) for Name Mangling in Classes

If a variable has two leading underscores (__var), Python applies name mangling (useful in object-oriented programming).

class Example:
    def __init__(self):
        self.__secret_value = 42  # Private variable with name mangling

obj = Example()
print(obj.__secret_value)  # This will raise an AttributeError

Best Practice: Use double underscores only in classes, not for regular variables.

2.2.3 Reserved Keywords in Python (Cannot Be Used as Variables)

Python reserved keywords have special meanings and cannot be used as variable names.

List of Python Reserved Keywords

False    class    finally  is        return  
None     continue for      lambda    try  
True     def      from     nonlocal  while  
and      del      global   not       with  
as       elif     if       or        yield  
assert   else     import   pass  
break    except   in       raise

Example of Incorrect Usage

if = 10  # SyntaxError: invalid syntax
return = "Hello"  # SyntaxError: invalid syntax

Instead, use:

if_value = 10
return_message = "Hello"

Best Practice: If you accidentally use a keyword, modify the name slightly.

2.2.4 Using Meaningful Prefixes for Variables

Using prefixes makes it easier to identify variable types.

Examples of Recommended Naming Prefixes

Example of Consistent Naming:

is_admin = True  # Boolean variable
user_list = ["Alice", "Bob", "Charlie"]  # List variable
config_dict = {"theme": "dark", "language": "English"}  # Dictionary variable

This makes reading and debugging code easier.

2.2.5 Summary

Here is a summary of important concepts that we have covered in this section:

• Follow Python’s variable naming rules:
  Start with a letter or underscore
  Use only letters, numbers, and underscores
  Avoid special characters and spaces
  Do not use reserved keywords
• Best Practices Include:
  Use descriptive and meaningful names
  Use snake_case (user_name), NOT camelCase (userName)
  Use UPPERCASE for constants (PI = 3.14)
  Use _underscore for private variables (_private_var)
  Use prefixes to indicate variable type (is_active, user_list)

By following these conventions, your Python code will be more readable, maintainable, and professional.

What’s Next?

In the next lesson, 2.3 Common Data Types in Python, we will explore strings, integers, floats, and booleans—the building blocks of Python programming!