15 Python Automation Projects for Beginners: Step-by-Step Guide 2026

import shutil
from pathlib import Path

RULES = {
    "Images":    [".jpg",".jpeg",".png",".gif",".webp",".heic"],
    "Documents": [".pdf",".doc",".docx",".txt",".pages"],
    "Sheets":    [".xls",".xlsx",".csv",".numbers"],
    "Videos":    [".mp4",".mov",".avi",".mkv"],
    "Audio":     [".mp3",".wav",".flac",".aac"],
    "Archives":  [".zip",".rar",".tar",".gz"],
    "Code":      [".py",".js",".html",".css",".json"],
}

def organize(folder_path):
    folder = Path(folder_path)
    moved  = 0
    for file in folder.iterdir():
        if file.is_dir(): continue
        category = next(
            (k for k, exts in RULES.items() if file.suffix.lower() in exts),
            "Other"
        )
        dest = folder / category
        dest.mkdir(exist_ok=True)
        shutil.move(str(file), str(dest / file.name))
        print(f"  ✅ {file.name:<35} → {category}/")
        moved += 1
    print(f"\nDone. Moved {moved} files.")

# ▶ Change to your folder path and run
organize("/Users/yourname/Downloads")

🚀 How to extend it: Add scheduling with cron (Mac) or Task Scheduler (Windows) to run every morning automatically. Add a log file to record what was moved and when.

from pathlib import Path
import datetime

class BulkRenamer:
    def __init__(self, folder):
        self.folder = Path(folder)

    def add_number(self, pattern="*.jpg", prefix="photo"):
        """photo_0001.jpg, photo_0002.jpg ..."""
        for i, f in enumerate(sorted(self.folder.glob(pattern)), 1):
            f.rename(self.folder / f"{prefix}_{i:04d}{f.suffix}")
            print(f"  {f.name} → {prefix}_{i:04d}{f.suffix}")

    def add_date_prefix(self, pattern="*.pdf"):
        """2026-03-26_filename.pdf"""
        today = datetime.date.today().strftime("%Y-%m-%d")
        for f in self.folder.glob(pattern):
            if not f.name.startswith(today):
                new = self.folder / f"{today}_{f.name}"
                f.rename(new)
                print(f"  {f.name} → {new.name}")

    def replace_text(self, old, new, pattern="*"):
        """Replace text in all filenames matching pattern"""
        for f in self.folder.glob(pattern):
            if old in f.name:
                renamed = self.folder / f.name.replace(old, new)
                f.rename(renamed)
                print(f"  {f.name} → {renamed.name}")

# ▶ Usage examples
r = BulkRenamer("/Users/yourname/Photos")
r.add_number(pattern="*.jpg", prefix="vacation")
# r.add_date_prefix(pattern="*.pdf")
# r.replace_text("draft", "final")

import shutil, datetime
from pathlib import Path

SOURCE     = Path("/Users/yourname/Projects/my_project")
BACKUP_DIR = Path("/Users/yourname/Backups")
KEEP_LAST  = 7   # how many backups to keep

def backup():
    BACKUP_DIR.mkdir(exist_ok=True)
    stamp   = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M")
    archive = BACKUP_DIR / f"backup_{SOURCE.name}_{stamp}"
    shutil.make_archive(str(archive), "zip", str(SOURCE))
    print(f"✅ Backup created: {archive.name}.zip")
    cleanup()

def cleanup():
    backups = sorted(BACKUP_DIR.glob("backup_*.zip"), key=lambda f: f.stat().st_mtime)
    while len(backups) > KEEP_LAST:
        old = backups.pop(0)
        old.unlink()
        print(f"🗑️  Deleted old backup: {old.name}")

backup()

🚀 How to extend it: Schedule with cron: 0 22 * * * python3 backup.py — runs every night at 10 PM. Add email notification when backup completes.

import csv, smtplib, os, logging
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from dotenv import load_dotenv

load_dotenv()
logging.basicConfig(filename="newsletter.log", level=logging.INFO,
                    format="%(asctime)s %(message)s")

TEMPLATE = """Hi {name},

Welcome to this week's Python automation digest!

This week's tip: {tip}

Happy automating,
LearnForge Team"""

THIS_WEEK_TIP = "Use pathlib.Path instead of os.path — cleaner and cross-platform."

def send_newsletter(csv_file: str) -> None:
    sent = failed = 0
    with smtplib.SMTP("smtp.gmail.com", 587) as server:
        server.starttls()
        server.login(os.getenv("EMAIL_USER"), os.getenv("EMAIL_PASS"))

        with open(csv_file, encoding="utf-8") as f:
            for row in csv.DictReader(f):
                try:
                    msg = MIMEMultipart()
                    msg["From"]    = os.getenv("EMAIL_USER")
                    msg["To"]      = row["email"]
                    msg["Subject"] = "🐍 Python Tip of the Week"
                    body = TEMPLATE.format(name=row["name"], tip=THIS_WEEK_TIP)
                    msg.attach(MIMEText(body, "plain"))
                    server.send_message(msg)
                    logging.info(f"SENT: {row['email']}")
                    sent += 1
                except Exception as e:
                    logging.error(f"FAILED: {row['email']} — {e}")
                    failed += 1

    print(f"✅ Sent: {sent}  |  ❌ Failed: {failed}")

send_newsletter("subscribers.csv")
# subscribers.csv columns: name, email

# pip install requests beautifulsoup4 python-dotenv
import requests, re, time, smtplib, os
from bs4 import BeautifulSoup
from email.mime.text import MIMEText
from dotenv import load_dotenv

load_dotenv()

PRODUCT_URL  = "https://example-shop.com/laptop-stand"
TARGET_PRICE = 35.00
CHECK_EVERY  = 3600  # seconds
HEADERS      = {"User-Agent": "Mozilla/5.0"}

def scrape_price() -> float | None:
    try:
        soup = BeautifulSoup(requests.get(PRODUCT_URL, headers=HEADERS, timeout=10).text, "lxml")
        raw  = soup.select_one(".price, [data-price], .product-price")
        return float(re.sub(r"[^\d.]", "", raw.text)) if raw else None
    except Exception as e:
        print(f"Scrape error: {e}"); return None

def send_alert(current_price: float) -> None:
    msg = MIMEText(
        f"🎉 Price dropped!\n\nCurrent price: ${current_price:.2f}\nTarget: ${TARGET_PRICE:.2f}\n\n{PRODUCT_URL}"
    )
    msg["Subject"] = f"🔔 Price Alert: ${current_price:.2f}"
    msg["From"] = msg["To"] = os.getenv("EMAIL_USER")
    with smtplib.SMTP("smtp.gmail.com", 587) as s:
        s.starttls(); s.login(os.getenv("EMAIL_USER"), os.getenv("EMAIL_PASS"))
        s.send_message(msg)
    print("📧 Alert sent!")

print(f"👁️ Watching price for: {PRODUCT_URL}")
while True:
    price = scrape_price()
    if price:
        print(f"Current: ${price:.2f}  |  Target: ${TARGET_PRICE:.2f}")
        if price <= TARGET_PRICE:
            send_alert(price); break
    time.sleep(CHECK_EVERY)

# pip install requests beautifulsoup4 lxml
import requests, datetime
from bs4 import BeautifulSoup
from pathlib import Path

RSS_FEEDS = {
    "BBC World":  "http://feeds.bbci.co.uk/news/world/rss.xml",
    "CBC Canada": "https://www.cbc.ca/cmlink/rss-topstories",
}
MAX_ITEMS = 5   # headlines per feed

def fetch_feed(name: str, url: str) -> list[str]:
    soup  = BeautifulSoup(requests.get(url, timeout=10).text, "xml")
    items = soup.find_all("item")[:MAX_ITEMS]
    return [f"  • {i.title.text.strip()}" for i in items if i.title]

def build_digest() -> str:
    today  = datetime.date.today().strftime("%A, %B %d %Y")
    lines  = [f"📰 News Digest — {today}\n{'='*40}\n"]
    for name, url in RSS_FEEDS.items():
        lines.append(f"\n{name}:")
        lines.extend(fetch_feed(name, url))
    return "\n".join(lines)

digest = build_digest()
print(digest)

# Save to file
out = Path(f"digest_{datetime.date.today()}.txt")
out.write_text(digest, encoding="utf-8")
print(f"\n✅ Saved to {out.name}")

# pip install requests python-dotenv
# Free API: wttr.in (no key needed)
import requests, smtplib, os
from email.mime.text import MIMEText
from dotenv import load_dotenv

load_dotenv()
CITY = "Toronto"

def get_weather(city: str) -> dict:
    url  = f"https://wttr.in/{city}?format=j1"
    data = requests.get(url, timeout=10).json()
    curr = data["current_condition"][0]
    return {
        "temp_c":   curr["temp_C"],
        "feels":    curr["FeelsLikeC"],
        "desc":     curr["weatherDesc"][0]["value"],
        "humidity": curr["humidity"],
        "rain":     int(curr["precipMM"]) > 0,
    }

w    = get_weather(CITY)
tip  = "☂️ Take an umbrella!" if w["rain"] else "☀️ No rain expected."
body = f"""Good morning! Weather in {CITY}:

🌡️  Temperature: {w['temp_c']}°C (feels like {w['feels']}°C)
🌥️  Conditions:  {w['desc']}
💧  Humidity:   {w['humidity']}%

{tip}
"""
msg = MIMEText(body)
msg["Subject"] = f"☀️ Weather: {w['temp_c']}°C in {CITY}"
msg["From"] = msg["To"] = os.getenv("EMAIL_USER")

with smtplib.SMTP("smtp.gmail.com", 587) as s:
    s.starttls(); s.login(os.getenv("EMAIL_USER"), os.getenv("EMAIL_PASS"))
    s.send_message(msg)
print("✅ Weather email sent.")

# pip install pandas openpyxl
import pandas as pd
from openpyxl import load_workbook
from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
import datetime

# 1. Load and process data
df = pd.read_csv("sales.csv")   # columns: rep, region, product, revenue, units

summary = df.groupby("region").agg(
    total_revenue=("revenue", "sum"),
    total_units  =("units",   "sum"),
    avg_deal     =("revenue", "mean"),
    deals        =("revenue", "count"),
).reset_index().sort_values("total_revenue", ascending=False)

# 2. Write to Excel
today    = datetime.date.today().strftime("%Y-%m-%d")
filename = f"sales_report_{today}.xlsx"
summary.to_excel(filename, index=False, sheet_name="Sales Summary")

# 3. Style the report
wb = load_workbook(filename)
ws = wb.active
blue_fill = PatternFill("solid", fgColor="1E40AF")
thin      = Border(bottom=Side(style="thin", color="E5E7EB"))

for cell in ws[1]:
    cell.font      = Font(bold=True, color="FFFFFF", size=11)
    cell.fill      = blue_fill
    cell.alignment = Alignment(horizontal="center", vertical="center")
ws.row_dimensions[1].height = 24

for col in ws.columns:
    ws.column_dimensions[col[0].column_letter].width = (
        max(len(str(c.value or "")) for c in col) + 4
    )

wb.save(filename)
print(f"✅ Report saved: {filename}")

# pip install pypdf2
from PyPDF2 import PdfMerger, PdfReader, PdfWriter
from pathlib import Path
import sys

def merge_pdfs(folder: str, output: str = "merged.pdf") -> None:
    merger = PdfMerger()
    pdfs   = sorted(Path(folder).glob("*.pdf"))
    for pdf in pdfs:
        merger.append(str(pdf))
        print(f"  Added: {pdf.name}")
    merger.write(output)
    merger.close()
    print(f"✅ Merged {len(pdfs)} files → {output}")

def split_pdf(input_pdf: str, output_dir: str = "pages") -> None:
    reader   = PdfReader(input_pdf)
    out_dir  = Path(output_dir)
    out_dir.mkdir(exist_ok=True)
    stem     = Path(input_pdf).stem
    for i, page in enumerate(reader.pages):
        writer = PdfWriter()
        writer.add_page(page)
        out_file = out_dir / f"{stem}_page_{i+1:03d}.pdf"
        with open(out_file, "wb") as f:
            writer.write(f)
        print(f"  Page {i+1} → {out_file.name}")
    print(f"✅ Split into {len(reader.pages)} pages.")

# Usage:
merge_pdfs("/Users/yourname/Invoices")
# split_pdf("big_document.pdf")

import pandas as pd

def clean_csv(input_file: str, output_file: str) -> None:
    df = pd.read_csv(input_file)
    original_rows = len(df)
    report = []

    # Standardize column names
    df.columns = df.columns.str.strip().str.lower().str.replace(r"\s+", "_", regex=True)
    report.append(f"✅ Columns normalized: {list(df.columns)}")

    # Strip whitespace from strings
    str_cols = df.select_dtypes("object").columns
    df[str_cols] = df[str_cols].apply(lambda c: c.str.strip())

    # Standardize email to lowercase
    if "email" in df.columns:
        df["email"] = df["email"].str.lower()
        report.append("✅ Emails lowercased")

    # Remove duplicates
    before = len(df)
    df = df.drop_duplicates()
    removed = before - len(df)
    report.append(f"✅ Removed {removed} duplicate rows")

    # Drop rows where all values are null
    df = df.dropna(how="all")

    # Fill missing numeric values with 0
    num_cols = df.select_dtypes("number").columns
    df[num_cols] = df[num_cols].fillna(0)

    df.to_csv(output_file, index=False)
    print(f"\n📊 Clean Report — {input_file}")
    print(f"   Before: {original_rows} rows  |  After: {len(df)} rows")
    for r in report: print(f"   {r}")
    print(f"   ✅ Saved to: {output_file}")

clean_csv("raw_contacts.csv", "clean_contacts.csv")

import requests, smtplib, os, time, datetime
from email.mime.text import MIMEText
from dotenv import load_dotenv

load_dotenv()
SITES    = ["https://learnforge.dev", "https://yoursite.com"]
INTERVAL = 300   # 5 minutes
LOG_FILE = "uptime.log"
alerted  = set()  # avoid repeat alerts for same site

def log(msg):
    ts   = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    line = f"[{ts}] {msg}"
    print(line)
    with open(LOG_FILE, "a") as f: f.write(line + "\n")

def alert(url, error):
    if url in alerted: return
    alerted.add(url)
    msg = MIMEText(f"🚨 SITE DOWN\n\n{url}\nError: {error}")
    msg["Subject"] = f"🚨 Down: {url}"
    msg["From"] = msg["To"] = os.getenv("EMAIL_USER")
    with smtplib.SMTP("smtp.gmail.com", 587) as s:
        s.starttls(); s.login(os.getenv("EMAIL_USER"), os.getenv("EMAIL_PASS"))
        s.send_message(msg)

log("▶ Uptime monitor started.")
while True:
    for url in SITES:
        try:
            r = requests.get(url, timeout=10)
            if r.status_code < 400:
                log(f"✅ UP   {r.status_code}  {url}")
                alerted.discard(url)   # reset if back online
            else:
                log(f"❌ ERR  {r.status_code}  {url}")
                alert(url, f"HTTP {r.status_code}")
        except Exception as e:
            log(f"❌ DOWN  {url}  {e}")
            alert(url, str(e))
    time.sleep(INTERVAL)