קורס אוטומציה פייתון מעשי: 5 סקריפטים קטנים שחוסכים שעות למפתחים

from pathlib import Path
import argparse
import shutil

def organize(folder: Path, apply: bool) -> None:
    if not folder.exists():
        raise FileNotFoundError(f"Folder not found: {folder}")

    for item in folder.iterdir():
        if not item.is_file():
            continue

        suffix = item.suffix.lower().lstrip(".") or "no-extension"
        target_dir = folder / suffix
        target_file = target_dir / item.name

        print(f"{item.name} -> {suffix}/{item.name}")

        if apply:
            target_dir.mkdir(exist_ok=True)
            shutil.move(str(item), str(target_file))

def create_demo(folder: Path) -> None:
    folder.mkdir(exist_ok=True)
    for name in ["notes.txt", "invoice.pdf", "photo.png", "README"]:
        (folder / name).write_text("demo\n", encoding="utf-8")

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("folder", nargs="?", default="demo_downloads")
    parser.add_argument("--apply", action="store_true")
    args = parser.parse_args()

    path = Path(args.folder)
    if args.folder == "demo_downloads" and not path.exists():
        create_demo(path)

    organize(path, args.apply)

notes.txt -> txt/notes.txt
invoice.pdf -> pdf/invoice.pdf
photo.png -> png/photo.png
README -> no-extension/README

from pathlib import Path
import argparse

def rename_files(folder: Path, prefix: str, apply: bool) -> None:
    files = sorted([p for p in folder.iterdir() if p.is_file()])

    for index, file_path in enumerate(files, start=1):
        new_name = f"{prefix}_{index:03d}{file_path.suffix.lower()}"
        new_path = folder / new_name

        print(f"{file_path.name} -> {new_name}")

        if apply and file_path != new_path:
            file_path.rename(new_path)

def create_demo(folder: Path) -> None:
    folder.mkdir(exist_ok=True)
    for name in ["Screen Shot.PNG", "report.PDF", "todo.TXT"]:
        (folder / name).write_text("demo\n", encoding="utf-8")

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("folder", nargs="?", default="demo_rename")
    parser.add_argument("--prefix", default="file")
    parser.add_argument("--apply", action="store_true")
    args = parser.parse_args()

    path = Path(args.folder)
    if args.folder == "demo_rename" and not path.exists():
        create_demo(path)

    rename_files(path, args.prefix, args.apply)

Screen Shot.PNG -> doc_001.png
report.PDF -> doc_002.pdf
todo.TXT -> doc_003.txt

from pathlib import Path
import re
import argparse

LOG_PATTERN = re.compile(r"^\[(?P<time>\d{2}:\d{2}:\d{2})\] (?P<level>ERROR|WARNING): (?P<message>.+)$")

def create_demo(path: Path) -> None:
    path.write_text(
        "[09:00:01] INFO: Service started\n"
        "[09:01:15] WARNING: Disk space is low\n"
        "[09:02:30] ERROR: Failed to open report.csv\n",
        encoding="utf-8"
    )

def scan_log(path: Path) -> None:
    counts = {"ERROR": 0, "WARNING": 0}

    for line in path.read_text(encoding="utf-8").splitlines():
        match = LOG_PATTERN.search(line)
        if not match:
            continue

        level = match.group("level")
        counts[level] += 1
        print(f"{match.group('time')} {level}: {match.group('message')}")

    print(f"Summary: ERROR={counts['ERROR']}, WARNING={counts['WARNING']}")

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("logfile", nargs="?", default="demo.log")
    args = parser.parse_args()

    log_path = Path(args.logfile)
    if args.logfile == "demo.log" and not log_path.exists():
        create_demo(log_path)

    scan_log(log_path)

09:01:15 WARNING: Disk space is low
09:02:30 ERROR: Failed to open report.csv
Summary: ERROR=1, WARNING=1

import csv
import sqlite3
from pathlib import Path

CSV_PATH = Path("tasks.csv")
DB_PATH = Path("tasks.db")

def create_csv() -> None:
    rows = [
        {"title": "Clean downloads", "owner": "Dana"},
        {"title": "Check logs", "owner": ""},
        {"title": "Create backup", "owner": "Ari"},
    ]

    with CSV_PATH.open("w", newline="", encoding="utf-8") as file:
        writer = csv.DictWriter(file, fieldnames=["title", "owner"])
        writer.writeheader()
        writer.writerows(rows)

def load_to_db() -> None:
    connection = sqlite3.connect(DB_PATH)
    try:
        connection.execute("DROP TABLE IF EXISTS tasks")
        connection.execute("CREATE TABLE tasks (title TEXT NOT NULL, owner TEXT)")

        with CSV_PATH.open(newline="", encoding="utf-8") as file:
            reader = csv.DictReader(file)
            for row in reader:
                owner = row["owner"] or None
                connection.execute(
                    "INSERT INTO tasks (title, owner) VALUES (?, ?)",
                    (row["title"], owner)
                )

        connection.commit()

        for title, owner in connection.execute(
            "SELECT title, COALESCE(owner, 'Unassigned') FROM tasks ORDER BY title"
        ):
            print(f"{title}: {owner}")
    finally:
        connection.close()

if __name__ == "__main__":
    create_csv()
    load_to_db()

Check logs: Unassigned
Clean downloads: Dana
Create backup: Ari

from pathlib import Path
from zipfile import ZipFile, ZIP_DEFLATED
from datetime import datetime
import argparse

def create_demo(folder: Path) -> None:
    folder.mkdir(exist_ok=True)
    (folder / "notes.txt").write_text("Important notes\n", encoding="utf-8")
    (folder / "config.txt").write_text("demo=true\n", encoding="utf-8")

def backup_folder(folder: Path, output_dir: Path) -> Path:
    output_dir.mkdir(exist_ok=True)
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    zip_path = output_dir / f"{folder.name}_{timestamp}.zip"

    with ZipFile(zip_path, "w", ZIP_DEFLATED) as archive:
        for path in folder.rglob("*"):
            if path.is_file():
                archive.write(path, path.relative_to(folder))

    return zip_path

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("folder", nargs="?", default="demo_backup")
    parser.add_argument("--out", default="backups")
    args = parser.parse_args()

    source = Path(args.folder)
    if args.folder == "demo_backup" and not source.exists():
        create_demo(source)

    result = backup_folder(source, Path(args.out))
    print(f"Created backup: {result}")