# Full signature
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None)

# Mode examples
f = open("data.txt",  "r")   # read text (default)
f = open("data.txt",  "w")   # write text  -  WARNING: destroys existing content!
f = open("data.txt",  "a")   # append text
f = open("data.txt",  "x")   # create new, fail if exists  -  safe write
f = open("image.png", "rb")  # read binary
f = open("data.bin",  "wb")  # write binary

# NEVER do this in real code
f = open("data.txt", "r")
content = f.read()
f.close()   # What if read() raised an exception? close() is never called.

# ALWAYS do this
with open("data.txt", "r") as f:
    content = f.read()
# f.close() is called automatically, even if an exception occurred inside the block

# Multiple files at once  -  single with statement
with open("input.txt", "r") as src, open("output.txt", "w") as dst:
    for line in src:
        dst.write(line.upper())
# Both files are closed when the block exits

# 1. read()  -  entire file as one string
with open("story.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(type(content))   # <class 'str'>
    print(len(content))    # total character count

# 2. read(n)  -  read exactly n characters
with open("story.txt", "r", encoding="utf-8") as f:
    first_100 = f.read(100)     # first 100 characters
    next_100  = f.read(100)     # next 100 characters

# 3. readline()  -  one line at a time
with open("data.txt", "r", encoding="utf-8") as f:
    first_line  = f.readline()   # includes the '\n'
    second_line = f.readline()
    print(repr(first_line))      # 'Hello, World!\n'

# 4. readlines()  -  all lines as a list
with open("data.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()
    print(lines)   # ['line 1\n', 'line 2\n', 'line 3\n']

# 5. Iterating directly  -  most Pythonic and memory-efficient
with open("data.txt", "r", encoding="utf-8") as f:
    for line in f:                      # file object is its own iterator
        print(line.rstrip('\n'))        # strip trailing newline

# 6. List comprehension over file
with open("data.txt", "r", encoding="utf-8") as f:
    lines = [line.strip() for line in f if line.strip()]  # non-empty lines only

# 1. write(string)  -  write a string, returns number of characters written
with open("output.txt", "w", encoding="utf-8") as f:
    chars_written = f.write("Hello, Hyderabad!\n")
    print(chars_written)   # 18

# 2. writelines(iterable)  -  write each item; no newlines added automatically
lines = ["line 1\n", "line 2\n", "line 3\n"]
with open("output.txt", "w", encoding="utf-8") as f:
    f.writelines(lines)    # does NOT add '\n' between items  -  include it yourself

# 3. print() to a file  -  convenient for formatted output
with open("report.txt", "w", encoding="utf-8") as f:
    print("Sales Report", file=f)
    print("=" * 40, file=f)
    print(f"Total: Rs.{15000:,}", file=f)

# 4. Appending  -  never overwrites, always adds at end
with open("log.txt", "a", encoding="utf-8") as f:
    f.write("2024-01-15 10:32:00  -  User logged in\n")

with open("data.txt", "r", encoding="utf-8") as f:
    # tell() returns the current byte position
    print(f.tell())          # 0  -  at the start

    first = f.read(10)       # read 10 characters
    print(f.tell())          # 10 (for ASCII; could be more for multi-byte chars)

    # seek(offset, whence=0)
    # whence=0: from start of file (default)
    # whence=1: from current position
    # whence=2: from end of file

    f.seek(0)                # go back to the beginning
    everything = f.read()    # now reads the full file again

    f.seek(0, 2)             # seek to end of file
    size = f.tell()          # file size in bytes
    print(f"File size: {size} bytes")

    f.seek(-10, 2)           # 10 bytes before the end
    last_10 = f.read()       # last 10 bytes

# RISKY  -  uses the system's default encoding (varies by OS and locale)
with open("data.txt", "r") as f:
    content = f.read()
# Works on your Linux machine (UTF-8 default), fails on Windows (cp1252 default)

# SAFE  -  explicit is always better
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()

# Writing with explicit encoding
with open("output.txt", "w", encoding="utf-8") as f:
    f.write("नमस्कार दुनिया\n")   # Hindi text  -  requires UTF-8

# errors parameter controls what happens on a bad byte

# 'strict' (default)  -  raises UnicodeDecodeError on bad byte
with open("file.txt", "r", encoding="utf-8", errors="strict") as f:
    content = f.read()

# 'ignore'  -  silently skips bad bytes (data loss, but no crash)
with open("file.txt", "r", encoding="utf-8", errors="ignore") as f:
    content = f.read()

# 'replace'  -  replaces bad bytes with the replacement char (U+FFFD: '?')
with open("file.txt", "r", encoding="utf-8", errors="replace") as f:
    content = f.read()

# 'backslashreplace'  -  replaces bad bytes with \xNN escape sequences
with open("file.txt", "r", encoding="utf-8", errors="backslashreplace") as f:
    content = f.read()

# Detecting encoding when you don't know it
# pip install chardet
import chardet

with open("mystery_file.txt", "rb") as f:
    raw = f.read(10000)                      # sample first 10 KB
    result = chardet.detect(raw)
    detected = result["encoding"]
    confidence = result["confidence"]
    print(f"Detected: {detected} ({confidence:.0%} confidence)")

with open("mystery_file.txt", "r", encoding=detected) as f:
    content = f.read()

# MEMORY-EFFICIENT: iterate over the file object directly
# Only one line is in memory at a time  -  works for files of any size

def count_lines(filepath):
    count = 0
    with open(filepath, "r", encoding="utf-8") as f:
        for _ in f:
            count += 1
    return count

def grep(filepath, search_term):
    """Yield lines containing search_term."""
    with open(filepath, "r", encoding="utf-8") as f:
        for line_num, line in enumerate(f, start=1):
            if search_term in line:
                yield line_num, line.rstrip("\n")

# Usage
for num, line in grep("server.log", "ERROR"):
    print(f"Line {num}: {line}")


# MEMORY-EXPENSIVE: only use when you need all lines at once
with open("small_file.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()   # loads entire file into a list

# BETTER alternative to readlines()  -  list comprehension strips newlines too
with open("small_file.txt", "r", encoding="utf-8") as f:
    lines = [line.rstrip("\n") for line in f]

import datetime

def write_report(filepath, data):
    """Write a formatted report to a text file."""
    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    with open(filepath, "w", encoding="utf-8") as f:
        f.write(f"Report generated: {timestamp}\n")
        f.write("=" * 60 + "\n\n")

        for section_title, rows in data.items():
            f.write(f"{section_title}\n")
            f.write("-" * len(section_title) + "\n")
            for row in rows:
                f.write(f"  {row}\n")
            f.write("\n")

data = {
    "Top Scorers": ["Virat Kohli: 520 runs", "Rohit Sharma: 480 runs"],
    "Top Wicket Takers": ["Jasprit Bumrah: 22 wickets", "R Ashwin: 18 wickets"],
}
write_report("ipl_report.txt", data)


# Append-only logging
def log_event(logfile, level, message):
    """Append a timestamped log entry."""
    timestamp = datetime.datetime.now().isoformat()
    with open(logfile, "a", encoding="utf-8") as f:
        f.write(f"{timestamp} [{level.upper()}] {message}\n")

log_event("app.log", "INFO",    "Server started on port 8000")
log_event("app.log", "WARNING", "Memory usage above 80%")
log_event("app.log", "ERROR",   "Database connection refused")

import os
import tempfile

def safe_write(filepath, content):
    """
    Write content to filepath safely:
    1. Write to a temp file in the same directory
    2. Rename temp → target (atomic on most systems)
    This ensures the target file is never partially written.
    """
    directory = os.path.dirname(os.path.abspath(filepath))
    with tempfile.NamedTemporaryFile(
        mode="w",
        encoding="utf-8",
        dir=directory,
        delete=False,
        suffix=".tmp"
    ) as tmp:
        tmp.write(content)
        tmp_path = tmp.name

    os.replace(tmp_path, filepath)   # atomic on POSIX; near-atomic on Windows
    print(f"Written safely to {filepath}")

safe_write("config.txt", "host=localhost\nport=5432\n")

import csv

# Basic reading
with open("players.csv", "r", encoding="utf-8", newline="") as f:
    reader = csv.reader(f)
    header = next(reader)      # skip the header row
    print("Columns:", header)
    for row in reader:
        print(row)             # each row is a list of strings

# DictReader  -  rows as dicts (column names as keys)
with open("players.csv", "r", encoding="utf-8", newline="") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(dict(row))
        # {'name': 'Rohit Sharma', 'team': 'MI', 'runs': '1200', 'avg': '48.5'}

import csv

players = [
    ["name",         "team", "runs", "wickets"],
    ["Rohit Sharma", "MI",   1200,    0],
    ["Virat Kohli",  "RCB",   980,    0],
    ["Jasprit Bumrah","MI",     45,   28],
]

with open("output.csv", "w", encoding="utf-8", newline="") as f:
    writer = csv.writer(f)
    writer.writerows(players)    # writerow() for one row, writerows() for many

# DictWriter  -  write from dicts
fieldnames = ["name", "team", "runs", "wickets"]
records = [
    {"name": "Rohit Sharma",  "team": "MI",  "runs": 1200, "wickets": 0},
    {"name": "Virat Kohli",   "team": "RCB", "runs": 980,  "wickets": 0},
    {"name": "Jasprit Bumrah","team": "MI",  "runs": 45,   "wickets": 28},
]

with open("players_dict.csv", "w", encoding="utf-8", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=fieldnames)
    writer.writeheader()      # writes the column header row
    writer.writerows(records)

import csv

# Custom delimiter (TSV, pipe-separated, etc.)
with open("data.tsv", "r", encoding="utf-8", newline="") as f:
    reader = csv.reader(f, delimiter="\t")   # tab-separated
    for row in reader:
        print(row)

# Quoting  -  fields with commas or newlines are automatically quoted
with open("tricky.csv", "w", encoding="utf-8", newline="") as f:
    writer = csv.writer(f, quoting=csv.QUOTE_MINIMAL)   # default
    writer.writerow(["name", "address", "notes"])
    writer.writerow(["Ravi", "123, MG Road, Bangalore", "Has a comma in address"])
    # Output: Ravi,"123, MG Road, Bangalore",Has a comma in address

# Skipping blank lines and comments
with open("dirty.csv", "r", encoding="utf-8", newline="") as f:
    reader = csv.reader(f)
    cleaned = [
        row for row in reader
        if row and not row[0].startswith("#")   # skip empty and comment rows
    ]

# Excel-exported CSVs often have UTF-8-BOM encoding
with open("excel_export.csv", "r", encoding="utf-8-sig", newline="") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(row)   # column names won't have a BOM prefix

# Type conversion  -  CSV values are always strings; convert explicitly
with open("stats.csv", "r", encoding="utf-8", newline="") as f:
    reader = csv.DictReader(f)
    for row in reader:
        name   = row["name"]
        runs   = int(row["runs"])       # explicit conversion
        avg    = float(row["average"])
        active = row["active"].lower() == "true"

import csv
from collections import defaultdict

def summarize_csv(filepath):
    """
    Read a large CSV and compute per-team totals
    without loading the whole file into memory.
    """
    team_runs = defaultdict(int)

    with open(filepath, "r", encoding="utf-8", newline="") as f:
        reader = csv.DictReader(f)
        for row in reader:
            team = row["team"]
            runs = int(row["runs"])
            team_runs[team] += runs

    return dict(sorted(team_runs.items(), key=lambda x: -x[1]))

# Each row is processed and discarded  -  constant memory usage regardless of file size

import json

# Write a Python object to JSON
data = {
    "tournament": "IPL 2024",
    "teams": ["MI", "CSK", "RCB", "KKR", "SRH"],
    "matches": 74,
    "champion": "KKR",
    "stats": {
        "highest_score": 287,
        "total_sixes": 1234,
    },
}

with open("ipl2024.json", "w", encoding="utf-8") as f:
    json.dump(data, f, indent=4, ensure_ascii=False)
    # indent=4 → pretty-printed with 4-space indentation
    # ensure_ascii=False → allows non-ASCII characters (Hindi, etc.) as-is

# Read a JSON file back
with open("ipl2024.json", "r", encoding="utf-8") as f:
    loaded = json.load(f)
    print(loaded["champion"])         # KKR
    print(loaded["stats"]["total_sixes"])  # 1234

# JSON serialization (to string) vs deserialization (from string)
json_string = json.dumps(data, indent=2)  # dumps → to string
print(json_string[:80])

back_to_dict = json.loads(json_string)    # loads → from string

import json
import datetime
from decimal import Decimal
from pathlib import Path

# By default, datetime, Decimal, and Path objects are not JSON-serializable
data = {
    "name": "Rohit Sharma",
    "dob": datetime.date(1987, 4, 30),   # ← not serializable
    "salary": Decimal("15000000.50"),     # ← not serializable
}

# json.dumps(data)  →  TypeError!

# Solution 1: Custom default function
def json_serializer(obj):
    if isinstance(obj, (datetime.date, datetime.datetime)):
        return obj.isoformat()
    if isinstance(obj, Decimal):
        return float(obj)
    if isinstance(obj, Path):
        return str(obj)
    raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")

json_string = json.dumps(data, default=json_serializer, indent=2)
print(json_string)

# Solution 2: Custom JSONEncoder subclass (better for repeated use)
class AppJSONEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, (datetime.date, datetime.datetime)):
            return obj.isoformat()
        if isinstance(obj, Decimal):
            return str(obj)   # str preserves precision; float may lose it
        if isinstance(obj, set):
            return sorted(list(obj))
        return super().default(obj)

with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, cls=AppJSONEncoder, indent=2)

import json

# Writing JSONL  -  append records one by one
records = [
    {"id": 1, "player": "Rohit Sharma",  "score": 89},
    {"id": 2, "player": "Virat Kohli",   "score": 112},
    {"id": 3, "player": "MS Dhoni",      "score": 67},
]

with open("scores.jsonl", "w", encoding="utf-8") as f:
    for record in records:
        f.write(json.dumps(record) + "\n")   # one JSON object per line

# Reading JSONL  -  lazy, memory-efficient
def read_jsonl(filepath):
    with open(filepath, "r", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if line:                         # skip blank lines
                yield json.loads(line)

for record in read_jsonl("scores.jsonl"):
    print(record)
# {'id': 1, 'player': 'Rohit Sharma', 'score': 89}
# ...

# Copy a binary file
def copy_file(src_path, dst_path, chunk_size=65536):
    """Copy a file in binary chunks  -  works for files of any size."""
    with open(src_path, "rb") as src, open(dst_path, "wb") as dst:
        while True:
            chunk = src.read(chunk_size)
            if not chunk:              # empty bytes = end of file
                break
            dst.write(chunk)

copy_file("photo.jpg", "photo_backup.jpg")

# Get file size without loading content
import os
size_bytes = os.path.getsize("photo.jpg")
print(f"File size: {size_bytes:,} bytes ({size_bytes / 1024 / 1024:.2f} MB)")

# Read the first few bytes  -  magic bytes for file type detection
def detect_file_type(filepath):
    """Detect file type by reading magic bytes."""
    signatures = {
        b'\xff\xd8\xff':           'JPEG image',
        b'\x89PNG\r\n\x1a\n':     'PNG image',
        b'%PDF':                   'PDF document',
        b'PK\x03\x04':            'ZIP archive',
        b'\x1f\x8b':              'GZIP compressed',
        b'RIFF':                   'RIFF file (WAV/AVI)',
    }
    with open(filepath, "rb") as f:
        header = f.read(8)
    for signature, file_type in signatures.items():
        if header.startswith(signature):
            return file_type
    return "Unknown file type"

print(detect_file_type("report.pdf"))   # PDF document
print(detect_file_type("photo.jpg"))    # JPEG image

import struct

# Write structured binary data (a simple binary format)
# Format: name (20 chars), score (int), average (float)
players = [
    ("Rohit Sharma",  1200, 48.50),
    ("Virat Kohli",    980, 52.10),
    ("Jasprit Bumrah",  45,  9.00),
]

record_format = "20s i f"   # 20-char string, int (4 bytes), float (4 bytes)
record_size = struct.calcsize(record_format)   # = 28 bytes

with open("players.bin", "wb") as f:
    for name, runs, avg in players:
        packed = struct.pack(record_format, name.encode("utf-8").ljust(20), runs, avg)
        f.write(packed)

# Read it back
with open("players.bin", "rb") as f:
    while True:
        data = f.read(record_size)
        if not data:
            break
        name_bytes, runs, avg = struct.unpack(record_format, data)
        name = name_bytes.decode("utf-8").rstrip("\x00")
        print(f"{name}: {runs} runs, avg {avg:.2f}")

# config.ini
# [database]
# host = localhost
# port = 5432
# name = myapp_db
# pool_size = 10
#
# [server]
# host = 0.0.0.0
# port = 8000
# debug = true
# allowed_origins = http://localhost:3000,https://myapp.com

import configparser

config = configparser.ConfigParser()
config.read("config.ini", encoding="utf-8")

# Access values  -  always returns strings
db_host = config["database"]["host"]
db_port = config.getint("database", "port")          # parse as int
pool    = config.getint("database", "pool_size")
debug   = config.getboolean("server", "debug")       # 'true'/'false' → bool
origins = config["server"]["allowed_origins"].split(",")

print(f"Database: {db_host}:{db_port}/{config['database']['name']}")
print(f"Debug mode: {debug}")

# Safe access with fallback
log_level = config.get("logging", "level", fallback="INFO")

# Writing a config file
config2 = configparser.ConfigParser()
config2["database"] = {
    "host": "prod-db.example.com",
    "port": "5432",
    "name": "production",
    "pool_size": "20",
}
config2["server"] = {
    "host": "0.0.0.0",
    "port": "8000",
    "debug": "false",
}

with open("prod_config.ini", "w", encoding="utf-8") as f:
    config2.write(f)

from pathlib import Path

# Create a Path object  -  works on Windows, Mac, and Linux
p = Path("data/reports/ipl2024.csv")

# Path components
print(p.name)        # 'ipl2024.csv'        ← filename with extension
print(p.stem)        # 'ipl2024'            ← filename without extension
print(p.suffix)      # '.csv'               ← extension
print(p.suffixes)    # ['.csv']             ← all extensions
print(p.parent)      # data/reports         ← parent directory
print(p.parents[0])  # data/reports
print(p.parents[1])  # data
print(p.parts)       # ('data', 'reports', 'ipl2024.csv')

# Build paths with / operator  -  works cross-platform
base    = Path("data")
reports = base / "reports"
file    = reports / "ipl2024.csv"
print(file)          # data/reports/ipl2024.csv

# Absolute path
print(Path.cwd())    # current working directory
print(file.resolve())# fully resolved absolute path

from pathlib import Path

p = Path("data/reports/ipl2024.csv")

# Checking
print(p.exists())         # True/False  -  does it exist?
print(p.is_file())        # True if it's a regular file
print(p.is_dir())         # True if it's a directory
print(p.is_absolute())    # True if path is absolute

# Create directories
Path("data/reports").mkdir(parents=True, exist_ok=True)
# parents=True  → creates intermediate directories (like mkdir -p)
# exist_ok=True → no error if directory already exists

# Create a file
Path("data/notes.txt").touch()   # create empty file, or update mtime if exists

# Delete
Path("data/temp.txt").unlink()                  # delete a file
Path("data/temp.txt").unlink(missing_ok=True)   # no error if doesn't exist (3.8+)
Path("data/empty_dir").rmdir()                  # delete empty directory

# Rename / move
p.rename("data/reports/ipl2024_backup.csv")
p.replace("data/archive/ipl2024.csv")   # replace() works even if destination exists

from pathlib import Path

project = Path("my_project")

# List immediate children
for item in project.iterdir():
    kind = "DIR " if item.is_dir() else "FILE"
    print(f"{kind}  {item.name}")

# Find files matching a pattern  -  one level deep
for csv_file in project.glob("*.csv"):
    print(csv_file)

# Recursive search  -  all levels
for py_file in project.rglob("*.py"):
    print(py_file)

# Find all Python files, skip hidden directories and __pycache__
py_files = [
    f for f in project.rglob("*.py")
    if "__pycache__" not in f.parts
    and not any(part.startswith(".") for part in f.parts)
]

# Get file metadata
p = Path("data.csv")
stat = p.stat()
print(f"Size:     {stat.st_size:,} bytes")
print(f"Modified: {datetime.datetime.fromtimestamp(stat.st_mtime)}")
print(f"Created:  {datetime.datetime.fromtimestamp(stat.st_ctime)}")

from pathlib import Path

p = Path("notes.txt")

# Write and read text
p.write_text("Hello, Python!\nSecond line.\n", encoding="utf-8")
content = p.read_text(encoding="utf-8")
print(content)

# Write and read bytes
p_bin = Path("data.bin")
p_bin.write_bytes(b"\x00\x01\x02\x03")
data = p_bin.read_bytes()
print(data)   # b'\x00\x01\x02\x03'

# For more control (large files, line-by-line), use open() as before
with p.open("r", encoding="utf-8") as f:
    for line in f:
        print(line.rstrip())

import os
from pathlib import Path

filepath = "data/reports/ipl2024.csv"

# --- String-based (old way) ---
dirname  = os.path.dirname(filepath)              # 'data/reports'
basename = os.path.basename(filepath)             # 'ipl2024.csv'
stem, ext = os.path.splitext(basename)            # ('ipl2024', '.csv')
joined   = os.path.join("data", "reports", "f")  # 'data/reports/f'
exists   = os.path.exists(filepath)
abspath  = os.path.abspath(filepath)

# --- pathlib (new way) ---
p = Path(filepath)
dirname  = p.parent                               # Path('data/reports')
basename = p.name                                 # 'ipl2024.csv'
stem     = p.stem                                 # 'ipl2024'
ext      = p.suffix                               # '.csv'
joined   = Path("data") / "reports" / "f"        # Path('data/reports/f')
exists   = p.exists()
abspath  = p.resolve()

import os
import shutil
from pathlib import Path

# --- File operations ---
os.rename("old.txt", "new.txt")            # rename (same filesystem)
os.replace("src.txt", "dst.txt")           # rename, overwriting dst if it exists
os.remove("unwanted.txt")                  # delete a file

# shutil for copying
shutil.copy("src.txt", "dst.txt")          # copy file (no metadata)
shutil.copy2("src.txt", "dst.txt")         # copy file + metadata (timestamps)
shutil.copyfileobj(src_file, dst_file)     # copy between open file objects

# --- Directory operations ---
os.mkdir("new_dir")                         # create one directory
os.makedirs("a/b/c", exist_ok=True)        # create full path
os.rmdir("empty_dir")                      # delete empty directory
shutil.rmtree("full_dir")                  # delete directory and all contents (careful!)

# --- Move ---
shutil.move("src_path", "dst_path")        # move file or directory

# --- Disk usage ---
total, used, free = shutil.disk_usage("/")
print(f"Total: {total // (2**30):.1f} GB")
print(f"Used:  {used  // (2**30):.1f} GB")
print(f"Free:  {free  // (2**30):.1f} GB")

# --- Environment and current directory ---
print(os.getcwd())                          # current working directory
os.chdir("/tmp")                            # change directory
print(os.environ.get("HOME", "unknown"))   # environment variables

import tempfile
import os

# Temporary file  -  deleted when closed
with tempfile.NamedTemporaryFile(mode="w", suffix=".csv",
                                  encoding="utf-8", delete=True) as tmp:
    tmp.write("name,score\nRavi,95\n")
    print(f"Temp file: {tmp.name}")
    # File is accessible here by name

# Temporary directory  -  deleted when the context exits
with tempfile.TemporaryDirectory() as tmpdir:
    tmpdir_path = Path(tmpdir)
    output_file = tmpdir_path / "results.json"
    output_file.write_text('{"status": "ok"}', encoding="utf-8")
    # Process files...
# tmpdir and all its contents are deleted here

# Persistent temp file (you manage deletion)
fd, path = tempfile.mkstemp(suffix=".txt")
os.close(fd)    # close the low-level file descriptor
with open(path, "w", encoding="utf-8") as f:
    f.write("temporary content")
# ... use the file ...
os.unlink(path)   # you must delete it manually

# BAD  -  if an exception occurs, the file is never closed
f = open("data.txt", "r")
content = f.read()
process(content)    # raises an exception!
f.close()           # never reached → file descriptor leaked

# GOOD  -  with guarantees closure
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()
    process(content)

# CATASTROPHIC  -  'w' truncates the file immediately on open
with open("important_data.csv", "w") as f:
    # The file is NOW EMPTY, even before you write anything!
    f.write(new_data)

# SAFE  -  if the file might exist, use 'a' or 'x' depending on intent
with open("log.csv", "a") as f:     # append, never destroys
    f.write(new_row)

with open("new_file.csv", "x") as f:  # fails if file already exists
    f.write(data)

# BAD  -  breaks on values containing commas
line = 'Ravi,"123, MG Road, Bangalore",Hyderabad'
parts = line.split(",")    # WRONG: gives 4 parts instead of 3

# GOOD  -  use the csv module which handles quoting correctly
import csv
import io
reader = csv.reader(io.StringIO(line))
parts = next(reader)   # ['Ravi', '123, MG Road, Bangalore', 'Hyderabad']

# BAD  -  works on your machine, breaks elsewhere
with open("hindi_content.txt", "r") as f:
    content = f.read()   # might raise UnicodeDecodeError on different systems

# GOOD  -  always explicit
with open("hindi_content.txt", "r", encoding="utf-8") as f:
    content = f.read()

# BAD  -  loads a 5 GB log file into a single list
with open("huge.log", "r", encoding="utf-8") as f:
    lines = f.readlines()   # 5 GB in RAM!

# GOOD  -  process one line at a time
with open("huge.log", "r", encoding="utf-8") as f:
    for line in f:
        process(line)       # constant memory, any file size

# BUG  -  second read returns empty string
with open("data.txt", "r", encoding="utf-8") as f:
    first_read  = f.read()   # reads all content, pointer at end
    second_read = f.read()   # returns ''  -  pointer is at end!
    print(bool(second_read)) # False

# FIX  -  seek back to the start
with open("data.txt", "r", encoding="utf-8") as f:
    first_read = f.read()
    f.seek(0)                # reset pointer to beginning
    second_read = f.read()   # reads full content again
    print(first_read == second_read)  # True

import os
from pathlib import Path

# BAD  -  breaks on Windows ('\' vs '/')
path = base_dir + "/" + subdir + "/" + filename

# ALSO BAD  -  verbose and error-prone
path = os.path.join(base_dir, subdir, filename)

# GOOD  -  use pathlib
path = Path(base_dir) / subdir / filename

import csv

# BAD  -  on Windows, Python's universal newline translation
# + csv's own newline handling can create blank rows in output
with open("data.csv", "w") as f:
    writer = csv.writer(f)
    writer.writerow(["a", "b"])

# GOOD  -  always use newline="" with csv module
with open("data.csv", "w", encoding="utf-8", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["a", "b"])

import json
import configparser
from pathlib import Path

def load_config(config_path):
    """
    Load configuration from JSON or INI file.
    Returns a plain dict in either case.
    """
    p = Path(config_path)
    if not p.exists():
        raise FileNotFoundError(f"Config file not found: {p}")

    if p.suffix == ".json":
        with p.open("r", encoding="utf-8") as f:
            return json.load(f)

    elif p.suffix in (".ini", ".cfg"):
        config = configparser.ConfigParser()
        config.read(p, encoding="utf-8")
        return {
            section: dict(config[section])
            for section in config.sections()
        }

    else:
        raise ValueError(f"Unsupported config format: {p.suffix}")

# Usage
config = load_config("app.json")
db_host = config["database"]["host"]

from pathlib import Path
from itertools import islice

def read_in_batches(filepath, batch_size=1000):
    """Yield batches of `batch_size` lines from a file."""
    with open(filepath, "r", encoding="utf-8") as f:
        while True:
            batch = list(islice(f, batch_size))
            if not batch:
                break
            yield [line.rstrip("\n") for line in batch]


def process_large_log(filepath):
    """Count error occurrences by error code in a large log file."""
    from collections import Counter
    error_counts = Counter()

    for batch in read_in_batches(filepath, batch_size=500):
        for line in batch:
            if "ERROR" in line:
                # Parse error code from line like: "2024-01-15 [ERROR] E1234 message"
                parts = line.split()
                if len(parts) >= 3:
                    error_counts[parts[2]] += 1

    return error_counts.most_common(10)

import shutil
from pathlib import Path

def organize_downloads(source_dir, target_dir):
    """
    Move files from source_dir to categorized subdirectories in target_dir
    based on file extension.
    """
    CATEGORIES = {
        "Images":    {".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg"},
        "Documents": {".pdf", ".docx", ".doc", ".txt", ".md", ".xlsx"},
        "Data":      {".csv", ".json", ".xml", ".parquet", ".sql"},
        "Code":      {".py", ".js", ".ts", ".html", ".css", ".sh"},
        "Archives":  {".zip", ".tar", ".gz", ".rar", ".7z"},
    }

    source = Path(source_dir)
    target = Path(target_dir)
    moved  = 0

    for file in source.iterdir():
        if not file.is_file():
            continue

        category = "Other"
        for cat_name, extensions in CATEGORIES.items():
            if file.suffix.lower() in extensions:
                category = cat_name
                break

        dest_dir = target / category
        dest_dir.mkdir(parents=True, exist_ok=True)
        shutil.move(str(file), dest_dir / file.name)
        moved += 1
        print(f"  {file.name} → {category}/")

    print(f"\nOrganized {moved} files.")

organize_downloads("~/Downloads", "~/Downloads/Organized")

import time
import os
from pathlib import Path

def watch_file(filepath, poll_interval=1.0):
    """
    Generator that yields the file content whenever it changes.
    Useful for watching log files or config reloads.
    """
    p = Path(filepath)
    last_mtime = None

    while True:
        try:
            current_mtime = p.stat().st_mtime
            if current_mtime != last_mtime:
                last_mtime = current_mtime
                yield p.read_text(encoding="utf-8")
        except FileNotFoundError:
            pass   # file may not exist yet
        time.sleep(poll_interval)

# Usage (in a separate thread or async context)
# for content in watch_file("app.log"):
#     process_new_content(content)

import re
from collections import Counter
from pathlib import Path

def word_frequency(input_path, output_path, top_n=10):
    # Read and clean
    text = Path(input_path).read_text(encoding="utf-8").lower()
    words = re.findall(r"\b[a-z]+\b", text)   # only alphabetic words
    counts = Counter(words)

    # Write top N
    with open(output_path, "w", encoding="utf-8") as f:
        f.write(f"Top {top_n} words\n")
        f.write("-" * 25 + "\n")
        for word, count in counts.most_common(top_n):
            f.write(f"{word:<20} {count:>5}\n")

word_frequency("novel.txt", "word_freq.txt", top_n=10)

import csv

def filter_and_grade(input_csv, output_csv, min_avg=40.0):
    results = []

    with open(input_csv, "r", encoding="utf-8", newline="") as f:
        reader = csv.DictReader(f)
        for row in reader:
            avg = float(row["average"])
            if avg > min_avg:
                row["grade"] = "A" if avg > 50 else "B"
                results.append(row)

    results.sort(key=lambda r: float(r["average"]), reverse=True)

    if not results:
        print("No qualifying players.")
        return

    fieldnames = list(results[0].keys())
    with open(output_csv, "w", encoding="utf-8", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(results)

    print(f"Wrote {len(results)} players to {output_csv}")

filter_and_grade("players.csv", "top_players.csv")

import json
from pathlib import Path

def merge_configs(defaults_path, overrides_path, output_path):
    def load_json_safe(path):
        p = Path(path)
        if not p.exists():
            print(f"File not found: {path}, using empty dict")
            return {}
        with p.open("r", encoding="utf-8") as f:
            return json.load(f)

    defaults  = load_json_safe(defaults_path)
    overrides = load_json_safe(overrides_path)

    # Deep merge: overrides take precedence, nested dicts are merged recursively
    def deep_merge(base, override):
        result = base.copy()
        for key, value in override.items():
            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
                result[key] = deep_merge(result[key], value)
            else:
                result[key] = value
        return result

    merged = deep_merge(defaults, overrides)

    with open(output_path, "w", encoding="utf-8") as f:
        json.dump(merged, f, indent=2, ensure_ascii=False)

    print(f"Merged config written to {output_path}")

merge_configs("defaults.json", "overrides.json", "final.json")

import re
from collections import Counter
from pathlib import Path

LOG_PATTERN = re.compile(
    r"(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) \[(\w+)\] (.+)"
)

def analyze_logs(log_path, error_output_path):
    level_counts = Counter()
    error_lines  = []

    with open(log_path, "r", encoding="utf-8") as f:
        for line_num, line in enumerate(f, start=1):
            match = LOG_PATTERN.match(line.strip())
            if match:
                timestamp, level, message = match.groups()
                level_counts[level] += 1
                if level == "ERROR":
                    error_lines.append(line.strip())
            else:
                print(f"  Unparseable line {line_num}: {line[:60]!r}")

    # Summary
    print("\nLog Summary")
    print("=" * 30)
    total = sum(level_counts.values())
    for level, count in sorted(level_counts.items()):
        pct = count / total * 100
        print(f"  {level:<10} {count:>5} ({pct:5.1f}%)")
    print(f"  {'TOTAL':<10} {total:>5}")

    # Write errors
    if error_lines:
        with open(error_output_path, "w", encoding="utf-8") as f:
            f.write(f"# {len(error_lines)} ERROR entries\n\n")
            f.write("\n".join(error_lines) + "\n")
        print(f"\nWrote {len(error_lines)} errors to {error_output_path}")

analyze_logs("app.log", "errors_only.log")