LEARN COMPLETE PYTHON IN 24 HOURS

15. Mini Advanced Projects & Best Practices

15.1 CLI Tool with argparse / click

argparse (built-in) vs click (modern & beautiful)

Recommended in 2026: Use click — cleaner syntax, better help messages, colors, progress bars.

Install

Bash

pip install click

Example: File stats CLI tool

Python

# file_stats.py import click from pathlib import Path import os @click.command() @click.argument("path", type=click.Path(exists=True), default=".") @click.option("--size", "-s", is_flag=True, help="Show file sizes") @click.option("--count", "-c", is_flag=True, help="Count files") def stats(path, size, count): """Show statistics about files in a directory.""" p = Path(path) files = list(p.rglob("*")) if count: click.echo(f"Total files: {len(files)}") if size: total_size = sum(f.stat().st_size for f in files if f.is_file()) click.echo(f"Total size: {total_size / 1024 / 1024:.2f} MB") if not (size or count): click.echo("Use --size or --count option (or both)") if name == "__main__": stats()

Run examples

Bash

python file_stats.py . --size --count python file_stats.py downloads/ -s -c python file_stats.py --help

Improvement ideas: Add subcommands (@click.group), progress bar (click.progressbar), output to JSON/CSV

15.2 Async Web Scraper

Goal: Scrape multiple pages concurrently with asyncio + aiohttp + BeautifulSoup

Install

Bash

pip install aiohttp beautifulsoup4

Code

Python

import asyncio import aiohttp from bs4 import BeautifulSoup from urllib.parse import urljoin async def fetch(session, url): async with session.get(url, timeout=10) as response: return await response.text() async def scrape_page(session, url): html = await fetch(session, url) soup = BeautifulSoup(html, "lxml") title = soup.title.string.strip() if soup.title else "No title" links = [urljoin(url, a["href"]) for a in soup.find_all("a", href=True)] return {"url": url, "title": title, "link_count": len(links)} async def main(start_url): async with aiohttp.ClientSession() as session: tasks = [scrape_page(session, start_url)] results = await asyncio.gather(*tasks, return_exceptions=True) for result in results: if isinstance(result, Exception): print(f"Error: {result}") else: print(f"URL: {result['url']}") print(f"Title: {result['title']}") print(f"Links found: {result['link_count']}\n") if name == "__main__": asyncio.run(main("https://example.com"))

Improvements:

• Add recursive crawling with depth limit

• Save results to JSON/CSV

• Handle rate limiting & retries (aiohttp_retry)

• Use asyncio.Semaphore to limit concurrent requests

15.3 Custom Decorator-based Logger

Goal: Create a decorator that logs function calls with arguments, return value, and execution time.

Python

import time import logging from functools import wraps logging.basicConfig( level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s", datefmt="%Y-%m-%d %H:%M:%S" ) def log_execution(func): @wraps(func) def wrapper(*args, **kwargs): start = time.perf_counter() func_name = func.__name__ arg_str = ", ".join([f"{a!r}" for a in args] + [f"{k}={v!r}" for k, v in kwargs.items()]) logging.info(f"Calling {func_name}({arg_str})") try: result = func(*args, **kwargs) elapsed = time.perf_counter() - start logging.info(f"{func_name} returned {result!r} in {elapsed:.4f}s") return result except Exception as e: elapsed = time.perf_counter() - start logging.error(f"{func_name} raised {type(e).__name__}: {e} in {elapsed:.4f}s") raise return wrapper # Usage @log_execution def divide(a, b): return a / b divide(10, 2) # success # divide(10, 0) # logs error

Output example:

text

2026-03-05 17:12:45 [INFO] Calling divide(10, 2) 2026-03-05 17:12:45 [INFO] divide returned 5.0 in 0.0001s

Improvements: Add file logging, log level control, custom format, async support

15.4 Thread-Safe Counter Class

Goal: Create a thread-safe counter using locks.

Python

import threading class ThreadSafeCounter: def init(self, initial=0): self._value = initial self._lock = threading.Lock() def increment(self, step=1): with self._lock: self._value += step return self._value def decrement(self, step=1): with self._lock: self._value -= step return self._value @property def value(self): with self._lock: return self._value # Usage with threads counter = ThreadSafeCounter() def worker(): for in range(100000): counter.increment() threads = [threading.Thread(target=worker) for _ in range(10)] for t in threads: t.start() for t in threads: t.join() print("Final count:", counter.value) # Exactly 1,000,000

Alternative (Python 3.9+): Use threading.atomic or queue.Queue for simpler cases.

15.5 Data Pipeline with Generators

Goal: Build memory-efficient ETL pipeline using generators.

Python

def read_lines(filename): """Generator: read file line by line""" with open(filename, "r", encoding="utf-8") as f: for line in f: yield line.strip() def filter_errors(lines): """Filter only ERROR lines""" for line in lines: if "ERROR" in line.upper(): yield line def parse_log(line): """Parse log line (simplified)""" parts = line.split(" - ") if len(parts) >= 2: return {"timestamp": parts[0], "message": parts[1]} return {"raw": line} def process_pipeline(filename): raw = read_lines(filename) errors = filter_errors(raw) parsed = (parse_log(line) for line in errors) for item in parsed: yield item # Usage for entry in process_pipeline("server.log"): print(entry)

Advantages: Processes one line at a time → works with huge files Improvements: Add yield from, error handling, save to database/JSON

15.6 PEP 8, PEP 257, Documentation & Git Workflow

PEP 8 – Style Guide (must follow)

• 4 spaces indentation

• Line length: 88–100 chars (Black default)

• Snake_case for variables/functions

• CamelCase for classes

• Spaces around operators: a = b + c

• Import order: standard → third-party → local

Tools to enforce:

Bash

pip install black isort flake8 mypy black . # format isort . # sort imports flake8 . # lint mypy . # type check

PEP 257 – Docstrings

Python

def calculate_area(radius: float) -> float: """Calculate area of a circle. Args: radius: Radius of the circle (must be positive). Returns: Area in square units. Raises: ValueError: If radius is negative. """ if radius < 0: raise ValueError("Radius cannot be negative") return 3.14159 radius * 2

Git Workflow (recommended for solo/team)

1. git clone repo

2. git checkout -b feature/add-login

3. Work → commit often (git commit -m "Add login endpoint")

4. git push origin feature/add-login

5. Create Pull Request on GitHub/GitLab

6. Review → merge → delete branch

7. git pull origin main → git fetch --prune

Commit message style (Conventional Commits)

text

feat: add user registration endpoint fix: resolve division by zero error docs: update README with installation steps refactor: simplify authentication logic chore: update dependencies

This completes the full Mini Advanced Projects & Best Practices section — these projects will help you apply everything you've learned and build a strong portfolio!

16. Next Level Roadmap (2026+)

You’ve completed Python from zero to advanced — congratulations! 🎉 Now it’s time to specialize and build real-world skills that get you jobs, freelance work, or open-source contributions. Below is a practical, high-demand roadmap for 2026–2027.

16.1 Web Development (FastAPI, Django)

FastAPI is currently (2026) the #1 choice for modern Python web APIs — fast, async, automatic OpenAPI docs, type-safe with Pydantic.

Recommended Learning Path:

1. Build REST + async APIs with FastAPI

2. Use SQLAlchemy (async) or Tortoise-ORM for databases

3. Add authentication (JWT, OAuth2)

4. Deploy with Docker + Uvicorn/Gunicorn

5. Add tests (pytest + httpx)

Key Projects:

• To-do list API with user auth

• Blog API with CRUD + pagination

• Real-time chat (WebSockets + FastAPI)

Resources:

• Official FastAPI docs (excellent)

• “FastAPI – A python framework for building APIs” (free course on YouTube by Sanjeev Thiyagarajan)

• “Test-Driven Development with FastAPI and Docker” (free book on TestDriven.io)

Django – Still dominant for full-stack apps with admin panel, ORM, auth built-in.

When to choose:

• FastAPI → APIs, microservices, modern startups

• Django → Full websites with admin, rapid prototyping, enterprise

Projects:

• Django: Personal blog with comments & admin

• Django REST Framework (DRF) + React/Vue frontend

16.2 Data Science / Machine Learning

2026–2027 hot stack: Python + Polars (faster than pandas) + scikit-learn + PyTorch / TensorFlow + Hugging Face

Learning Path:

1. Master NumPy, pandas/Polars, Matplotlib/Seaborn/Plotly

2. Statistics & probability basics

3. scikit-learn (classification, regression, clustering)

4. Deep learning: PyTorch (preferred in 2026) or TensorFlow

5. Hugging Face Transformers → NLP, computer vision

6. MLOps basics (MLflow, DVC, BentoML)

Key Projects:

• House price prediction (regression)

• Customer churn classification

• Image classification (transfer learning)

• Sentiment analysis with BERT

• Recommendation system (collaborative filtering)

Resources:

• “Python for Data Analysis” (Wes McKinney – pandas creator)

• “Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow” (Aurélien Géron)

• fast.ai courses (free, practical deep learning)

• Kaggle competitions (best practice platform)

16.3 DevOps & Automation

Goal: Automate deployment, infrastructure, CI/CD, monitoring

Key Tools (2026 standard):

• Docker & Docker Compose

• GitHub Actions / GitLab CI (free & powerful)

• Kubernetes basics (minikube or kind for learning)

• Terraform / Pulumi (IaC)

• Ansible / Fabric for configuration

• Prometheus + Grafana (monitoring)

• Sentry / Rollbar (error tracking)

Learning Path:

1. Dockerize a FastAPI app

2. Set up GitHub Actions CI/CD pipeline

3. Deploy to Render / Railway / Fly.io (easiest)

4. Learn basic AWS/GCP/Azure (one of them)

5. Automate daily tasks with Python (scheduling with cron/APScheduler)

Projects:

• Auto-deploy FastAPI app on push to GitHub

• Dockerized Django + PostgreSQL + Nginx

• Automated backup script for database/files

16.4 Contributing to Open Source

Contributing builds your portfolio, network, and skills faster than any course.

Step-by-step Guide (2026):

1. Create GitHub profile → pin your best projects

2. Find beginner-friendly repos:

   • “good first issue” or “help wanted” label

   • Popular: FastAPI, Django, scikit-learn, pandas, requests, black, Ruff

3. Start small: fix typos/docs, add tests, update dependencies

4. Read CONTRIBUTING.md carefully

5. Open issue first if adding feature

6. Submit clean PR with good commit messages

7. Respond to feedback politely

Best Repos for Beginners (2026):

• fastapi/fastapi

• encode/django-rest-framework

• tiangolo/sqlmodel

• psf/black

• astral-sh/ruff

• pandas-dev/pandas (good first issues)

Tip: Use GitHub’s “Explore” → “Topics” → “good-first-issue”

📚 Amazon Book Library

All my books are FREE on Amazon Kindle Unlimited🌍 Exclusive Country-Wise Amazon Book Library – Only Here!

On GlobalCodeMaster.com you’ll find complete, ready-to-use lists of my books with direct Amazon links for every country.

Belong to India, Australia, USA, UK, Canada or any other country? Just click your country’s link and enjoy:

✅ Any eBook FREE on Kindle Unlimited ✅ Or buy at incredibly low prices

400+ fresh books written in 2025-2026 with today’s latest AI, Python, Machine Learning & tech trends – nowhere else will you find this complete country-wise collection on one platform!

Choose your country below and start reading instantly 🚀

BOOK LIBRARY USA 2026 LINK

BOOK LIBRARY INDIA 2026 LINK

BOOK LIBRARY AUSTRALIA 2026 LINK

BOOK LIBRARY CANADA 2026 LINK

BOOK LIBRARY UNITED KINGDOM 2026 LINK

BOOK LIBRARY GERMANY 2026 LINK

BOOK LIBRARY FRANCE 2026 LINK

BOOK LIBRARY ITALY 2026 LINK

BOOK LIBRARY SPAIN 2026 LINK

BOOK LIBRARY NETHERLANDS 2026 LINK

BOOK LIBRARY BRAZIL 2026 LINK

BOOK LIBRARY MEXICO 2026 LINK

BOOK LIBRARY JAPAN 2026 LINK

BOOK LIBRARY POLAND 2026 LINK

BOOK LIBRARY IRELAND 2026 LINK

BOOK LIBRARY SWEDEN 2026 LINK

BOOK LIBRARY BELGIUM 2026 LINK