For people who learned Python years ago — and haven’t really looked since.
The Python you learned isn’t the Python that exists today.
An 8-hour course to catch you up on everything that changed while you weren’t looking.
You learned Python once.
Maybe in a university course. Maybe on the job. Maybe from a book you worked through on weekends. You got it running, you solved your problem — and then life moved on. Other languages. Other projects. Python settled into the back of your toolkit.
Here’s what you may not realize: while you were away, Python changed. A lot.
The version you learned still works — but today’s Python is more sophisticated and mature, with new syntax, idioms, and tools. Code that experienced Python developers write now would look unfamiliar to the person who first learned it years ago.
And the hard part is that you can’t see the gap from where you’re standing. Your old code still runs. Nothing forces you to notice that half of what you do the long way now has a cleaner, faster, more obvious answer. You don’t know what you don’t know.
That’s exactly the gap python --update is built to close.
What’s actually changed
This isn’t a random pile of new features. Python evolved in a few clear directions, and once you see them, the whole modern language clicks into place. Here’s the shape of it.
The everyday code you write got dramatically cleaner. f-strings retired the old % and .format() gymnastics — and f"{value=}" now prints the name and the value together, which quietly removes half your debugging print statements. match/case collapses the if/elif ladders you used to write by hand, looking deep inside of nested data structures. Extended unpacking means first, *rest, last = values just works. And once you’re fluent with comprehensions, enumerate, and zip, you stop writing for i in range(len(...)) forever. None of this was available — or idiomatic — when most people learned the language.
A lot of that is because Python leaned hard into laziness. The functions you remember returning lists — range, map, zip, even dict.keys() — now hand back lazy iterators that produce values only as you ask for them. Generators went from an exotic corner feature to the default way Python moves data around. Get comfortable with generators and the itertools toolkit and you’ll handle enormous datasets without breaking a sweat — and you’ll finally understand why so much modern Python looks the way it does.
The standard library quietly grew up. dataclasses turns pages of __init__ boilerplate into a single decorator. pathlib makes the old os.path string-juggling obsolete. collections hands you defaultdict, Counter, and namedtuple for problems you used to solve the hard way. Context managers and with take care of cleanup you used to do manually. And type hints — list[int], str | None — together with tools like mypy now catch whole categories of bugs before you ever run the code.
A whole concurrency model arrived that simply didn’t exist before. asyncio and async/await gave Python a way to juggle thousands of simultaneous operations — a model with no equivalent in the Python you first learned. Meanwhile the GIL, the thing that always held real threading back, is finally being removed, and free-threaded Python is becoming real. We’ll sort out what’s actually true today about threads, async, and when to reach for each.
And Python itself became modern — and a living, governed language. The tooling leapt forward: uv replaced the old pip / venv / virtualenv tangle with one fast command, ruff does the work of black, flake8, and isort in milliseconds, and pyproject.toml is now the single home for a project’s configuration. The interpreter got substantially faster, and error messages now tell you what went wrong — often suggesting the fix. Underneath all of it, Python’s governance changed too: after Guido van Rossum stepped back, a steering council took over, and the language now ships on a predictable annual schedule. Part of what you’ll walk away with is a sense of how to keep current, instead of falling twenty years behind again.
The course itself
python --update is two live sessions, four hours each:
- Session 1 — Tuesday, July 21 — 5:30 pm Central European Time, 11:30 a.m. Eastern Time, 8:30 a.m. Pacific Time
- Session 2 — Tuesday, July 28 — 5:30 pm Central European Time, 11:30 a.m. Eastern Time, 8:30 a.m. Pacific Time
Live, so you can ask questions as we go. Recorded, so you can rewatch any part — or catch up if you miss a session.
This isn’t a teaser or a sampler. It’s drawn from the same material I’ve taught inside companies as a full two-day course, put into the context of a diff from older versions of Python.
Part of a larger picture
python --update isn’t a product I sell on its own. It’s included with a LernerPython membership — and that’s the whole point.
Because this is one course. The membership is full of them.
If eight hours of “oh — that’s how you’re supposed to do it” is worth your time, picture having that on tap, along with:
- 40+ courses on Python and Git, from fundamentals to how the language actually works under the hood
- Hundreds of exercises that look like real work — now with an interactive AI tutor that reads your code, catches your mistakes, and explains them, the way I would
- A private Discord where you can ask me directly
- Monthly office hours and special lectures on new features and where the language is going
- A structured roadmap so you always know what to learn next
Membership is $40/month or $400/year, and it starts with a 14-day free trial. python --update is yours as a member — for as long as you’re a member.
Success stories from learners
Want the detail? Here’s the full syllabus.
For those who want to see exactly what we’ll cover, here’s how the two sessions break down. Like everything at LernerPython, it’s hands-on — we write code, we don’t just talk about it.
Session 1 — July 21: How you write Python now
Modern syntax and idioms. f-strings and the = debugging trick, extended unpacking, the walrus operator, and match/case pattern matching — the everyday constructs that make current Python shorter and clearer than the version you learned.
Comprehensions, iterators, and generators. Why range, map, zip, and dict.keys() stopped returning lists, how generators became central to the language, and how to use generator expressions and itertools to process data lazily and efficiently.
The looping patterns professionals actually use. enumerate, zip, and the idioms that retire the C-style for i in range(len(...)) habit — small changes that make your code instantly read as fluent, modern Python.
A standard library worth knowing. dataclasses, pathlib, the collections types (defaultdict, Counter, namedtuple), and context managers — the batteries that got dramatically better and save you from reinventing them.
Type hints in practice. The modern syntax (list[int], str | None), what they actually buy you, and how tools like mypy catch bugs before runtime — without turning Python into a different language.
Session 2 — July 28: The modern ecosystem, and where Python is heading
Concurrency: async and threads, honestly. What asyncio and async/await are really for, how the GIL shaped Python’s threading story, what free-threaded Python changes, and how to decide which tool fits which problem.
Modern tooling. uv for projects and dependencies, ruff for linting and formatting, and pyproject.toml as the standard — the workflow that replaced a decade of accumulated friction.
Packaging, the modern way. How sharing and installing code actually works now — wheels, pyproject.toml, and the quiet death of setup.py — so the thing everyone used to dread is finally straightforward.
Performance and better diagnostics. What made recent Python meaningfully faster, and how today’s error messages and tracebacks help you fix problems instead of just reporting them.
A living language — and how to keep up. Python’s governance after Guido, the annual release cadence, and how the PEP process works — plus a practical habit for staying current so you never fall this far behind again.
Not ready to join today?
The course is a few weeks out. If you’d like a nudge as it gets closer — including a heads-up at the right moment to start your trial so the course lands inside it — leave your email and I’ll keep you posted.
Hi, I’m Reuven.
I’ve been teaching Python for more than 30 years.
I graduated from MIT’s CS department in 1992. I have a PhD in learning sciences. I’ve trained teams at Apple, Cisco, Intel, and Sandisk. I speak at PyCon and EuroPython. I’ve published three books and wrote a column for Linux Journal for 20 years.
But what I really am is a teacher.
I’ve been learning Chinese for about a decade, and many aspects of my learning have influenced my teaching. I understand much better now how important practice is. You can know something but not really know it.
I see myself as something like a stand-up comedian, trying the same thing over and over to different audiences until I see what variation works best. (And yes, I have lots of dad jokes in my classes.)
When someone tells me that thanks to my class, he was able to reduce the code in one project by 70 percent, or someone else tells me that a method I taught him would have more or less removed the need for a whole program… that just makes my day.
I’ve been using Python for more than 30 years, and I’m constantly learning new things. Members tell me no one else is doing what I’m doing.