>>> model.predict(["this class was brilliant"])
['positive'] # you trained it, you understand it
Stage 1 of 3 — Python from the roots
Python, from the ground up.
A complete, in-depth Python course that does not stop at the basics. You learn every fundamental for real understanding, then the standard-library modules most courses never open, and you finish with a genuine first taste of AI. Live, small-batch, instructor-led — built for Grade 6 learners through working professionals.
>>> 10,000+ students
>>> 15+ countries
>>> 70+ live courses
>>> 4.9/5 from 247+ reviews
The full path, end to end
Python is rarely the whole journey. At Modern Age Coders it is the first stage of a three-stage climb that takes you from your very first line of code to building machine-learning models with your own hands. This page goes deep on Stage 1, but here is the whole route so you can see the depth ahead and choose with open eyes. Each stage is designed to make the next one possible, so you are never asked to run before you can walk and never held back once you can.
You are here
Stage 1
Python From the Ground Up
Grade 6-12: ~40 classes · Grade 12+ & adults: 24
Every Python fundamental from the roots, deeper language knowledge, the standard-library modules most courses never open, and a real first taste of AI.
Stage 2
NumPy, Pandas & Matplotlib Masterclass
24 classes · teens after Stage 1, college, professionals
Data analysis in real depth — the maths underneath each tool and how each library is actually built, not just which method to call.
Open Stage 2 >
Stage 3
Machine Learning From Scratch
32 classes · college and professionals only
Build the models yourself — implement gradient descent and core algorithms by hand before you ever reach for a library.
Open Stage 3 >>>> For an adult, the full route runs about 80 live classes end to end — Stage 1 (24) into Stage 2 (24) into Stage 3 (32) — each stage earning the next.
The growth ladder
Stage 1 grows the way a tree does: down into the roots first, up through a strong trunk, out to the canopy. Read it from the bottom up. Each cell is a live REPL line — a yellow >>> input and the result it returns.
Canopy — first taste of AI
A real, hands-on taste of AI
You finish Stage 1 by training a small model on real text or numbers and reasoning about why it gets things right and wrong. Not a black box, not a demo you watch — your own working AI, built on the Python you now truly understand. It is deliberately small, but it is honest: you collect the data, write the code, run the prediction, and explain the result in your own words.
Trunk — the modules others skip
>>> from collections import Counter
>>> Counter("mississippi").most_common(1)
[('s', 4)] # the standard library, opened
The standard library, finally opened
Most courses stop at print, lists and loops. We keep climbing into the parts of Python that make working programmers fast: itertools, collections, dataclasses, pathlib, typing, datetime, json, and the generators and iterators that power them.
Roots — fundamentals, for real
>>> x = 7
>>> id(x) # where does the computer keep it?
140703... # understanding, not memorising
Fundamentals you actually understand
We start in the soil. What a variable really is and how memory holds it, how data types behave, how control flow decides, how functions package thought, and how objects model the world. Slow where it matters, so nothing above it is built on sand. By the time you leave the roots you can predict what a piece of code will do before you run it, which is the first sign you actually understand a language rather than recite it.
What "from the ground up" actually means
Plenty of courses claim to teach Python. Most teach the first afternoon of it and call the rest advanced. Here is what we mean by depth, concretely.
>>> Fundamentals for true understanding
You will not just memorise syntax. You will understand what a variable is and how Python keeps it in memory, why integers and strings and lists behave differently, how mutability bites and how to avoid it. We teach control flow as decision-making, functions as a way to package thinking, and object-oriented programming as a way to model real things — classes, instances, methods and inheritance — until you can read and design code, not just copy it.
We linger on the parts beginners usually rush past: scope and the difference between local and global names, default arguments and the traps they hide, how Python passes objects to functions, and why the same operation can be cheap on one data type and expensive on another. These are the ideas that quietly decide whether your later code is clean or fragile.
>>> The standard library others skip
Python ships with a deep toolbox almost no beginner course opens. We do. You will use collections for the right data structure, itertools to compose clean pipelines, dataclasses to model data without boilerplate, pathlib for files done properly, typing for code that explains itself, and datetime and json for the real world — all built on a solid grasp of generators and iterators.
This is the layer that separates someone who can write a script from someone who can write good Python. Knowing that a generator can process a huge file without loading it into memory, or that a defaultdict removes a whole class of bugs, changes how you reach for tools for the rest of your life. We do not survey these modules from a distance; you write real code with each one.
>>> Debugging as a real skill
Reading an error message, forming a hypothesis, and finding the bug is a skill we teach on purpose, not a thing we hope you pick up. You will learn to read tracebacks calmly, reason about what the code is actually doing versus what you meant, use print and the debugger deliberately, and isolate a problem instead of guessing. This is the difference between a learner and an engineer.
>>> An early, hands-on taste of AI
Stage 1 ends where it should — with you building something intelligent. Using only the Python you now understand, you will prepare a small dataset, train a simple model, and watch it make predictions, then probe why it succeeds and fails. It is a true taste of artificial intelligence, grounded in fundamentals, so that when you reach Stage 3 nothing about it feels like magic.
If this is the kind of depth you are after across every subject we teach, our real coding classes philosophy explains why we refuse to teach the shallow version of anything.
Two tracks, one depth
The depth never changes. The pace does. We run Stage 1 as two tracks so a Grade 6 student and a working adult each get the same thorough Python, taught at the speed that fits them.
Track A
Grade 6 to 12
about 40 live classes
Paced for school learners. We give each idea room to land, weave in plenty of small builds, and let understanding settle before adding the next layer. School students who are new to programming need time to think in code, and these classes give them exactly that without ever dumbing the material down.
Track B
Grade 12 plus and adults
24 classes, often fewer
Faster, denser, the same depth. Older students and adults cover the entire ground — fundamentals, the standard library and the first taste of AI — in 24 classes, and frequently fewer depending on the learner. If you arrive with some exposure or strong logical maturity, your mentor compresses the early material and spends the saved time where it matters most. The 24 is a ceiling, not a target: many adults finish sooner, because the point is mastery, not attendance.
The courses behind Stage 1
Stage 1 is delivered through these live courses, matched to your age and goals. See each one, then decide.
Python for Kids
Real Python for younger learners — fundamentals taught gently and visually, ending in a friendly first brush with AI.
View course >
Python Programming (Teens)
The full Stage 1 climb for teenagers — roots, the standard library and a hands-on taste of AI, built project by project.
View course >
Python Masterclass — Zero to Advanced
The fast, dense track for college students and adults — every fundamental and the deeper standard library in 24 focused classes.
View course >
Computational Thinking & AI (Classes 9-12)
Python plus structured problem-solving for senior school — fundamentals aimed squarely at reasoning and an early, real look at AI.
View course >How classes run
The format is the point. You learn Python by writing Python while a mentor watches your reasoning, not by watching someone else.
01
Live, never recorded
Every session is a real class with a real teacher, in real time. You can ask the moment you are stuck.
02
Small batches
Batches stay small so your mentor knows your name, your habits and exactly where your understanding wobbles.
03
Your reasoning, reviewed
Mentors review how you think, not just whether the output is green. Wrong-but-honest reasoning gets fixed at the source.
04
You build it yourself
You type every line and debug every problem. By the end you own the skill, because you did the work.
Frequently asked questions
>>> How long does Stage 1 take?+
It depends on the track. For Grade 6 to 12 learners, Stage 1 runs about 40 live classes, paced gently so school students absorb each idea before moving on. For Grade 12 plus students and adults, the same ground is covered in 24 classes, and often fewer, because we move faster and skip nothing essential. Either way, the pace is set by the learner in a small batch, not by a fixed clock.
>>> Do I need any prior experience?+
No. This course is built for true beginners, which is exactly why it is called from the ground up. We start at the roots, with what a variable really is and how the computer remembers it, and grow from there. If you have dabbled before, the early classes simply move quicker and the deeper standard-library work will still be new to you.
>>> What ages is this for?+
Two tracks span ages 6 to 65. The Grade 6 to 12 track is paced for school learners across roughly 40 classes. The Grade 12 plus and adults track covers the same depth faster in 24 classes. We place every student into the track and batch that fits their grade, goals and prior exposure.
>>> Are classes live?+
Yes. Every class is live, online and instructor-led in a small batch. You write code while your mentor watches, asks why, and reviews your reasoning in real time. Nothing here is a pre-recorded video you watch alone, and nothing important is left to a quiz.
>>> How does the free demo work?+
Book a free demo and you sit in a live session with a mentor. You will meet your teacher, write a little real Python, and get a clear, honest read on the right track and batch for you. There is no obligation, and you will leave the demo knowing exactly what Stage 1 looks like before you decide anything.
>>> Should I still learn Python now that AI can write code?+
Yes, more than ever. Typing code is no longer the scarce skill, understanding is. AI tools generate Python quickly, but someone still has to read that output, judge whether it is correct, fix it when it is wrong, and direct the tool toward the right design. Strong fundamentals make you that person. Without them you are trusting code you cannot evaluate, which is exactly why we teach Python deeply and finish Stage 1 with a real, hands-on taste of AI.
Start at the roots. Grow to AI.
Sit in one live class, write a little Python, and see the depth for yourself. The demo is free and tells you exactly which track fits.