Core & Advanced Python Online Training

CPU, memory, processes, file systems, environment variables, DNS, ports, client-server models, and the HTTP/HTTPS request-response lifecycle.

Configuring VS Code, terminal proficiency, Git integration, Postman, Docker desktop, and Python language servers.

Installing Python 3.12, multi-version management, PATH configuration, REPL, bytecode compilation, and virtual environments.

Setting up virtual environments (venv), pip dependency management, requirements-dev.txt, .gitignore, and standardized enterprise project skeletons.

How CPython compiles source to bytecode (.pyc), the Python Virtual Machine (PVM), garbage collection, and PEP 8 style standards.

Mutable vs immutable objects, id(), type(), memory allocation, references, and shallow vs deep copies.

Integers, floats, booleans, strings, lists, tuples, sets, dictionaries, slicing, and comprehension expressions.

Conditional branching, structural pattern matching (match/case), while/for loops, try/except/finally blocks, and custom exceptions.

Building an interactive CLI tool implementing robust error handling, collection transformations, and formatted tabular outputs.

Classes, instances, __init__, self, instance vs class variables, static methods (@staticmethod), and class methods (@classmethod).

Private attributes (_ and __ name mangling), @property getters/setters, single and multiple inheritance, MRO (Method Resolution Order), and super().

abc module, @abstractmethod, protocol classes, dynamic polymorphism, and interface enforcement.

__str__, __repr__, __len__, __getitem__, __setitem__, __iter__, __next__, __eq__, and context managers (__enter__/__exit__).

Functions as objects, scope, closures, function decorators, parameterized decorators, class decorators, and functools.wraps.

Implementing a custom Active Record class leveraging descriptors, magic methods, and custom decorators for validation.

typing module, Union, Optional, Any, Callable, TypeVar, Generic, Literal, TypedDict, and mypy static analysis.

@dataclass, field(), frozen dataclasses, slots=True, Pydantic BaseModel, Field validation, and serialization.

yield keyword, generator expressions, send(), throw(), close(), and itertools combinations/permutations.

Concurreny vs parallelism, GIL (Global Interpreter Lock), event loops, async/await, Task, Future, asyncio.gather, and asyncio.run.

Building an asynchronous HTTP pipeline using aiohttp and asyncio to fetch, parse, and store multi-source data concurrently.

Connection objects, cursor objects, execute(), executemany(), fetchone(), fetchall(), and parameter markers.

Connecting to PostgreSQL with psycopg3, client-side vs server-side cursors, prepared statements, and async connection management.

Why connection creation is expensive, psycopg_pool ConnectionPool, sizing pools, handling connection exhaustion, and health checks.

SQL injection vectors, why string interpolation fails, parameterized queries, and defensive database programming.

Building Project 1: Layered DAO architecture, connection pooling, transaction management, and automated reporting.

Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion in dynamic Python.

Factory Method, Abstract Factory, Builder pattern for complex objects, thread-safe Singletons, and when to avoid Singletons.

Adapter for legacy interfaces, Facade for simplifying complex subsystems, and Pythonic Decorators for cross-cutting concerns.

Strategy pattern for interchangeable algorithms, Observer for pub/sub decoupling, and Command pattern for transactional actions.

Decoupling business logic from frameworks, repository interfaces, use case interactors, and building maintainable enterprise domains.

Refactoring a tightly-coupled script into a pure Clean Architecture domain with abstract repositories and pluggable adapters.

Unit, integration, and end-to-end tests, Test-Driven Development (TDD), regression prevention, and testing asynchronous code.

Test discovery rules, assert statements, parametrized tests (@pytest.mark.parametrize), markers, and pytest.ini configuration.

Fixture scopes (function, class, module, session), autouse fixtures, yield fixtures for teardown, conftest.py hierarchy, and temporary directories.

unittest.mock.Mock, MagicMock, patch decorator, mocking third-party APIs, and using Testcontainers for isolated real PostgreSQL tests.

FastAPI TestClient / DRF APIClient, testing HTTP response status and JSON payloads, pytest-cov, and enforcing 85%+ code coverage gates.

Writing unit and integration test suites covering edge cases, authentication failures, and database transactions for an enterprise REST API.

Structure a clean multi-package Python project using strict typing, dataclasses, and pooled psycopg3 repositories.

Implement concurrent data ingestion, validation rules, error recovery, and JSON/CSV export workflows.

Write unit and integration fixtures in PyTest and defend Python memory/GIL/AsyncIO internals in AI Viva.