What is the common pitfall with Using Triple Quotes Inside a Function as a Comment Instead of Docstring?

If placed after other statements, a triple-quoted string is simply an unassigned expression, not the __doc__ metadata. Exam trap note: In exams inspecting `func.__doc__`, misplaced docstrings evaluate to None.

What are the core concepts of Python Comments?

Single-line comments start with a hash symbol (#) and are completely discarded by the Python compiler into bytecode. Docstrings are string literals placed immediately as the first statement of a module, function, class, or method. CPython retains docstrings as bytecode constants and binds them to the object’s `__doc__` special attribute.

← Previous: Python Syntax & Indentation All Modules Next: Python Variables & Dynamic Binding →

MOD-02 · Sequence #2 · Python Basics

Python Comments

Comments explain why code was written, while docstrings specify how modules, functions, and classes behave. Docstrings are accessible at runtime via the __doc__ attribute and power automated documentation tools like Sphinx and help().

Live Interactive Code Snippet (Python 3.12 CPython WASM) Open in Practice Mode →

# This is a single line comment
"""
This is a multiline
docstring explaining logic
"""
print("Comments documented")

Core Principles & Mental Models

1. Comments vs. Docstrings

Compile-Time Stripping vs. Runtime Reflection

Single-line comments start with a hash symbol (#) and are completely discarded by the Python compiler into bytecode.
Docstrings are string literals placed immediately as the first statement of a module, function, class, or method.
CPython retains docstrings as bytecode constants and binds them to the object’s `__doc__` special attribute.

def calculate_bmi(weight_kg, height_m):
    """Calculate Body Mass Index.

    Args:
        weight_kg: Weight in kilograms (float)
        height_m: Height in meters (float)

    Returns:
        Calculated BMI value (float)
    """
    return weight_kg / (height_m ** 2)

print(calculate_bmi.__doc__)

💡 Key Takeaway: Docstrings are introspectable at runtime via obj.__doc__ and help(obj), making them essential for reusable software.

Interactive Walkthrough Examples

Function Documentation with Google-style Docstrings (Basic)

Creating accessible documentation for an undergraduate math helper.

def gcd(a: int, b: int) -> int:
    """Compute the Greatest Common Divisor using Euclid's algorithm.
    
    Parameters:
        a (int): First non-negative integer.
        b (int): Second non-negative integer.
        
    Returns:
        int: Greatest common divisor of a and b.
    """
    while b != 0:
        a, b = b, a % b
    return a

print("GCD(48, 18):", gcd(48, 18))
print("First line of docstring:", gcd.__doc__.strip().split("\n")[0])

Explanation: Notice how gcd.__doc__ is preserved and accessible at runtime.

Common Misconceptions & Exam Traps

Common Pitfall: Using Triple Quotes Inside a Function as a Comment Instead of Docstring

If placed after other statements, a triple-quoted string is simply an unassigned expression, not the __doc__ metadata.

Buggy Code

def compute():
    x = 10
    """This is placed AFTER code so it is NOT a docstring,
    it is an unassigned string literal evaluated as a statement!"""
    return x * 2

Correct Solution

def compute():
    """Placed immediately as the first statement."""
    x = 10
    # Use regular # comments for inline explanations
    return x * 2

Exam Trap Note: In exams inspecting `func.__doc__`, misplaced docstrings evaluate to None.

Conceptual Knowledge Self-Check Quiz

Q1: Which special attribute stores a function's docstring at runtime in Python?

__comment__
__help__
__doc__
__meta__

__doc__ holds the string literal placed at the top of the function definition.

Algorithmic Practice Challenges

Idiomatic Best Practices

✅ Write comments to answer "why", not "what" — clear code already shows what it does.
✅ Always start docstrings with a one-line summary followed by a blank line and detailed notes.

← Python Syntax & Indentation Take Assessed Test → Python Variables & Dynamic Binding →

All 26 Curriculum Modules

MOD-01: Python Syntax & Indentation — Whitespace blocks, execution statements, and semicolon absence in Python.
MOD-02: Python Comments — Single-line comments (#) and multiline docstrings.
MOD-03: Python Variables & Dynamic Binding — Variable creation, dynamic typing, unpacking, and multiple assignment.
MOD-04: Python Data Types — Built-in fundamental types: int, float, str, bool, list, tuple, dict, set, None.
MOD-05: Python Numbers & Type Casting — Int, float, complex numbers, and casting via int(), float(), str().
MOD-06: Python Strings & Slicing — String arrays, indexing [start:stop:step], negative indices, and string methods.
MOD-07: Python Booleans & Logical Evaluation — Boolean truth values, truthy vs falsy values, and logical operators.
MOD-08: Python Operators — Arithmetic, assignment, comparison, logical, identity (is), and membership (in).
MOD-09: Python Lists (Arrays) — Ordered, mutable sequences, indexing, append, insert, remove, pop, and list comprehensions.
MOD-10: Python Tuples — Ordered, immutable sequences, unpacking, and tuple hashing for dictionary keys.
MOD-11: Python Sets — Unordered, unindexed collections of unique elements; union, intersection, difference.
MOD-12: Python Dictionaries — Key-value associative mappings, keys(), values(), items(), and dict comprehensions.
MOD-13: Python If...Else & Branching — Conditional branching, elif ladder, nested conditions, and ternary conditional operators.
MOD-14: Python While Loops — Conditional loops, break, continue, and the while...else loop construct.
MOD-15: Python For Loops & Range — Sequence iteration, range(start, stop, step), enumerate(), and zip().
MOD-16: Python Functions & Parameters — def declarations, positional args, keyword args, *args, **kwargs, and return statements.
MOD-17: Python Lambda Functions — Anonymous inline functions, map(), filter(), and sorted(key=lambda).
MOD-18: Python Classes & Objects (OOP) — Class definition, the __init__ constructor, the self receiver, and instance methods.
MOD-19: Python Inheritance & Polymorphism — Subclassing, super() initializer, method overriding, and polymorphism.
MOD-20: Python Iterators & Generators — __iter__ and __next__ protocols, and generator functions with the yield keyword.
MOD-21: Python Scope & LEGB Rule — Local, Enclosing, Global, and Built-in namespaces; global and nonlocal keywords.
MOD-22: Python Modules & Packages — import, from ... import ..., as alias, dir() inspection, and __name__ == "__main__".
MOD-23: Python Dates & Math — datetime module (now, strftime, strptime) and math functions (pow, sqrt, ceil, floor).
MOD-24: Python JSON & Regular Expressions — json.loads(), json.dumps(), and the re module (search, findall, sub, split).
MOD-25: Python Try...Except & Error Handling — Exception catching with try, except, else, finally, and raising custom exceptions.
MOD-26: Python File Handling — File open modes ("r", "w", "a", "x"), with context manager, and os removal.