Python OS Module

The Story That Explains the os Module 🔑os Module समझाने वाली कहानी 🔑一个讲清 os 模块的故事 🔑

The os module is Python's bridge to your operating system. Its star, os.walk(), visits every folder in a tree — the reason a ten-line script can tidy up thousands of files.

os module आपके operating system तक Python का पुल है। इसका सितारा, os.walk(), tree के हर folder में जाता है — इसी वजह से दस lines की script हज़ारों files सँभाल सकती है।

os 模块是 Python 通往操作系统的桥梁。它的明星 os.walk() 会访问树中的每个文件夹 — 这就是十行脚本能整理成千上万个文件的原因。

The Six Families of os Functions 👪os Functions के छह परिवार 👪os 函数的六大家族 👪

The os module is large, but almost every function belongs to one of six families. Know the families and you will always know where to look.

os module बड़ा है, पर लगभग हर function छह परिवारों में से एक का है। परिवार जान लें तो हमेशा पता रहेगा कि कहाँ देखना है।

os 模块很大，但几乎每个函数都属于六大家族之一。认识这些家族，你就总能知道去哪里找。

Getting Oriented — Where Am I? 🧭दिशा पहचानना — मैं कहाँ हूँ? 🧭找准方位 — 我在哪里？🧭

All the examples in this tutorial run inside the same practice folder, which contains a small project/ tree, some photos, logs and loose files.

इस tutorial के सारे उदाहरण एक ही practice folder में चलते हैं, जिसमें एक छोटा project/ tree, कुछ photos, logs और खुली files हैं।

本教程所有示例都在同一个练习文件夹中运行，里面有一个小型 project/ 树、一些照片、日志和零散文件。

import os

# Where is my script running from?
print(os.getcwd())

# What is in this folder? (sorted, because the order is not guaranteed)
print(sorted(os.listdir()))

# List a DIFFERENT folder without moving
print(sorted(os.listdir("project")))

# Check before you touch
print(os.path.exists("data.csv"), os.path.isfile("data.csv"), os.path.isdir("data.csv"))
print(os.path.exists("missing.csv"))
print(os.path.isdir("project"))

Creating and Removing Folders 🏗️Folders बनाना और हटाना 🏗️创建与删除文件夹 🏗️

import os
import shutil

os.mkdir("reports")                          # ONE folder
os.makedirs("archive/2026/january/raw")      # a whole chain at once
os.makedirs("cache", exist_ok=True)          # no error if it already exists
os.makedirs("cache", exist_ok=True)          # ...so running it twice is fine

for action in [lambda: os.mkdir("reports"),            # already exists
               lambda: os.mkdir("logs2/2026/jan"),     # parent missing
               lambda: os.rmdir("archive")]:           # not empty
    try:
        action()
    except OSError as e:
        print(type(e).__name__, "->", e)

os.rmdir("reports")                              # empty -> removed
os.removedirs("archive/2026/january/raw")        # removes the empty chain, bottom-up
print(os.path.exists("archive"))

open("cache/data.bin", "w").close()
shutil.rmtree("cache")                           # deletes a folder AND everything in it
print(os.path.exists("cache"))

File Operations — Rename, Remove, Inspect 📄File के काम — नाम बदलना, हटाना, जाँचना 📄文件操作 — 重命名、删除、查看 📄

import os
from datetime import datetime, timezone

# Rename and move use the same call
os.rename("draft.txt", "final.txt")
os.rename("final.txt", "reports_archive/final.txt")   # into another folder
print(sorted(os.listdir("reports_archive")))

# Delete a file - permanent, no recycle bin
os.remove("temp.log")
print(os.path.exists("temp.log"))

# Metadata: size, timestamps, permissions
info = os.stat("data.csv")
print(f"Size:     {info.st_size} bytes")
print(f"Modified: {info.st_mtime}")                  # seconds since 1 Jan 1970 (UTC)
print(f"Mode:     {oct(info.st_mode)}")
when = datetime.fromtimestamp(info.st_mtime, tz=timezone.utc)
print(f"Readable: {when:%Y-%m-%d %H:%M} UTC")

st_mtime is a count of seconds since 1 January 1970 (UTC), often called a timestamp. Convert it with datetime.fromtimestamp(). The mode 0o100644 means "a regular file that the owner can read and write, and everyone else can read".

st_mtime 1 जनवरी 1970 (UTC) से बीते सेकंडों की गिनती है, जिसे अक्सर timestamp कहते हैं। इसे datetime.fromtimestamp() से बदलें। Mode 0o100644 का मतलब है "एक सामान्य file जिसे owner पढ़-लिख सकता है, और बाक़ी सब पढ़ सकते हैं"।

st_mtime 是自 1970 年 1 月 1 日（UTC）以来的秒数，通常叫 时间戳。用 datetime.fromtimestamp() 转换。模式 0o100644 表示"普通文件，所有者可读写，其他人只读"。

Try It — Folder Operations Storyकरके देखें — Folder Operations Story动手试试 — 文件夹操作故事

Three short stories, each a sequence of real calls run on a real empty folder. Step through and watch the tree change after every call — green rows appear, red rows disappear, and errors are shown exactly as Python reported them.

तीन छोटी कहानियाँ, हर एक असली ख़ाली folder पर चलाई गई असली calls का क्रम। कदम-दर-कदम चलें और हर call के बाद tree बदलते देखें — हरी rows आती हैं, लाल rows जाती हैं, और errors वैसे ही दिखते हैं जैसे Python ने बताए।

三个小故事，每个都是在真实空文件夹上运行的一系列真实调用。逐步执行，看每次调用后树的变化 — 绿色行出现，红色行消失，错误与 Python 报告的完全一致。

Path Anatomy — What Makes Up a Path 🧬Path की बनावट — Path किससे बनता है 🧬路径解剖 — 路径由什么组成 🧬

Every path can be split into named parts, and os.path has a function for each part.

हर path को नाम वाले हिस्सों में बाँटा जा सकता है, और os.path में हर हिस्से के लिए एक function है।

每个路径都能拆成有名字的部分，os.path 为每个部分都提供了函数。

import os

path = "/home/aarav/data/report.csv"

print(os.path.basename(path))
print(os.path.dirname(path))
print(os.path.split(path))          # (dirname, basename)
print(os.path.splitext(path))       # (everything before the extension, extension)

print(os.path.join("/home/aarav", "reports", "2026", "jan.csv"))
print(os.path.isabs(path), os.path.isabs("data.csv"))

Four Path SurprisesPath के चार चौंकाने वाले नियम路径的四个意外

import os
import ntpath          # the rules os.path uses on Windows, available everywhere

# 1) An absolute part throws away everything before it
print(os.path.join("data", "/etc/passwd"))

# 2) normpath tidies "..", "." and doubled slashes
print(os.path.normpath("data//2026/./jan/../feb/sales.csv"))

# 3) splitext only takes the LAST extension
print(os.path.splitext("backup.tar.gz"))
print(os.path.splitext(".bashrc"))           # a leading dot is not an extension

# 4) The same join on Windows rules
print(ntpath.join("C:\\Users", "aarav", "notes.txt"))
print(ntpath.splitext("C:\\Users\\aarav\\report.CSV"))

Try It — Path Dissectorकरके देखें — Path Dissector动手试试 — 路径解剖器

Pick a path and a rule set. The coloured bar shows how Python splits it (folder · separator · name · extension), and the table shows the exact values Python returns. Try the Windows paths with Linux/macOS rules — a surprise awaits.

एक path और नियमों का सेट चुनें। रंगीन पट्टी दिखाती है कि Python उसे कैसे बाँटता है (folder · separator · नाम · extension), और table वही values दिखाती है जो Python लौटाता है। Windows paths को Linux/macOS नियमों से आज़माएँ — एक हैरानी इंतज़ार में है।

选择一个路径和一套规则。彩色条显示 Python 如何拆分它（文件夹 · 分隔符 · 名字 · 扩展名），表格显示 Python 返回的确切值。用 Linux/macOS 规则试试 Windows 路径 — 有惊喜等着你。

os.walk() — Visiting Every Folder in a Tree 🌳os.walk() — Tree के हर Folder तक जाना 🌳os.walk() — 访问树中的每个文件夹 🌳

os.walk(top) is a generator. Each time the loop asks for the next item, it visits one folder and hands back a 3-item tuple: (dirpath, dirnames, filenames). It keeps going until every folder below top has been visited.

os.walk(top) एक generator है। हर बार जब loop अगला item माँगता है, यह एक folder में जाता है और 3 items का tuple देता है: (dirpath, dirnames, filenames)। यह तब तक चलता है जब तक top के नीचे का हर folder देख न लिया जाए।

os.walk(top) 是一个 生成器。循环每要一次下一个元素，它就访问一个文件夹，并交回一个三元组：(dirpath, dirnames, filenames)。直到 top 下的每个文件夹都被访问过才停止。

import os

for dirpath, dirnames, filenames in os.walk("project"):
    print(f"Folder: {dirpath}")
    print(f"  Sub-folders: {dirnames}")
    print(f"  Files:       {filenames}")

Try It — The os.walk Explorer 🔭करके देखें — os.walk Explorer 🔭动手试试 — os.walk 探索器 🔭

This explorer replays real os.walk runs on the project/ tree from Section 07 — 12 combinations, all recorded from Python. Step through one yield at a time. The numbers on the folders show the visiting order. SKIP is {".git", "__pycache__"}.

यह explorer Section 07 के project/ tree पर असली os.walk runs दोहराता है — 12 combinations, सब Python से रिकॉर्ड किए गए। एक बार में एक yield आगे बढ़ें। Folders पर लिखे नंबर जाने का क्रम दिखाते हैं। SKIP है {".git", "__pycache__"}।

这个探索器重放在第 07 节 project/ 树上真实运行的 os.walk — 共 12 种组合，全部来自 Python 录制。一次前进一个 yield。文件夹上的数字表示访问顺序。SKIP 是 {".git", "__pycache__"}。

Predictable Order with dirnames.sort()dirnames.sort() से तय क्रम用 dirnames.sort() 获得可预测顺序

import os

# Sort in place for a predictable order on every computer
for dirpath, dirnames, filenames in os.walk("project"):
    dirnames.sort()
    print(dirpath, sorted(filenames))

os.walk Patterns You Will Use Again and Again 🧰os.walk Patterns जो बार-बार काम आएँगे 🧰会反复用到的 os.walk 模式 🧰

Pattern 1 — Skip Folders (Pruning)Pattern 1 — Folders छोड़ना (Pruning)模式 1 — 跳过文件夹（剪枝）

os.walk decides where to go next by reading the same list object it gave you. Replace the contents of that list with dirnames[:] = … and the walk changes. Assign a brand-new list with dirnames = … and you only change your local variable — the walk never sees it.

os.walk आगे कहाँ जाना है, यह उसी list object को पढ़कर तय करता है जो उसने आपको दिया। dirnames[:] = … से उस list की सामग्री बदलें तो walk बदल जाता है। dirnames = … से नई list assign करें तो सिर्फ़ आपका local variable बदलता है — walk को कभी पता नहीं चलता।

os.walk 通过读取它交给你的 同一个列表对象 来决定下一步去哪里。用 dirnames[:] = … 替换列表内容，遍历就会改变。用 dirnames = … 赋一个新列表，只改变了你的局部变量 — 遍历根本看不到。

import os

skip = {".git", "__pycache__"}

print("--- WRONG: dirnames = [...] ---")
for dirpath, dirnames, filenames in os.walk("project"):
    dirnames.sort()
    dirnames = [d for d in dirnames if d not in skip]      # a new local list
    print(dirpath)

print("--- RIGHT: dirnames[:] = [...] ---")
for dirpath, dirnames, filenames in os.walk("project"):
    dirnames[:] = sorted(d for d in dirnames if d not in skip)   # same list, changed
    print(dirpath)

Pattern 2 — Find Files by TypePattern 2 — Type से Files खोजना模式 2 — 按类型查找文件

import os

py_files = []
for dirpath, dirnames, filenames in os.walk("project"):
    dirnames[:] = sorted(d for d in dirnames if d not in {".git", "__pycache__"})
    for f in sorted(filenames):
        if f.endswith(".py"):
            py_files.append(os.path.join(dirpath, f))   # join name + folder!

print(f"Found {len(py_files)} Python files:")
for p in py_files:
    print(" ", p)

Pattern 3 — Delete Bottom-Up with topdown=FalsePattern 3 — topdown=False से नीचे से ऊपर Delete模式 3 — 用 topdown=False 自底向上删除

import os

# topdown=False visits the DEEPEST folders first -
# you can only rmdir a folder after its children are gone
for dirpath, dirnames, filenames in os.walk("temp_data", topdown=False):
    for f in filenames:
        os.remove(os.path.join(dirpath, f))
        print("removed file  ", os.path.join(dirpath, f))
    os.rmdir(dirpath)
    print("removed folder", dirpath)

Pattern 4 — One Folder, Fast, with os.scandirPattern 4 — एक Folder, तेज़, os.scandir से模式 4 — 用 os.scandir 快速查看一个文件夹

os.scandir() returns DirEntry objects that already know their name, full path and type. Checking is_dir() usually costs no extra system call. os.walk itself is built on scandir.

os.scandir() DirEntry objects देता है जिन्हें अपना नाम, पूरा path और type पहले से पता होता है। is_dir() जाँचने में आमतौर पर कोई अतिरिक्त system call नहीं लगती। os.walk ख़ुद scandir पर बना है।

os.scandir() 返回 DirEntry 对象，它们已经知道自己的名字、完整路径和类型。检查 is_dir() 通常不需要额外的系统调用。os.walk 本身就构建在 scandir 之上。

import os

with os.scandir("project") as entries:
    for entry in sorted(entries, key=lambda e: e.name):
        kind = "folder" if entry.is_dir() else "file  "
        size = entry.stat().st_size if entry.is_file() else ""
        print(kind, entry.name, size)

Environment Variables ⚙️Environment Variables ⚙️环境变量 ⚙️

Environment variables are named text values that a program receives from whatever started it — your terminal, an IDE, Docker, or a cloud server. They are the standard place for settings that change between machines: ports, database URLs, API keys.

Environment variables नाम वाली text values हैं जो program को उसे शुरू करने वाले से मिलती हैं — आपका terminal, IDE, Docker, या cloud server। मशीन-दर-मशीन बदलने वाली settings के लिए यही मानक जगह है: ports, database URLs, API keys।

环境变量是带名字的文本值，程序从启动它的东西那里接收 — 你的终端、IDE、Docker 或云服务器。它们是存放随机器变化的设置的标准位置：端口、数据库 URL、API 密钥。

import os

home = os.environ["HOME"]                                   # KeyError if missing
db_url = os.getenv("DATABASE_URL", "sqlite:///dev.db")    # safe, with a default
port = os.getenv("PORT", "8080")
print(home, db_url)
print(repr(port), type(port).__name__)                     # always a string!
print(int(port) + 1)

os.environ["APP_MODE"] = "production"       # this process and its children only
os.environ["APP_REGION"] = "ap-south-1"
for key, value in sorted(os.environ.items()):
    if key.startswith("APP_"):
        print(f"{key}={value}")

try:
    os.environ["NO_SUCH_VAR"]
except KeyError as e:
    print("KeyError:", e)

Try It — Environment Labकरके देखें — Environment Lab动手试试 — 环境变量实验室

Set PORT and DEBUG the way a shell would, then see what config.py really prints. Every output here was recorded from Python with those exact variables set. Try DEBUG=0 and look at the last line.

PORT और DEBUG वैसे set करें जैसे shell करता है, फिर देखें config.py असल में क्या छापता है। यहाँ का हर output उन्हीं variables के साथ Python से रिकॉर्ड किया गया है। DEBUG=0 आज़माएँ और आख़िरी line देखें।

像 shell 那样设置 PORT 和 DEBUG，然后看 config.py 真正打印什么。这里每个输出都是在设置了这些变量后从 Python 录制的。试试 DEBUG=0，看最后一行。

Process and System Information 🖥️Process और System की जानकारी 🖥️进程与系统信息 🖥️

import os
import subprocess
import sys

print(os.name)                         # 'posix' on Linux/macOS, 'nt' on Windows
print(sys.platform)                    # 'linux', 'darwin', 'win32'
print(os.getpid() > 0)                 # this process's ID (changes every run)
print(os.cpu_count())                  # CPUs in the machine
print(os.process_cpu_count())          # CPUs THIS process may use (Python 3.13+)

# Run another program and capture its output
result = subprocess.run([sys.executable, "--version"], capture_output=True, text=True)
print(result.returncode, result.stdout.strip())

os.cpu_count() counts the CPUs in the machine. os.process_cpu_count() (new in Python 3.13) counts the CPUs this process is allowed to use — which can be fewer inside a container or with CPU limits. Use it to size a worker pool.

os.cpu_count() मशीन के CPUs गिनता है। os.process_cpu_count() (Python 3.13 में नया) वे CPUs गिनता है जिन्हें यह process इस्तेमाल कर सकता है — container में या CPU limits के साथ ये कम हो सकते हैं। Worker pool का आकार तय करने के लिए इसे इस्तेमाल करें।

os.cpu_count() 统计机器的 CPU 数。os.process_cpu_count()（Python 3.13 新增）统计 本进程被允许使用的 CPU 数 — 在容器中或有 CPU 限制时可能更少。用它来决定工作池大小。

Real-World Scripts 🛠️असली काम की Scripts 🛠️实战脚本 🛠️

Five small scripts that solve problems people really have. Each one was run on the practice folder, and the output shown is the real output.

पाँच छोटी scripts जो लोगों की असली समस्याएँ हल करती हैं। हर एक practice folder पर चलाई गई, और दिखाया गया output असली है।

五个解决真实问题的小脚本。每个都在练习文件夹上运行过，显示的输出都是真实输出。

1 · Count Files by Extension1 · Extension के हिसाब से Files गिनना1 · 按扩展名统计文件

import os
from collections import Counter

counts = Counter()
for dirpath, dirnames, filenames in os.walk("project"):
    dirnames[:] = [d for d in dirnames if d not in {".git", "__pycache__"}]
    for f in filenames:
        ext = os.path.splitext(f)[1].lower() or "(no ext)"
        counts[ext] += 1

for ext, n in counts.most_common():
    print(f"{ext:10s} {n}")

2 · Total Size of a Folder2 · Folder का कुल आकार2 · 文件夹总大小

import os

def folder_size(root):
    total = 0
    for dirpath, _, filenames in os.walk(root):
        for f in filenames:
            try:
                total += os.path.getsize(os.path.join(dirpath, f))
            except OSError:
                pass                 # broken link, no permission...
    return total

size = folder_size("project")
print(f"{size:,} bytes ({size / 1024:.2f} KB)")

3 · Bulk Rename with a Dry Run3 · Dry Run के साथ थोक में नाम बदलना3 · 带演练的批量重命名

import os

DRY_RUN = True          # look first, change later!

def rename_jpeg(root, dry_run):
    for dirpath, dirnames, filenames in os.walk(root):
        dirnames.sort()
        for f in sorted(filenames):
            if f.lower().endswith(".jpeg"):
                old = os.path.join(dirpath, f)
                new = os.path.join(dirpath, f[:-5] + ".jpg")
                print(("would rename " if dry_run else "renamed      ") + f"{old} -> {new}")
                if not dry_run:
                    os.rename(old, new)

rename_jpeg("photos", DRY_RUN)
rename_jpeg("photos", dry_run=False)
print(sorted(os.listdir("photos/trip")))

4 · Files Changed in the Last 24 Hours4 · पिछले 24 घंटों में बदली Files4 · 过去 24 小时内修改的文件

import os
import time

cutoff = time.time() - 24 * 60 * 60          # 24 hours ago

recent = []
for dirpath, _, filenames in os.walk("logs"):
    for f in filenames:
        path = os.path.join(dirpath, f)
        if os.path.getmtime(path) > cutoff:
            recent.append(path)

print(f"{len(recent)} file(s) changed in the last 24 hours:", sorted(recent))

Note: this checks the last 24 hours, not "since midnight". For "today", compare against datetime.combine(date.today(), time.min).timestamp().

ध्यान दें: यह पिछले 24 घंटे जाँचता है, "आधी रात से" नहीं। "आज" के लिए datetime.combine(date.today(), time.min).timestamp() से तुलना करें।

注意：这里检查的是过去 24 小时，不是"从午夜起"。要表示"今天"，请与 datetime.combine(date.today(), time.min).timestamp() 比较。

5 · Same File Name in Different Folders5 · अलग Folders में एक ही File नाम5 · 不同文件夹中的同名文件

import os
from collections import defaultdict

seen = defaultdict(list)
for dirpath, dirnames, filenames in os.walk("project"):
    dirnames.sort()
    for f in filenames:
        seen[f].append(os.path.join(dirpath, f))

for name, paths in sorted(seen.items()):
    if len(paths) > 1:
        print(f"{name} appears in:")
        for p in paths:
            print(f"  {p}")

The Modern Alternative — pathlib 🌟आधुनिक विकल्प — pathlib 🌟现代替代方案 — pathlib 🌟

pathlib (standard library since Python 3.4) wraps a path in an object. Instead of passing strings to many os.path functions, you ask the path itself. Most new code uses pathlib; os is still the tool for environment variables, processes and low-level work — and you will read os.path code for years.

pathlib (Python 3.4 से standard library में) path को एक object में लपेटता है। कई os.path functions को strings देने के बजाय, आप path से ही पूछते हैं। ज़्यादातर नया code pathlib इस्तेमाल करता है; environment variables, processes और low-level काम के लिए os अब भी औज़ार है — और os.path वाला code आप सालों तक पढ़ेंगे।

pathlib（自 Python 3.4 起属于标准库）把路径包装成对象。你不再把字符串传给一堆 os.path 函数，而是直接问路径本身。大多数新代码使用 pathlib；而环境变量、进程和底层操作仍要靠 os — 而且你还会读很多年的 os.path 代码。

from pathlib import Path

p = Path("/home/aarav/data/report.csv")
print(p.name, p.stem, p.suffix)
print(p.parent)

new_p = Path("/home/aarav") / "reports" / "2026" / "jan.csv"
print(new_p)

# rglob: every .py file below a folder - often simpler than os.walk
for py_file in sorted(Path("project").rglob("*.py")):
    print(py_file)

# Path.walk() (Python 3.12+) works like os.walk but gives Path objects
for dirpath, dirnames, filenames in Path("project/src").walk():
    dirnames.sort()
    print(dirpath, sorted(filenames))

Quick Reference 📋झटपट संदर्भ 📋速查表 📋

Common Pitfalls 🕳️आम ग़लतियाँ 🕳️常见陷阱 🕳️

Golden Rules and Quiz 🏆सुनहरे नियम और Quiz 🏆黄金法则与小测验 🏆

Quick Quiz — 8 Questionsछोटा Quiz — 8 सवाल小测验 — 8 道题