Intuition The one-sentence pictureA module is just a .py file full of ready-made code (functions, classes, variables), and import is how you borrow that code into your own file instead of rewriting it. Think of it like a library : you don't copy every book onto your desk — you keep a reference card and fetch what you need.
Intuition The problem they solveWithout modules you'd paste the same sqrt code, the same date logic, the same web-request code into every program. That is:
wasteful (typing it again),buggy (fix a bug in one copy, the others stay broken),unreadable (one giant file).
Modules let you write code once , store it in a file, and reuse it everywhere by name. This is the DRY principle: Don't Repeat Yourself .
Definition Module vs Package
A module is a single .py file (e.g. math.py).
A package is a folder of modules with an __init__.py file (e.g. numpy/).
The namespace is the "container of names" a module gives you so its pi doesn't clash with your pi.
Intuition Mental model — import runs the file ONCEWhen Python sees import math, it does three things in order:
Find the file math.py (searches sys.path).Execute every top-level line in it (defining functions, etc.) — only the first time .Bind a name (math) in your namespace that points to the finished module object.
The "execute only once" part is key: importing the same module twice does not run it twice — Python caches it in sys.modules.
import math print (math.pi) # 3.14159... print (math.sqrt( 16 )) # 4.0
math. prefix?
import math gives you one name: math. Everything inside lives behind the dot . This keeps your namespace clean — your own sqrt and math.sqrt never collide.
from math import pi, sqrt print (pi) # no prefix needed print (sqrt( 16 )) # 4.0
Intuition Why no prefix now?from math import sqrt copies the name sqrt directly into your namespace. Convenient, but riskier: if you later define sqrt, you silently overwrite it.
import numpy as np np.array([ 1 , 2 , 3 ])
Long names (matplotlib.pyplot) are tiring to type. Aliasing with as gives a short, community-standard nickname (np, pd, plt). It's the same object , just a shorter label.
from datetime import datetime as dt now = dt.now() Used to avoid a clash (here the module datetime and the class datetime share a name).
Common mistake Steel-man: "from module import * is the easiest — just grab everything!"
Why it feels right: no prefixes, no listing names — looks like the least typing.
Why it's wrong: from math import * dumps every public name into your namespace. You can't tell where gamma came from, and it can silently overwrite your own variables. Worse, two import * lines can clobber each other.
The fix: import explicitly (from math import sqrt, pi) or use the prefixed import math. Use * only in throwaway scripts / interactive shells.
Intuition The search orderWhen you import foo, Python checks sys.path — a list of folders — in order:
the directory of the running script (or current dir),
directories in PYTHONPATH,
the standard library + installed packages.
First match wins. This is why naming your file random.py breaks import random — your file is found first and shadows the real one.
Worked example Example 1 — clean prefixed importimport math area = math.pi * math.pow( 3 , 2 ) # circle radius 3 print ( round (area, 2 )) # 28.27 Why math.pi? Because import math only bound the name math; pi lives inside it.
Why round? math.pi is a long float; we trim for display — round is built-in, no import needed.
Worked example Example 2 — selective import to read cleanlyfrom statistics import mean, median data = [ 3 , 1 , 4 , 1 , 5 , 9 , 2 ] print (mean(data)) # 3.571... print (median(data)) # 3 Why from … import? The math reads like English (mean(data)), no statistics. noise.
Why list both names? Explicit imports document exactly what this file depends on.
Worked example Example 3 — aliasing to avoid a clashfrom datetime import datetime as dt, timedelta tomorrow = dt.now() + timedelta( days = 1 ) print (tomorrow.date()) Why as dt? The class datetime lives inside the module datetime; aliasing prevents confusion and shortens calls.
Why timedelta un-aliased? Its name is already clear and unique — no reason to rename.
Worked example Example 4 — proving "import runs once"# mymod.py print ( "mymod is being executed!" ) x = 42 # main.py import mymod # prints "mymod is being executed!" import mymod # prints NOTHING — cached in sys.modules print (mymod.x) # 42 Why nothing the second time? Python checks sys.modules first; finding mymod already there, it skips re-execution. Why this matters: module-level code (DB connections, prints) runs exactly once — predictable and fast.
Recall Feynman: explain it to a 12-year-old (click to open)Imagine your toy box has a calculator toy inside (math). You can say "toy box, give me your calculator" (import math, then math.sqrt) — you keep saying "toy box's" before every toy so you don't mix it with your own toys. Or you can take the calculator out and put it on your desk (from math import sqrt) so you grab it directly — but careful, now if you already had a thing called "calculator" on your desk, the new one covers it up! And as is just sticking a nickname sticker on the toy so you can call it something shorter.
What is a Python module? A single .py file containing reusable code (functions, classes, variables).
What is the difference between a module and a package? A module is one .py file; a package is a folder of modules containing an __init__.py.
After import math, how do you call sqrt? math.sqrt(...) — you must use the math. prefix.
After from math import sqrt, how do you call sqrt? Just sqrt(...) — the name was copied into your namespace, no prefix.
What does as do in an import? Gives the imported module/name an alias (nickname) — same object, shorter label.
Why is from module import * discouraged? It dumps all public names into your namespace, hiding origins and silently overwriting your own variables.
How many times does Python execute a module's top-level code on repeated imports? Once — subsequent imports are served from the sys.modules cache.
Where does Python search for a module to import? The folders listed in sys.path (script dir, PYTHONPATH, then standard/installed libs), first match wins.
Why does naming your file random.py break import random? Your local file is found first on sys.path and shadows the real standard-library module.
What is a namespace in the context of modules? A container of names; import module keeps the module's names behind its prefix so they don't clash with yours.
Python Functions — modules mostly bundle reusable functions.Namespaces and Scope — import is fundamentally about binding names into namespaces.sys and os modules — sys.path and sys.modules control import resolution.Packages and __init__.py — scaling from one file to many.Virtual Environments and pip — how third-party modules get onto sys.path.DRY Principle — the design idea that motivates modules.
from module import name as alias
Intuition Hinglish mein samjhoDekho, ek module matlab simple — ek .py file jisme pehle se likha hua code (functions, variables, classes) pada hota hai. import ka kaam hai woh code apni file me udhaar lena, taaki tumhe dobara likhna na pade. Jaise library se book reference lete ho — poori book copy nahi karte, bas naam se mangwa lete ho. Yahi DRY principle hai: Don't Repeat Yourself .
Char tareeke hote hain. import math karoge to har cheez ke aage math. lagana padega (math.pi) — isse tumhare apne naam aur module ke naam kabhi clash nahi karte, safe rehta hai. from math import pi karoge to seedha pi use kar sakte ho bina prefix ke — convenient, par dhyan rakho, agar tumne baad me khud pi banaya to purana overwrite ho jayega. import numpy as np matlab nickname — same cheez, bas chhota naam (community standard: np, pd, plt).
Ek important baat: jab tum import karte ho, Python pehle file dhoondhta hai sys.path me, phir uska top-level code ek hi baar chalata hai, aur cache (sys.modules) me rakh leta hai. Isliye do baar import karne par code dobara nahi chalta. Aur yahi reason hai ki apni file ka naam random.py mat rakhna — warna tumhari file pehle mil jayegi aur asli random module chhup jayega. from module import * se bacho — yeh sab naam ek saath ghusa deta hai aur confusion + overwrite ka khatra hota hai. Explicit import sabse safe aur readable hai.
