What is the common pitfall with Wildcard Imports (`from module import *`)?

Wildcard imports obscure where functions originate and cause silent namespace collisions. Exam trap note: PEP 8 strictly condemns `from module import *` in production code.

What are the core concepts of Python Modules & Packages?

When you execute `import math`, Python searches directories listed in `sys.path`. Once found, Python compiles the file to bytecode (.pyc in __pycache__), executes the top-level code, and caches the module in `sys.modules`. Subsequent imports of the same module retrieve the cached reference without re-executing.

← Previous: Python Scope & LEGB Rule All Modules Next: Python Dates & Math →

MOD-22 · Sequence #22 · Advanced Python

Python Modules & Packages

Modules (.py files) and packages (directories with __init__.py) organize code into reusable namespaces. Understanding import mechanics, sys.path resolution, aliases with `as`, and the `if __name__ == "__main__":` idiom is crucial for production code.

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

import math as m
print(m.sqrt(16))  # 4.0
print(m.pi)        # 3.14159...

Core Principles & Mental Models

1. Module Import Mechanics and sys.path

How CPython Locates and Caches Modules

When you execute `import math`, Python searches directories listed in `sys.path`.
Once found, Python compiles the file to bytecode (.pyc in __pycache__), executes the top-level code, and caches the module in `sys.modules`.
Subsequent imports of the same module retrieve the cached reference without re-executing.

import sys
print("Current Python sys.path entries:", len(sys.path))
import math as m
print("Square root of 25:", m.sqrt(25))

💡 Key Takeaway: Python caches loaded modules in sys.modules, executing module code only once per process.

2. The `if name == "main":` Execution Guard

Script Execution vs. Library Import

When a file is run directly by python (`python script.py`), Python assigns `__name__ = "__main__"`.
When a file is imported by another module (`import script`), Python assigns `__name__ = "script"`.
Wrapping entry points in `if __name__ == "__main__":` ensures tests and scripts only run when directly invoked.

def calculate_average(nums):
    return sum(nums) / len(nums)

if __name__ == "__main__":
    # Only runs when directly executed, not when imported!
    print("Self-test:", calculate_average([10, 20, 30]))

💡 Key Takeaway: Always guard top-level execution code with if __name__ == "__main__":.

Interactive Walkthrough Examples

Selective Imports vs. Wildcard Imports (Basic)

Demonstrating clean selective imports with aliases.

from math import pi, sqrt, floor as fl

print("Pi constant:", round(pi, 4))
print("Floor of 4.9:", fl(4.9))
print("Sqrt of 64:", sqrt(64))

Explanation: Selective imports keep namespaces clean and explicit.

Common Misconceptions & Exam Traps

Common Pitfall: Wildcard Imports (`from module import *`)

Wildcard imports obscure where functions originate and cause silent namespace collisions.

Buggy Code

from math import *  # Pollutes global namespace; can overwrite existing variables silently!

Correct Solution

import math
# or: from math import sin, cos

Exam Trap Note: PEP 8 strictly condemns `from module import *` in production code.

Conceptual Knowledge Self-Check Quiz

Q1: What is the value of `name` when a Python file is run directly as the main program?

"__init__"
"__main__"
"main"
The file name

CPython sets the special variable `__name__` to `"__main__"` for the entry-point script.

Algorithmic Practice Challenges

Idiomatic Best Practices

✅ Place imports at the very top of the file, grouped: Standard library, 3rd party, Local.
✅ Always use `if __name__ == "__main__":` in runnable scripts.

← Python Scope & LEGB Rule Take Assessed Test → Python Dates & Math →

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.