Python Script to Organize Files Automatically: Step-by-Step Guide 2026

💡 The Python solution: Write the sorting rules once. Run the script whenever you want (or schedule it to run automatically). Your files end up exactly where they should be — every single time, in under 3 seconds.

python3 --version
# Should show: Python 3.6.x or higher

from pathlib import Path

# Point to a folder
folder = Path("/Users/yourname/Downloads")

# Point to a specific file
file = Path("/Users/yourname/Downloads/invoice_march.pdf")

# Get just the filename: "invoice_march.pdf"
print(file.name)

# Get just the extension: ".pdf"
print(file.suffix)

# Get the filename without extension: "invoice_march"
print(file.stem)

# List all files in a folder
for item in folder.iterdir():
    print(item.name)

# Check if it's a file (not a subfolder)
if file.is_file():
    print("It's a file")

# Build a path by joining parts (works on Windows AND Mac)
new_path = folder / "Images" / "photo.jpg"
print(new_path)  # /Users/yourname/Downloads/Images/photo.jpg

# Create a folder (ok if it already exists)
(folder / "Images").mkdir(exist_ok=True)

Key insight: The / operator in pathlib builds paths — it doesn't divide numbers. folder / "Images" creates the path Downloads/Images/. This works identically on Windows, Mac, and Linux.

First, create a dictionary that maps folder names to lists of file extensions. This is the "brain" of your organizer — edit it however you like.

# organizer.py — Step 1: define your rules

FILE_RULES = {
    "Images":       [".jpg", ".jpeg", ".png", ".gif", ".webp", ".heic", ".svg"],
    "Documents":    [".pdf", ".doc", ".docx", ".txt", ".odt", ".pages"],
    "Spreadsheets": [".xls", ".xlsx", ".csv", ".numbers", ".ods"],
    "Videos":       [".mp4", ".mov", ".avi", ".mkv", ".m4v", ".wmv"],
    "Audio":         [".mp3", ".wav", ".flac", ".aac", ".m4a"],
    "Archives":     [".zip", ".rar", ".tar", ".gz", ".7z"],
    "Code":          [".py", ".js", ".html", ".css", ".json", ".sql", ".sh"],
    "Installers":   [".dmg", ".pkg", ".exe", ".msi", ".deb"],
}
# Files not matching any rule → go to "Other"

Given a file extension, this function returns the correct destination folder name.

# organizer.py — Step 2: lookup function

def get_destination(extension: str) -> str:
    """Return folder name for a given file extension."""
    ext = extension.lower()  # ".JPG" → ".jpg"
    for folder_name, extensions in FILE_RULES.items():
        if ext in extensions:
            return folder_name
    return "Other"  # fallback for unknown types

# Quick test:
print(get_destination(".pdf"))   # → "Documents"
print(get_destination(".mp4"))   # → "Videos"
print(get_destination(".xyz"))   # → "Other"

Before moving any files, add a dry-run mode that only prints what would happen. This lets you verify the logic is correct before anything moves.

# organizer.py — Step 3: dry-run preview
from pathlib import Path

def preview_organization(folder_path: str) -> None:
    """Print what would happen — without moving anything."""
    folder = Path(folder_path)
    print(f"🔍 Preview for: {folder}\n")

    for file in sorted(folder.iterdir()):
        if file.is_dir():
            continue  # skip subfolders
        destination = get_destination(file.suffix)
        print(f"  {file.name:<40} →  {destination}/")

# Run preview first
preview_organization("/Users/yourname/Downloads")

Once the preview looks correct, add the actual move logic. We handle the case where two files have the same name to avoid overwriting:

# organizer.py — Step 4: move files
import shutil
from pathlib import Path

def organize_folder(folder_path: str) -> None:
    folder = Path(folder_path)
    moved = 0
    skipped = 0

    for file in folder.iterdir():
        if file.is_dir():
            continue

        # Find the destination folder
        dest_folder = folder / get_destination(file.suffix)
        dest_folder.mkdir(exist_ok=True)
        dest_file   = dest_folder / file.name

        # Handle name collision: add a counter suffix
        counter = 1
        while dest_file.exists():
            dest_file = dest_folder / f"{file.stem}_{counter}{file.suffix}"
            counter += 1

        shutil.move(str(file), str(dest_file))
        print(f"✅ Moved:    {file.name}  →  {dest_file.parent.name}/")
        moved += 1

    print(f"\nDone. Moved {moved} files. Skipped {skipped} subfolders.")

organize_folder("/Users/yourname/Downloads")

# Sort files into Year/Month subfolders based on last-modified date
import shutil, datetime
from pathlib import Path

def organize_by_date(folder_path: str) -> None:
    folder = Path(folder_path)
    moved  = 0

    for file in folder.iterdir():
        if file.is_dir():
            continue

        # Read the file's last-modified timestamp
        mtime      = datetime.datetime.fromtimestamp(file.stat().st_mtime)
        year_dir   = folder / str(mtime.year)
        month_dir  = year_dir / mtime.strftime("%m-%B")  # "03-March"
        month_dir.mkdir(parents=True, exist_ok=True)

        dest = month_dir / file.name
        counter = 1
        while dest.exists():
            dest = month_dir / f"{file.stem}_{counter}{file.suffix}"
            counter += 1

        shutil.move(str(file), str(dest))
        print(f"📅 {file.name}  →  {mtime.year}/{mtime.strftime('%m-%B')}/")
        moved += 1

    print(f"\n✅ Sorted {moved} files by date.")

organize_by_date("/Users/yourname/Photos/Unsorted")

import shutil, datetime
from pathlib import Path

def archive_old_files(
    folder_path: str,
    archive_path: str,
    days_old: int = 30,
    dry_run: bool = True       # set to False to actually move
) -> None:
    folder  = Path(folder_path)
    archive = Path(archive_path)
    archive.mkdir(parents=True, exist_ok=True)

    cutoff = datetime.datetime.now() - datetime.timedelta(days=days_old)
    moved  = 0

    for file in folder.iterdir():
        if file.is_dir():
            continue

        last_modified = datetime.datetime.fromtimestamp(file.stat().st_mtime)

        if last_modified < cutoff:
            action = f"Would archive" if dry_run else "Archived"
            print(f"{action}: {file.name}  (last modified: {last_modified.date()})")

            if not dry_run:
                shutil.move(str(file), str(archive / file.name))
            moved += 1

    label = "Would move" if dry_run else "Moved"
    print(f"\n{label} {moved} files older than {days_old} days.")
    if dry_run:
        print("  → Run with dry_run=False to execute.")

# Preview first (safe)
archive_old_files(
    folder_path  = "/Users/yourname/Downloads",
    archive_path = "/Users/yourname/Downloads/_Archive",
    days_old     = 30,
    dry_run      = True   # change to False when ready
)

⚠️ Always keep dry_run=True the first time you run it. Read the output carefully. Only switch to False once you are certain the right files are being targeted.

#!/usr/bin/env python3
"""
organizer.py — Auto File Organizer
Usage:
  python3 organizer.py /path/to/folder           # sort by type (dry run)
  python3 organizer.py /path/to/folder --run      # sort by type (execute)
  python3 organizer.py /path/to/folder --by-date  # sort by date (dry run)
"""
import sys
import shutil
import datetime
from pathlib import Path

FILE_RULES = {
    "Images":       [".jpg", ".jpeg", ".png", ".gif", ".webp", ".heic", ".svg"],
    "Documents":    [".pdf", ".doc", ".docx", ".txt", ".odt", ".pages"],
    "Spreadsheets": [".xls", ".xlsx", ".csv", ".numbers", ".ods"],
    "Videos":       [".mp4", ".mov", ".avi", ".mkv", ".m4v"],
    "Audio":         [".mp3", ".wav", ".flac", ".aac", ".m4a"],
    "Archives":     [".zip", ".rar", ".tar", ".gz", ".7z"],
    "Code":          [".py", ".js", ".html", ".css", ".json", ".sql"],
    "Installers":   [".dmg", ".pkg", ".exe", ".msi"],
}

def get_destination(extension: str) -> str:
    ext = extension.lower()
    for folder_name, exts in FILE_RULES.items():
        if ext in exts:
            return folder_name
    return "Other"

def safe_move(src: Path, dest_folder: Path) -> Path:
    """Move file; auto-rename if destination already exists."""
    dest = dest_folder / src.name
    counter = 1
    while dest.exists():
        dest = dest_folder / f"{src.stem}_{counter}{src.suffix}"
        counter += 1
    shutil.move(str(src), str(dest))
    return dest

def organize_by_type(folder: Path, dry_run: bool = True) -> None:
    moved = 0
    for file in sorted(folder.iterdir()):
        if file.is_dir():
            continue
        dest_folder = folder / get_destination(file.suffix)
        if dry_run:
            print(f"  [DRY RUN] {file.name:<40} →  {dest_folder.name}/")
        else:
            dest_folder.mkdir(exist_ok=True)
            result = safe_move(file, dest_folder)
            print(f"  ✅ {file.name:<40} →  {result.parent.name}/")
        moved += 1
    label = "Would move" if dry_run else "Moved"
    print(f"\n{label} {moved} file(s).")
    if dry_run:
        print("  Add --run to execute.")

def organize_by_date(folder: Path, dry_run: bool = True) -> None:
    moved = 0
    for file in sorted(folder.iterdir()):
        if file.is_dir():
            continue
        mtime      = datetime.datetime.fromtimestamp(file.stat().st_mtime)
        month_dir  = folder / str(mtime.year) / mtime.strftime("%m-%B")
        if dry_run:
            print(f"  [DRY RUN] {file.name:<40} →  {mtime.year}/{mtime.strftime('%m-%B')}/")
        else:
            month_dir.mkdir(parents=True, exist_ok=True)
            safe_move(file, month_dir)
            print(f"  📅 {file.name:<40} →  {mtime.year}/{mtime.strftime('%m-%B')}/")
        moved += 1
    label = "Would move" if dry_run else "Moved"
    print(f"\n{label} {moved} file(s).")

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: python3 organizer.py /path/to/folder [--run] [--by-date]")
        sys.exit(1)

    target   = Path(sys.argv[1])
    execute  = "--run" in sys.argv
    by_date  = "--by-date" in sys.argv

    if not target.is_dir():
        print(f"Error: '{target}' is not a valid folder.")
        sys.exit(1)

    mode = "DATE" if by_date else "TYPE"
    run  = "LIVE" if execute else "DRY RUN"
    print(f"📂 Organizing: {target}")
    print(f"   Mode: {mode}  |  {run}\n")

    if by_date:
        organize_by_date(target, dry_run=not execute)
    else:
        organize_by_type(target, dry_run=not execute)

# Preview (safe — nothing moves)
python3 organizer.py ~/Downloads

# Execute — sort by type
python3 organizer.py ~/Downloads --run

# Execute — sort by date
python3 organizer.py ~/Downloads --run --by-date