Best Python Programming Training Institute in Noida 2026

# Python fundamentals — what a good programme teaches first.
# This is the level students reach by week 2–3.

from dataclasses import dataclass
from typing import Optional


@dataclass
class Order:
    """An order with a simple total calculation."""
    order_id: int
    items: list[dict]
    discount: Optional[float] = None

    def subtotal(self) -> float:
        return sum(item["price"] * item["qty"] for item in self.items)

    def total(self) -> float:
        if self.discount is None:
            return self.subtotal()
        return self.subtotal() * (1 - self.discount)


def summarize_orders(orders: list[Order]) -> dict:
    """Return a summary dict for a list of orders."""
    if not orders:
        return {"count": 0, "total": 0.0}

    totals = [o.total() for o in orders]
    return {
        "count": len(orders),
        "total": round(sum(totals), 2),
        "avg": round(sum(totals) / len(totals), 2),
    }


# Try it
orders = [
    Order(1, [{"name": "Book", "price": 499, "qty": 2}]),
    Order(2, [{"name": "Pen", "price": 99, "qty": 5}], discount=0.1),
]

summary = summarize_orders(orders)
print(summary)

# What this teaches:
# - Dataclasses keep data classes clean
# - Type hints make code readable
# - Methods on classes encapsulate logic
# - Functions stay small and testable
#
# This is the minimum quality a "Python fundamentals" module should hit.
# If your course is still doing `print("hello")` after 4 weeks, it is too slow.

# A small Flask API — what a good programme teaches in weeks 6–8.
# This is the kind of project that becomes a portfolio piece.

from flask import Flask, jsonify, request

app = Flask(__name__)

# In-memory store for teaching (a real project uses a database)
books = [
    {"id": 1, "title": "Clean Code", "author": "Robert Martin"},
    {"id": 2, "title": "Fluent Python", "author": "Luciano Ramalho"},
]


@app.get("/books")
def list_books():
    return jsonify(books)


@app.get("/books/<int:book_id>")
def get_book(book_id):
    book = next((b for b in books if b["id"] == book_id), None)
    if book is None:
        return jsonify({"error": "not found"}), 404
    return jsonify(book)


@app.post("/books")
def create_book():
    data = request.get_json() or {}
    if "title" not in data or "author" not in data:
        return jsonify({"error": "title and author required"}), 400

    new_book = {
        "id": max(b["id"] for b in books) + 1,
        "title": data["title"],
        "author": data["author"],
    }
    books.append(new_book)
    return jsonify(new_book), 201


@app.delete("/books/<int:book_id>")
def delete_book(book_id):
    global books
    before = len(books)
    books = [b for b in books if b["id"] != book_id]
    if len(books) == before:
        return jsonify({"error": "not found"}), 404
    return "", 204


if __name__ == "__main__":
    app.run(debug=True)

# What this teaches:
# - Flask routes and HTTP methods
# - JSON input/output
# - Status codes (200, 201, 400, 404, 204)
# - Basic validation
#
# Why this matters:
# A working API like this is a real portfolio project.
# It shows you can build something another developer could use.
#
# If your course never gets to this stage, you are learning syntax, not Python.

# Testing with pytest — the module most beginner courses skip.
# A good programme teaches this before the portfolio project.

import pytest
from app import app, books


@pytest.fixture
def client():
    """A test client for the Flask app."""
    app.config["TESTING"] = True
    with app.test_client() as client:
        yield client


def test_list_books_returns_all(client):
    resp = client.get("/books")
    assert resp.status_code == 200
    data = resp.get_json()
    assert isinstance(data, list)
    assert len(data) == len(books)


def test_get_book_returns_404_for_unknown(client):
    resp = client.get("/books/9999")
    assert resp.status_code == 404
    assert resp.get_json()["error"] == "not found"


def test_create_book_validates_input(client):
    resp = client.post("/books", json={"title": "Incomplete"})
    assert resp.status_code == 400
    assert "author" in resp.get_json()["error"]


def test_create_book_success(client):
    resp = client.post(
        "/books",
        json={"title": "Python Testing", "author": "Someone"},
    )
    assert resp.status_code == 201
    data = resp.get_json()
    assert data["title"] == "Python Testing"
    assert "id" in data


# What this teaches:
# - How to test an API without a browser
# - Fixtures for reusable setup
# - Assertions on status codes and JSON
# - Test naming that reads as documentation
#
# Why this matters in an interview:
# "I tested my Flask API with pytest" is a very different sentence
# from "I learned Python". The first one gets you hired.

# A course that skips testing is a course that produces coders,
# not developers.