Ishita Sengupta
โ Enrolled๐ Kolkata, India โข B.Tech IT โ Python 3.12, OOP & Async
๐ Weekend SatโSun (6โ8 PM IST)
Launch full-screen from your iPhone / iPad Home Screen
Go from zero coding background to writing clean, idiomatic, tested Python 3.12 software mastering data structures, OOP, decorators, generators, context managers, AsyncIO concurrency, virtual environments, and pytest.
Net: $18 + 18% GST ($3 ) โข ~$1 /Hr
๐ 30-Day 100% Tuition Credit Upgrade Bridge ($21 Credit)
Deduct 100% of your $21 fee when upgrading to Python Backend Developer โ Industry-Ready Career Program (PBCP) within 30 days of batch start. PBCP โ
Every month concludes with measurable coding competency, a portfolio repository deliverable, and continuous DSA progression.
Syntax, control flow, lists/dicts/sets, functions, exceptions, complete OOP, and file/JSON handling.
Outcome: Build modular object-oriented Python CLI applications.
Deliverable: Python Banking & Inventory Management CLI.
DSA Focus: Arrays, strings, hashing & Python dict/set Big-O.
Iterators, generators, decorators, memory/GIL, threading/AsyncIO, pytest fixtures, and Git workflow.
Outcome: Deliver production-grade concurrent, tested Python packages.
Deliverable: Capstone: Modular Python 3.12 Banking & Async Log-Analyzer Suite.
DSA Focus: Two pointers, sliding window & recursion in Python.
Practised continuously from Month 1 to Month 6 (Easy โ Medium โ Selected Hard) with constraints, sample I/O, Big-O analysis, and Python 3.12 reference solutions and test cases inside the Student Coding Lab.
Complexity
6 Problems โข M1
Arrays
6 Problems โข M1
Strings
6 Problems โข M1
Hashing
6 Problems โข M2
Two Pointers
6 Problems โข M2
Published transparently so students compare scope honestly before enrolling:
โ Correct Answer: A
Breaking complex backend business rules (like tiered utility billing) into deterministic input -> process -> output steps before coding.
Practice L1/L2 engineering questions across all 116 PYTH topics. Our AI Interviewer speaks questions aloud and scores your spoken answer across Technical Depth, Clarity, Edge Cases & Confidence.
Every module and topic lists its exact technical subtopics, hands-on code labs, Mock Tests, MockAttempt AI interviews, and explicit What Topic Is Next โ progression so enrolled students and trainers always stay synchronized from Day 1 to Expert mastery.
Delivers complete zero-to-expert command over 928+ production subtopics across 80 live + lab hours (~โน25/hr, ~โน25/topic) mentored live by Working IT Professionals.
Month 1 โ Core Python 3.12, Data Structures, Functions & OOP (Weeks 1โ4)
Month 2 โ Decorators, Generators, AsyncIO, Pytest & Capstone (Weeks 5โ7)
Module Learning & Hands-On Objectives
Programming concepts, step-by-step algorithms, flowcharts, dry-running, and structured problem-solving
Python history, readability philosophy (PEP 8 / Zen of Python), backend/API/automation/data applications, and the Python 3 ecosystem
Installing Python 3.12 on Windows (`PATH` & `py` launcher) and Linux (`apt`/`pyenv`), verifying `python3` and `pip`
Configuring VS Code (Python + Pylance + Ruff extensions), PyCharm, integrated terminal, and selecting the workspace interpreter
Interactive REPL mode vs `.py` script mode, source -> bytecode (`.pyc` in `__pycache__`) -> Python Virtual Machine (PVM) execution flow
4-space block indentation rules (PEP 8), logical vs physical lines, docstrings, and meaningful single-line `#` comments
Dynamic variable binding, object references, `snake_case` naming rules, multiple assignment, and tuple swapping `a, b = b, a`
Built-in scalar types (`int` arbitrary precision, `float` IEEE-754, `complex`, `bool`, `str`, `NoneType`) and `type()` / `isinstance()`
Implicit numeric promotion (`int` -> `float`) vs explicit constructors (`int()`, `float()`, `str()`, `bool()`) and truthiness rules
Reading console text via `input()`, `print()` (`sep`, `end`, `flush`), and formatted f-string numeric/alignment specifiers
Arithmetic (`+`, `-`, `*`, `/` true division, `//` floor division, `%` modulo, `**` power), comparison, logical (`and`, `or`, `not`), and augmented assignment
Bitwise AND (`&`), OR (`|`), XOR (`^`), NOT (`~`), left shift (`<<`), and right shift (`>>`) on integers
`in` and `not in` across strings, lists, tuples, sets, and dictionary keys, plus `O(1)` `set` vs `O(n)` `list` lookup cost
`is` and `is not`, `id()` memory address checks, singleton `None` checks (`x is None`), vs `==` value comparison
Python evaluation order (`**`, unary `-`, `* / // %`, `+ -`, shifts, bitwise, comparisons, `not`, `and`, `or`) and chained comparisons (`0 <= score <= 100`)
`if`, `elif`, `else` branching, mutually exclusive grade/slab ladders, and concise conditional expressions (`x if cond else y`)
Build a PEP 8 compliant Python 3.12 command-line utility suite combining Calculator, Simple Interest Calculator, Tiered Electricity Bill Calculator, Student Grade Calculator, O(sqrt(n)) Prime Checker, Armstrong Checker, and Number Guessing Game with input validation.
Module Learning & Hands-On Objectives
Unicode UTF-8 string literals, raw strings `r"..."`, multiline strings, positive `0..n-1` and negative `-1..-n` indexing
Slice notation `s[start:stop:step]`, omitting bounds, negative steps `s[::-1]` reversal, and out-of-range slice safety
`upper()`, `lower()`, `casefold()`, `strip()`/`lstrip()`/`rstrip()`, `removeprefix()`, `removesuffix()`, `split()`, and `" ".join()`
`find()` / `rfind()` (`-1` on miss) vs `index()` / `rindex()` (`ValueError` on miss) and non-overlapping `count()`
`startswith()` (accepting a tuple of prefixes!), `endswith()`, `isdigit()`, `isalpha()`, `isalnum()`, and `isspace()`
Modern f-strings `f"{expr}"`, debug `f"{var=}"`, numeric formatting `:.2f`, `:,`, ISO dates, vs `.format()` templates
Why `str` objects cannot be mutated in-place, `O(n^2)` loop `+=` concatenation penalty vs `O(n)` `"".join(parts)` buffer building
Dynamic array internals of `list`, literal/constructor creation, indexing, slicing, slice assignment, and `len()`/`min()`/`max()`/`sum()`
`append()` (`O(1)` amortized), `extend()`, `insert(0, x)` (`O(n)` shift!), and `remove(val)` (`ValueError` if missing)
`pop()` (`O(1)` tail vs `O(n)` index), `clear()`, in-place `sort(key=..., reverse=...)` vs non-mutating `sorted()`, and `reverse()`
`[expr for x in iterable if cond]`, conditional transformations, flattening 2D matrices, and readability limits
Immutable fixed-structure `tuple` records, single-element trailing comma `(42,)`, tuple packing/unpacking, and hashability as `dict` keys
`.count(value)`, `.index(value)`, memory efficiency of tuples vs lists (`sys.getsizeof`), and immutability of slot bindings
Hash-table backed `set` and immutable `frozenset`, `set()` empty set creation (NOT `{}`!), `O(1)` membership and deduplication
Union (`|` / `.union()`), intersection (`&` / `.intersection()`), difference (`-`), symmetric difference (`^`), and subset/superset (`<=`, `>=`, `isdisjoint`)
`add()`, `update()`, `discard()` (no error if missing) vs `remove()` (`KeyError` if missing), and `pop()`
Insertion-ordered hash map (`dict`, guaranteed since Python 3.7+), hashable keys, `O(1)` read/write/delete, and `del` / `in`
`.keys()`, `.values()`, `.items()` dynamic views, `.get(k, default)`, `.pop(k, default)`, `.setdefault()`, and `|` / `|=` merge operators
Build 6 collection-powered Python modules: Student Marks Manager, Employee Record Manager, Shopping Cart, Case-Insensitive Word Frequency Counter, Order-Preserving Deduplicator, and O(1) Dict/Set Inventory Lookup.
Module Learning & Hands-On Objectives
`def` declaration, docstrings (PEP 257), single-responsibility design, invocation, and implicit `None` return
Positional arguments, keyword arguments, positional-only (`/`) and keyword-only (`*`) parameter markers
Default parameter evaluation at `def` definition time (ONCE!) and the `None` sentinel pattern for mutable defaults
Variadic positional `*args` (packed as `tuple`), variadic keyword `**kwargs` (packed as `dict`), and call-site `*` / `**` unpacking
Early-return guard clauses, returning multiple values via tuple packing/unpacking, and consistent return types
Local -> Enclosing -> Global -> Built-in (LEGB) name resolution, `global` vs `nonlocal`, and why mutable global state hurts concurrency
Single-expression anonymous `lambda params: expr` functions for inline sort keys and callbacks vs named `def` functions
Base case + progress toward base case, call stack frames, `sys.getrecursionlimit()` (~1000 in CPython, no tail-call optimization!)
First-class functions passed as arguments (strategy/validator callbacks) and returned from factory functions
Lazy iterator `map(func, *iterables)` transformation vs list/generator comprehensions
Lazy predicate filtering `filter(pred, iterable)`, `filter(None, iterable)` truthy filtering, vs comprehensions
`functools.reduce(fn, iterable, initializer)` cumulative folding vs Pythonic built-ins (`sum`, `min`, `max`, `all`, `any`, `math.prod`)
Creating reusable `.py` modules, module namespace isolation, `sys.modules` import cache, and avoiding circular imports
Multi-directory package hierarchy (`banking/models/`, `banking/services/`), `__init__.py`, `__all__`, and explicit package exports
Absolute imports (`from app.services.auth import verify`), explicit relative imports, `sys.path`, and why `from mod import *` is banned
How Python sets `__name__ == "__main__"` on direct execution vs module path on `import`, protecting CLI entrypoints
Practical backend usage of `os`, `sys`, `math`, `random`/`secrets`, and timezone-aware `datetime` (`datetime.now(timezone.utc)`)
`try` and `except SpecificError as exc:` blocks, exception hierarchy (`BaseException` vs `Exception`), and preserving error context
Architect a multi-package Python Banking & Calculator application (`models`, `services`, `exceptions`, `cli`) featuring keyword-only parameters, custom `InsufficientFundsError` exceptions, `if __name__ == "__main__":` guards, and rotating file + console `logging`.
Module Learning & Hands-On Objectives
Procedural vs object-oriented design, coupling data + behavior, and the 4 OOP pillars in Python backend architecture
`class` statement, `CapWords` (`PascalCase`) PEP 8 naming, class namespace dictionary (`__dict__`), and docstrings
Class instantiation `obj = ClassName(...)`, unique object identity (`id(obj)`), `isinstance()`, and attribute lookup order
Object initialization via `__init__(self, ...)` (vs `__new__` allocator), validating invariants at construction time
How Python binds `instance.method(x)` to `Class.method(instance, x)` and why explicit `self` is first parameter
Object-specific attributes bound on `self.attr` inside `__init__`, dynamic attribute storage in `obj.__dict__`
Class-level attributes shared across all instances (`company_name`, constants), lookup fallback `obj.__dict__` -> `cls.__dict__`, and mutable class attribute danger
Behavior operating on `self` state, mutator vs query methods, and calling sibling methods via `self.`
`@classmethod` decorator, `cls` class binding (subclass-aware!), and named alternative constructors (`from_dict`, `from_csv_row`)
`@staticmethod` decorator for namespace-grouped pure helper functions requiring neither `self` nor `cls`
Public attributes, `_protected` convention, `__private` name mangling (`_ClassName__attr`), and invariant protection
Deriving specialized `class Sub(Base):` (`is-a` relationship), `super().__init__(...)`, and extending base behavior
Inheriting from multiple bases `class View(AuthMixin, AuditMixin, BaseView):` and cooperative `super()` mixin design
Chained `GrandParent -> Parent -> Child` hierarchies (`Exception -> BankingError -> InsufficientFundsError`) and keeping depth shallow
Multiple sibling subclasses (`SavingsAccount`, `CurrentAccount`, `SalaryAccount`) sharing one common parent (`Account`)
Method overriding across subtypes and Pythonic duck typing ("if it implements `.send()`, treat it as a sender")
Separating WHAT a repository/gateway contract promises from HOW PostgreSQL, Redis, or JSON files implement it
`from abc import ABC, abstractmethod`, preventing instantiation of incomplete subclasses at instantiation time
Design and build a modular, object-oriented, file-backed Python 3.12 Employee Management Console Application supporting complete CRUD, search, JSON/CSV persistence, custom exception handling, and structured application logging.
Module Learning & Hands-On Objectives
Objects implementing `__iter__` (or sequence `__getitem__`), reusable multi-pass containers (`list`, `dict`) vs single-pass streams
Stateful Iterator Protocol (`__iter__` returning `self` + `__next__` raising `StopIteration` when exhausted)
Manual iteration via `it = iter(obj)` and `next(it, default)` sentinel handling without `StopIteration` crashes
Generator functions pausing frame state at `yield`, `yield from` delegation, and `O(1)` memory streaming
Lazy `(expr for x in iterable if cond)` parenthesized expressions passed directly into `sum()`, `any()`, `all()`, `max()`
`@decorator` syntactic sugar (`fn = decorator(fn)`), preserving `__name__`/`__doc__` metadata with `@functools.wraps(fn)`
Parameterized decorator factories (`@retry(max_attempts=3)`) and bottom-up composition order of stacked `@d1` / `@d2` decorators
Lexical scope capture (`__closure__` cell objects) and late-binding loop variable pitfalls in closures
Class-based context manager protocol (`__enter__` resource acquisition, `__exit__(exc_type, exc_val, tb)` cleanup/rollback)
`from contextlib import contextmanager, suppress, ExitStack` generator-based context managers (`try: yield resource finally: cleanup()`)
Set comprehensions `{...}`, dict comprehensions `{k: v ...}`, and nested comprehensions with filtering
Starred target unpacking `first, *middle, last = seq`, nested tuple unpacking, and `{**d1, **d2}` / `[*a, *b]` literals
Assignment expressions `if (m := pattern.search(line)):` and `while (chunk := f.read(8192)):` avoiding duplicate calls
Python 3.10+ `match subject:` with sequence, mapping (`case {"type": "paid", "amount": amt}:`), class, OR (`|`), guard (`if`), and wildcard (`case _:`) patterns
PEP 484/585/604 modern Python 3.12 syntax (`list[str]`, `dict[str, int]`, `str | None`), return `-> None`, and runtime `__annotations__`
`Any` vs `object`, `Literal`, `TypedDict`, `Final`, `Collections.abc.Callable`, and legacy `Optional`/`Union`/`List` in older codebases
Create an O(1)-memory generator log-analytics pipeline using `@functools.wraps` timing/retry decorators, custom `@contextmanager` timers, `StrEnum` levels, frozen `@dataclass(slots=True)` DTOs, `re.fullmatch` validators, and `pyproject.toml` packaging.
Module Learning & Hands-On Objectives
Source parsing -> AST -> code objects -> bytecode evaluation loop on the Python Virtual Machine stack frame
CPython reference interpreter vs PyPy/Cython, C extension ABI, and why NumPy/psycopg release the GIL in C code
Inspecting stack-machine opcodes (`LOAD_FAST`, `BINARY_OP`, `RETURN_VALUE`), `.pyc` caching, and Python 3.11+ adaptive specializing interpreter
Private CPython heap, `PyObject` header (`ob_refcnt` + `ob_type`), `pymalloc` small-object arenas, and `tracemalloc` profiling
Immediate deterministic deallocation when `ob_refcnt` drops to `0`, inspecting `sys.getrefcount()`, and strong vs `weakref` references
Why reference cycles (`a.peer = b; b.peer = a`) never hit refcount `0`, generational `gc` (Gen 0/1/2), and `gc.collect()`
Shared references across containers, in-place mutation (`+=` on `list` calls `__iadd__`) vs rebinding (`+=` on `tuple`/`str` creates new object)
Memory graph topology of alias (`=`), shallow copy (`copy.copy`), and deep copy (`copy.deepcopy`) on nested state
What the CPython GIL protects, why CPU-bound Python bytecode runs 1 thread at a time per process, and why I/O releases the GIL
OS threads inside a single shared-memory process, main thread vs daemon threads, and preemptive context switching
`threading.Thread(target=..., args=...)`, `.start()`, `.join(timeout=...)`, and collecting results via thread-safe `queue.Queue`
Mutual exclusion with `threading.Lock()` (`with lock:`), re-entrant `RLock()` when a locked method calls another locked method on `self`
Check-then-act (`if balance >= amt: balance -= amt`) and read-modify-write (`counter += 1` is multiple bytecodes!) non-atomicity
Circular lock wait (`Thread 1 locks A -> waits B`, `Thread 2 locks B -> waits A`) and prevention via canonical lock ordering (`id` sort) & timeouts
`from concurrent.futures import ThreadPoolExecutor, as_completed`, `executor.submit()`, `executor.map()`, `Future.result(timeout=...)`
Separate OS processes, separate Python heaps + separate GILs for true multi-core CPU parallelism, `spawn` vs `fork` start methods
Benchmark CPU-bound prime counting (`ProcessPoolExecutor`) vs blocking I/O (`ThreadPoolExecutor` + deadlock-free `Lock` ordering) vs non-blocking `asyncio.TaskGroup` + `Semaphore`-throttled `httpx.AsyncClient` API aggregation.
Module Learning & Hands-On Objectives
Arrange-Act-Assert (AAA) structure, deterministic repeatability (no sleep/network/clock flakiness!), and catching regressions in CI before deploy
Fast pure-Python Unit tests (70%) + real-DB/API Integration tests (25%) + end-to-end smoke workflows (5%)
Red (write failing test specifying requirement) -> Green (minimal passing implementation) -> Refactor (clean up while keeping tests green)
`unittest.TestCase`, `setUp`/`tearDown`, `self.assertEqual`/`assertRaises`, and why Djangoโs `django.test.TestCase` subclasses `unittest.TestCase`
Installing `pytest` + `pytest-asyncio` + `pytest-cov`, configuring `[tool.pytest.ini_options]` in `pyproject.toml`, `-k` filter, `-x` stop-on-first-fail, `--lf` last...
Descriptive `test_<unit>_<scenario>_<expected>()` naming (`test_apply_job_when_already_applied_returns_409`), plain `assert` introspection
Rich `pytest` diffing on dicts/lists, `pytest.approx()` for floats, and `with pytest.raises(InsufficientFundsError, match="Balance"):`
`@pytest.fixture(scope="function" | "module" | "session")` in `conftest.py`, composable dependency injection, `yield` teardown, and `tmp_path` built-in fixture
Distributed Version Control (DVCS), auditability, blame history, safe experimentation, and team rollback guarantees
Three-tree model: Working Tree -> Staging Area (`.git/index`) -> Local `.git/objects` DAG (`blob`, `tree`, `commit` SHA-1/SHA-256)
`git config --global user.name`, `user.email`, `init.defaultBranch main`, `core.autocrlf` (Windows `true` vs Linux `input`), and SSH keys
Initializing `.git` at project root, verifying repository boundaries, and immediate `.gitignore` creation before first `git add`
Interpreting untracked, unstaged, staged, ahead/behind remote tracking indicators before every commit
Explicit file staging `git add src/models.py`, interactive hunk staging `git add -p`, and unstaging via `git restore --staged`
Build a multi-package Python 3.12 application combining an OOP Banking & Inventory Ledger (JSON/CSV persistence, custom exceptions, @dataclass models) with an AsyncIO Concurrent Log-Analyzer and >= 85% pytest test coverage.
Verify your email OTP in 15 seconds to receive the live Zoom/Meet demo link, complete 7-module PDF, and personalized roadmap for Core & Advanced Python 3.12 Programming.
Python 3.12 From Scratch
Core LanguageLists, Dicts, Sets & OOP
Problem SolvingDecorators, Generators & AsyncIO
Advanced PythonCLI, venv, uv & Packaging
OS & ScriptingPytest Unit & Fixture Suites
Test AutomationGit, GitHub & Clean Code
Version ControlLeetCode Problem Solving
Trainer Coding PrepHackerRank Coding Prep
Trainer Coding PrepCore & Advanced Python 3.12 Programming teaches you how modern tech companies design, build, test, and deploy reliable Programming & Backend software using Python 3.12, Lists, Dicts & Sets, Functions & Type Hints, OOP & @dataclass, Decorators & Generators โ explained in clear everyday language before writing real production code.
Suitable for both complete beginners (guided step-by-step from Day 1 setup and core logic) and technical students/working professionals aiming for production architecture mastery.
Key Engineering Capabilities You Will Build:
Purpose: Directly required by Programming & Backend engineering teams to ship reliable client systems.
Purpose: Directly required by Programming & Backend engineering teams to ship reliable client systems.
Purpose: Directly required by Programming & Backend engineering teams to ship reliable client systems.
Purpose: Directly required by Programming & Backend engineering teams to ship reliable client systems.
Purpose: Automated Python 3.12, Lists, Dicts & Sets, Functions & Type Hints, OOP & @dataclass, Decorators & Generators test suites โข Linting & static checks โข Mentor Git pull-request reviews โ ensuring your code never breaks silently when real users hit edge cases.
Purpose: Verify every single Core & Advanced Python 3.12 Programming topic through timed MCQ exams and spoken technical interviews before deploying your Live Client Project.
Student Learning Outcomes (By End of Course):
Baseline: Python 3.12+, `venv`/`uv`, `pytest`, `mypy`/`ruff` & Git.Taught live by active Working IT Professionals between 7:00 AM and 8:00 PM IST (choose any slot based on trainer availability).
Batch Available (Sat โ Sun Only): 2 Hours / Day โข 7:00 AM to 8:00 PM IST (choose any slot based on trainer availability)
Mon โ Fri Guided Practice: Real GitHub repository builds, LeetCode/HackerRank coding & โฅ90% Mock/AI Interview gates.
Core & Advanced Python 3.12 Programming โ Live Cohort
Weekend Live (SatโSun โข 2h/Day โข 7 AMโ8 PM IST) โข 07:00 AM โ 08:00 PM IST Flexible Live Slots
Starts: 21 Nov 2026
๐ Live Client Production Project + Internship Letter
After completing all 14 progressive hands-on module projects during live classes, students join our mentor-led Client Production Sprint to build, test, and deploy "Core & Advanced Python 3.12 Programming โ Enterprise Client Production Platform" to live cloud production โ earning an Official Verified Internship Letter detailing their exact technical contributions.
Domain: Live Enterprise Programming & Backend Client Engagement โข Infra: Python 3.12, Lists, Dicts & Sets, Functions & Type Hints, OOP & @dataclass, Decorators & Generators โข Git CI/CD + Automated Testing + Live HTTPS Cloud Production
Certified on Your Official Internship Confirmation Letter:
1. Graduation Certificate
Certifies PYTH module mastery, Mock/AI Viva scores & GitHub repos.
2. Client Internship Letter
Employer BGV-verifiable proof of live production deployment contributions.
See the exact job positions and realistic salary packages unlocked by Core & Advanced Python 3.12 Programming, plus which specialized MockAttempt Academy courses to pair next to qualify for higher-paying multi-stack engineering roles.
Hands-on module projects, topic-wise MCQ mocks, AI interviews & live client internship proof.
Production architecture, performance tuning & automated testing mastery.
Unlocked by combining this course with the recommended next courses below.
Why Learn Next (For What Purpose): Pair Core & Advanced Python 3.12 Programming with complementary specialist tracks or use your 30-Day 100% Tuition Credit toward our 6-Month Job-Guarantee* Career Program.
Every module, GitHub lab, 50-MCQ assessment, and 4-axis Spoken AI Viva in Core & Advanced Python 3.12 Programming is reviewed quarterly against live enterprise hiring bars and taught in clear English on weekends by active Working IT Professionals.
โน1,999 All-Inclusive (Incl. 18% GST) for 6โ7 structured weeks of live classes, 30 Python coding labs, Topic MCQs, Spoken AI Vivas, and 100% 30-day fee credit toward our โน15,000 Python Backend (PBCP) or GenAI (GAIP) Career Programs.
Yes. Module 1 starts from installing Python 3.12, variables, loops, and functions before building up to OOP, decorators, generators, AsyncIO, and pytest.
Matching Career Roadmaps:
Weekend Live PYTH Cohorts Across Top IT Hiring Hubs:
Book Free Live Demo or Reserve Batch Seat