Previous | Tutorial index | Next

Tutorial 1: Naming Rules and Conventions in Python

Learning Objective

To be able to make and use names correctly to identify various items in your Python programs.

1. Introduction

1.1 What are Identifiers?

In Python, an identifier is the name you give to a programming entity. This includes variables, functions, classes, modules, and packages. Identifiers are how you reference these objects later in your code.

• When you write age = 25, age is an identifier that points to the integer object 25 in memory.
• When you define def calculate():, calculate is an identifier for that function object.

1.2 The Three Golden Rules (Syntactic Rules – Must Follow or SyntaxError)

1. First Character Rule:

   • Must start with a letter (A-Z or a-z) or an underscore (_).
   • Cannot start with a digit.
   • ✅ Valid: name, _private, var1
   • ❌ Invalid: 1st_place (Starts with a number), @username (Starts with a special char).

2. Subsequent Character Rule:

   • After the first character, you may use letters, digits, or underscores.
   • No other special symbols are allowed. This means no !, @, #, $, %, ^, &, *, - (hyphen), or spaces.
   • ✅ Valid: user_name, total_2026, data2
   • ❌ Invalid: user-name (Hyphen is interpreted as the subtraction operator), total$ (Dollar sign), first name (Space is not allowed).

3. Reserved Keywords Rule:

   • You cannot use Python's reserved keywords as identifiers. These words have special syntactic meaning to the interpreter.

   • Full list (as of Python 3.11): False, None, True, and, as, assert, async, await, break, class, continue, def, del, elif, else, except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield.

   • ❌ Invalid: if = 5, for = "loop", class = "Math"

   • Pro Tip: You can check all keywords in your Python environment by running:

     import keyword
     print(keyword.kwlist)
     

1.3 Case Sensitivity (The Tricky Detail)

Python treats uppercase and lowercase letters as distinctly different characters. Therefore:

• total, Total, and TOTAL are three entirely separate variables.
• This is both a blessing (allows flexibility) and a curse (can cause bugs if you mistype a variable name). Always be consistent.

1.4 Unicode and Non-ASCII Characters (The Subtle Exception)

• Technically, Python 3 allows Unicode characters in identifiers (e.g., résumé = "CV", température = 25).
• However: This is heavily discouraged in professional settings. Different operating systems and text editors handle Unicode differently, and it breaks compatibility. Stick to A-Z, a-z, 0-9, and _.

1.5 PEP 8 Naming Conventions (Best Practices – Not Enforced, but Crucial)

Why do we follow conventions? As the Zen of Python states: "Readability counts." Code is read far more often than it is written.

• Variables and Functions: Use snake_case. All lowercase, with underscores separating words.

  • ✅ Good: student_name, calculate_average, is_valid
  • ❌ Bad: studentName (That's CamelCase, reserved for classes), StudentName (Looks like a class).

• Constants: Use UPPER_CASE. All uppercase letters with underscores.

  • ✅ Good: MAX_SPEED, PI, DEFAULT_TIMEOUT
  • ❌ Bad: maxSpeed, pi (makes it look like a regular variable).

• Classes: Use CamelCase (also known as CapWords). Each word starts with a capital letter, no underscores.

  • ✅ Good: class StudentRecord:, class BankAccount:
  • ❌ Bad: class student_record: (That's for functions).

• Private/Internal Names (Advanced Hint): A single leading underscore (_internal) suggests that a variable or method is meant for internal use within a module or class. A double leading underscore (__private) invokes name mangling.

1.6 The "Shadowing" Pitfall (Built-in Names) While not a syntax error, you should never use the names of Python's built-in functions as variable names. This "shadows" them, meaning you lose access to the original function.

• ❌ Bad Practice: list = [1, 2, 3] (Now you cannot use the list() constructor later).
• ❌ Bad Practice: print = "Hello" (Now you broke the print() function).
• ✅ Good Practice: Use my_list or items instead of list.

2. Code Examples (Annotated)

# --- Valid and Recommended Names ---
student_first_name = "Alice"   # snake_case for variable
BASE_SALARY = 50000            # UPPER_CASE for constant
is_enrolled = True             # Boolean flag, clearly descriptive

def calculate_grade(score):    # snake_case for function
    return score * 1.1

class StudentProfile:          # CamelCase for class
    pass

# --- Invalid Names (Uncomment to see SyntaxError) ---
# 1st_student = "Bob"          # SyntaxError: invalid decimal literal
# student-name = "Bob"         # SyntaxError: cannot assign to expression here
# def = 10                     # SyntaxError: invalid syntax (keyword)

# --- Names that are Legal but Dangerous (Shadowing built-ins) ---
# WARNING: DO NOT DO THIS!
# list = [1, 2, 3]              # Legal, but now list() is broken.
# print = "Hello"               # Legal, but now you can't print!

# The right way to handle that:
my_numbers = [1, 2, 3]          # Use a descriptive alternative

# --- Demonstrating Case Sensitivity ---
score = 90
Score = 95
SCORE = 100
print(score)   # Outputs: 90
print(Score)   # Outputs: 95
print(SCORE)   # Outputs: 100

3. Quiz (Check Your Understanding)

Question 1: Which of the following are syntactically valid variable names in Python? (Select all that apply) a) _temp_value b) 2nd_attempt c) user-id d) total_amount e) class

Question 2: Are myVariable and myvariable the same variable? Why?

Question 3: Which of the following names best follows the PEP 8 convention for a constant representing the maximum number of login attempts? a) maxLoginAttempts b) MAX_LOGIN_ATTEMPTS c) max_login_attempts d) MaxLoginAttempts

Question 4: Why is import a bad name for a variable?

Question 5: (Tricky) Which of the following is valid but considered a terrible practice? a) _hidden b) π (Pi symbol) c) print d) user_name

4. Exercises (In-Class / Lab Practice)

Exercise 1: Spot the Invalid Names Identify the invalid names below, explain why they are invalid, and rewrite them correctly using PEP 8 rules:

1. 1st_name
2. last#name
3. while
4. user age
5. total-score
6. _private (Is this invalid? Actually, it's valid. Trick question!)

Exercise 2: Refactor (Fix the Mess) A new programmer wrote the following code. The names are legal but violate PEP 8 conventions. Rewrite the code with proper naming conventions.

# Bad Example - Fix it!
studentName = "John"
StudentAge = 20
def getAverageGrade(grade1, grade2):
    return (grade1 + grade2) / 2
MAXIMUMGRADE = 100

student_name = "John"
student_age = 20

def get_average_grade(grade1, grade2):
    return (grade1 + grade2) / 2

MAXIMUM_GRADE = 100

Exercise 3: Write a Short Program Write a Python program that declares 6 variables to represent a book in a library:

• Title (string)

• Author (string)

• Publication year (integer)

• Price (float)

• Is available (boolean)

• Number of pages (integer)

Make sure all variables follow PEP 8 rules for regular variables.

# Book information variables following PEP 8 snake_case naming
title = "The Pragmatic Programmer"
author = "David Thomas and Andrew Hunt"
publication_year = 1999
price = 45.99
is_available = True
num_pages = 352

# Print the book details
print("Book Details:")
print(f"Title: {title}")
print(f"Author: {author}")
print(f"Publication Year: {publication_year}")
print(f"Price: ${price:.2f}")
print(f"Available: {is_available}")
print(f"Number of Pages: {num_pages}")

5. Homework Questions (Deep Thinking)

Question 1 (Research): The rule says you cannot use a hyphen (-) in a variable name. Yet, it is a common character. Why do you think Python (and most programming languages) use underscores (_) instead of hyphens for multi-word names? (Hint: Think about the arithmetic operator for subtraction).

Question 2 (Debugging): A student runs the following code:

sum = 5 + 10
print(sum)
sum = sum("Hello") # They try to add up letters later

This code works initially but fails later. Why is using sum as a variable name a bad idea in a large program?

Question 3 (Comprehension): Explain the difference between a syntactic rule (like "cannot start with a number") and a convention (like "use snake_case for variables"). If you break a syntactic rule, what happens? If you break a convention, what happens?

Question 4 (PEP 8 Deep Dive): Go to the official PEP 8 documentation online (or a summary) and find the section on "Naming Conventions". Name one type of identifier (e.g., Class, Function, Constant) and write down the specific PEP 8 recommendation for it. Why does PEP 8 specifically recommend CamelCase for classes but snake_case for functions?

6. Summary Checklist (For Student Self-Review)

• I know that identifiers must start with a letter or underscore.
• I know that the rest of the name can only include letters, digits, and underscores.
• I can name at least 5 Python reserved keywords from memory.
• I understand why list is a bad variable name (shadowing).
• I know to use snake_case for variables and functions.
• I know to use UPPER_CASE for constants.
• I understand that Python is case-sensitive.

Previous | Tutorial index | Next