Python Automation for Beginners: Free Course with Hands-On Projects

Use this reliability checklist

• Sample first: test on copied data in a separate folder.
• Preserve the source: write a new output file unless in-place editing is essential.
• Dry run: preview changes before applying them.
• No silent overwrite: stop, version, or rename when the destination exists.
• Idempotency: running the tool twice should not duplicate work or corrupt output.
• Validate boundaries: check required columns, allowed extensions, date formats, and destination paths.
• Handle expected errors: report a locked file differently from a programming bug.
• Log decisions: record what was accepted, rejected, moved, or skipped.
• Keep secrets outside code: read tokens from environment variables or an approved secret store.
• Least privilege: give the script access only to the folder or account it needs.

A small automated test

Save this as test_clean_contacts.py beside clean_contacts.py:

import unittest

from clean_contacts import looks_like_email, normalize_city, normalize_email


class ContactCleanerTests(unittest.TestCase):
    def test_email_is_normalized(self):
        self.assertEqual(normalize_email("  USER@Example.COM "), "user@example.com")

    def test_obvious_bad_email_is_rejected(self):
        self.assertFalse(looks_like_email("not-an-email"))

    def test_city_spacing_is_cleaned(self):
        self.assertEqual(normalize_city("  islamabad  "), "Islamabad")


if __name__ == "__main__":
    unittest.main()

Run the tests:

python -m unittest -v

Three tests do not make the cleaner perfect. They protect three decisions from being accidentally changed later. Add tests when you discover a real edge case.

Final project: build an expense-report automation

The final project turns a raw CSV export into two outputs: a clean rejected-row log and a category summary. It demonstrates file handling, CSV validation, functions, logging, command-line arguments, and safe output behavior.

Project specification

The input CSV must have four columns:

date,description,category,amount
2026-08-01,Domain renewal,Software,14.99
2026-08-02,Client meeting,Travel,8.50
bad-date,Unknown purchase,Other,12.00
2026-08-03,Refund,Software,-5.00

The tool should:

1. accept the input path from the command line;
2. validate the required headers;
3. validate ISO-format dates and decimal amounts;
4. reject blank descriptions or categories;
5. calculate totals by category;
6. write expense_summary.csv and expense_rejected.csv;
7. refuse to overwrite output unless the user passes --force; and
8. log a count of accepted and rejected rows.

Save this as expense_report.py:

from collections import defaultdict
from datetime import date
from decimal import Decimal, InvalidOperation
from pathlib import Path
import argparse
import csv
import logging

SUMMARY_FILE = Path("expense_summary.csv")
REJECTED_FILE = Path("expense_rejected.csv")
REQUIRED_COLUMNS = {"date", "description", "category", "amount"}

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


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Create a category expense report from CSV.")
    parser.add_argument("input", type=Path, help="Source expense CSV")
    parser.add_argument("--force", action="store_true", help="Overwrite existing outputs")
    return parser.parse_args()


def validate_row(row: dict[str, str], row_number: int) -> tuple[dict | None, dict | None]:
    cleaned = {key: (value or "").strip() for key, value in row.items()}

    try:
        parsed_date = date.fromisoformat(cleaned["date"])
    except ValueError:
        return None, {**cleaned, "row_number": row_number, "reason": "invalid date"}

    try:
        amount = Decimal(cleaned["amount"])
    except InvalidOperation:
        return None, {**cleaned, "row_number": row_number, "reason": "invalid amount"}

    if not cleaned["description"]:
        return None, {**cleaned, "row_number": row_number, "reason": "missing description"}

    if not cleaned["category"]:
        return None, {**cleaned, "row_number": row_number, "reason": "missing category"}

    return {
        "date": parsed_date.isoformat(),
        "description": cleaned["description"],
        "category": cleaned["category"].title(),
        "amount": amount,
    }, None


def read_expenses(input_file: Path) -> tuple[list[dict], list[dict]]:
    accepted = []
    rejected = []

    with input_file.open("r", encoding="utf-8-sig", newline="") as source:
        reader = csv.DictReader(source)
        headers = set(reader.fieldnames or [])

        if not REQUIRED_COLUMNS.issubset(headers):
            missing = sorted(REQUIRED_COLUMNS - headers)
            raise ValueError(f"Missing required columns: {missing}")

        for row_number, row in enumerate(reader, start=2):
            good, bad = validate_row(row, row_number)
            if good:
                accepted.append(good)
            if bad:
                rejected.append(bad)

    return accepted, rejected


def ensure_outputs_are_safe(force: bool) -> None:
    existing = [path for path in (SUMMARY_FILE, REJECTED_FILE) if path.exists()]
    if existing and not force:
        names = ", ".join(path.name for path in existing)
        raise FileExistsError(f"Output exists: {names}. Use --force to replace it.")


def write_summary(expenses: list[dict]) -> None:
    totals = defaultdict(Decimal)
    for expense in expenses:
        totals[expense["category"]] += expense["amount"]

    with SUMMARY_FILE.open("w", encoding="utf-8", newline="") as destination:
        writer = csv.DictWriter(destination, fieldnames=["category", "total"])
        writer.writeheader()
        for category in sorted(totals):
            writer.writerow({"category": category, "total": f"{totals[category]:.2f}"})


def write_rejected(rows: list[dict]) -> None:
    fields = ["date", "description", "category", "amount", "row_number", "reason"]
    with REJECTED_FILE.open("w", encoding="utf-8", newline="") as destination:
        writer = csv.DictWriter(destination, fieldnames=fields)
        writer.writeheader()
        writer.writerows(rows)


def main() -> None:
    args = parse_args()

    if not args.input.is_file():
        raise FileNotFoundError(f"Input file not found: {args.input}")

    ensure_outputs_are_safe(args.force)
    accepted, rejected = read_expenses(args.input)
    write_summary(accepted)
    write_rejected(rejected)

    logging.info("Accepted rows: %s; rejected rows: %s", len(accepted), len(rejected))
    print(f"Accepted rows: {len(accepted)}")
    print(f"Rejected rows: {len(rejected)}")
    print(f"Summary: {SUMMARY_FILE.resolve()}")
    print(f"Rejected rows: {REJECTED_FILE.resolve()}")


if __name__ == "__main__":
    main()

Run it:

python expense_report.py expenses.csv

If you have checked the old output and intend to replace it:

python expense_report.py expenses.csv --force

Final-project acceptance test

Do not call the project finished until all of these are true:

• A valid four-row sample produces the expected category totals.
• An invalid date goes to the rejected file with its source row number.
• An invalid amount does not crash the whole run.
• A missing required column stops before writing output.
• Existing output is preserved unless --force is present.
• Negative amounts are handled according to the rule you document.
• The README explains the input columns, command, outputs, and limitations.

Schedule a script only after it is observable

Scheduling is the last step, not the first. An unattended script needs a fixed working directory, absolute input paths, logs, safe output behavior, and a clear failure signal.

On Windows, Task Scheduler can start the Python executable and pass the full script path as an argument. On Linux and many Unix-like systems, cron can run a command on a schedule. Test the exact command manually from the same account before scheduling it.

A scheduled automation that silently fails is worse than a manual checklist because people stop looking for the missing work.

Build a portfolio that proves the skill

A portfolio entry needs more than a screenshot of code. Show the problem and the evidence that your program handles it.

For each project, include:

• a short problem statement;
• sample input containing no real personal or client data;
• the rules and known limitations;
• the command needed to run it;
• sample output;
• a safety note describing dry runs, backups, and overwrite behavior;
• tests or an acceptance checklist; and
• a two-minute screen recording if it makes the workflow easier to understand.

A sensible repository layout looks like this:

expense-report-automation/
├── README.md
├── expense_report.py
├── sample_data/
│   └── expenses.csv
├── sample_output/
│   ├── expense_summary.csv
│   └── expense_rejected.csv
└── tests/
    └── test_expense_report.py

Never publish client data, credentials, private URLs, production logs, or a client's code without written permission.

Realistic ways this skill can become paid work

Python automation can support paid work, but learning the syntax does not guarantee income. Clients pay for a reliable result attached to a business problem.

How to scope a small automation job

1. Ask for a redacted sample input before quoting the work.
2. Write the rules in plain language and get agreement on ambiguous cases.
3. Define the output files and what happens to rejected records.
4. State what the script will not do.
5. Deliver a dry run or test result before touching live data.
6. Include setup instructions and a short support boundary.

If you are in Pakistan and need to understand practical payment options for international freelance work, MetaCyberGuru's guide to how Pakistani freelancers get paid by international clients covers the payment side separately.

Common mistakes that slow beginners down

• Automating a vague process: if humans disagree on the rule, the code cannot resolve it by magic.
• Using the real folder first: a test copy is cheaper than file recovery.
• Hiding rejected data: skipped records need a reason and a path back to review.
• Copying code without changing it: change the sample input, add a rule, and explain the output in your own words.
• Adding packages too early: first learn what Python already provides; add a dependency when it makes the solution meaningfully clearer.
• Putting secrets in the script: source code gets copied, shared, and committed.
• Scheduling before logging: unattended code must leave evidence.
• Selling “Python” instead of an outcome: a client understands “clean these exports every Friday” more easily than “I write Python scripts.”

Knowledge check

1. Why is --apply safer than a --dry-run option?
2. What is the difference between validating an email's shape and proving that the mailbox exists?
3. Why should network requests have a timeout?
4. What makes an automation idempotent?
5. Which information should never appear in logs?
6. What evidence would make a CSV-cleaning portfolio project credible?

Frequently asked questions about Python automation

Do I need to know Python before starting?

No. Lesson 0 starts with installation and a first script. You will progress faster if you type and change each example instead of only copying it.

Is this Python automation course completely free?

Yes. The lessons, sample code, project files, exercises, and reference links are free. The course does not require a paid Python package or AI subscription.

Which Python version should I use?

Install Python 3.14 if you are starting now. The examples require Python 3.10 or newer, and the downloadable bundle was tested with Python 3.11.5.

How long does the course take?

Plan for roughly 20–30 focused hours if you complete the exercises and final project. Your time will vary according to your existing command-line and programming experience.

Does the course include a certificate?

No. MetaCyberGuru does not currently issue a certificate for this course. The portfolio projects, README files, tests, and sample outputs are the evidence you can show.

Which Python automation projects will I build?

You will build a file organizer, CSV contact cleaner, public API report, reusable command-line tool, tests, and a final expense-report automation.

Can I use the projects in my portfolio?

Yes. Change the sample data, add at least one useful feature, document your decisions, and explain the limitations. Never upload client data or credentials.

What to learn next

Do not jump straight from file scripts to a large AI system. Choose the next layer based on the work you want to do:

• More reliable scripts: learn deeper testing, type hints, packaging, and Git.
• Business data: learn SQL, spreadsheet formats, and data analysis.
• Web services: continue with the Full-Stack Development for Beginners course to connect a browser, JSON API and database.
• AI tool integrations: continue with MetaCyberGuru's Model Context Protocol guide for Python tools.
• Market automation: first study risk and failure handling in the Python trading-bot safety guide. Automation does not remove financial risk.

Free official reference desk

• The Python Tutorial
• Virtual Environments and Packages
• pathlib documentation
• shutil documentation
• csv documentation
• argparse documentation
• logging documentation
• unittest documentation
• GitHub REST API: getting started

Python fundamentals change slowly, while API behavior and tooling change faster. This course should be reviewed every six months and whenever Python enters a new stable feature series or GitHub changes the API behavior used by the project.