Planet Python
Last update: April 30, 2026 01:45 PM UTC
April 30, 2026
Real Python
Quiz: Using Python for Data Analysis
Test your understanding of a data analysis workflow in Python, from cleansing raw data with pandas to spotting insights with regression.
EuroPython
EuroPython 2026: Ticket Sales Now Open
EuroPython 2026 ticket sales are now open! We have a special keynote this year: Łukasz Langa and Pablo Galindo Salgado will be recording the core.py podcast right on the conference stage. It will feature their special guest Guido van Rossum, the creator of Python.
April 29, 2026
PyCharm
Using Bag-of-Words With PyCharm
Have you ever wondered how machine learning models actually work with text? After all, these models require numerical input, but text is, well, text. Natural language processing (NLP) offers many ways to bridge this gap, from the large language models (LLMs) that are dominating headlines today all the way back to the foundational techniques of […]
PyCon
PyCon US 2026: Call for Volunteers
Real Python
AI Coding Agents Guide: A Map of the Four Workflow Types
AI coding agents come in four types: IDE, terminal, PR, and cloud. Learn how each workflow fits into modern Python development.
Quiz: ChatterBot: Build a Chatbot With Python
Test your understanding of the ChatterBot Python library, from training a basic bot with ListTrainer to wiring in a local LLM through Ollama.
Quiz: Python 3.13: A Modern REPL
Test your understanding of the redesigned Python 3.13 REPL with color support, multiline editing, paste mode, and history browsing.
Python GUIs
Actions in one thread changing data in another — How to communicate between threads and windows in PyQt6
I have a main window that starts background threads (e.g., handling GPIO data). From the main window I open secondary windows using buttons. When I press a button in a secondary window, I can't change anything in the background threads. But if I press a button in the main window, everything works. How do I communicate between a secondary window and a thread that was started from the main window?
April 28, 2026
Talk Python Blog
Introducing the new Talk Python web player
We expect that most people who listen to Talk Python do so through their podcast player apps on their phone or even on their laptops. But there are plenty of times that people end up on an episode page and would love to have a nice experience interacting with that episode as well. One really common example: you go back to an episode you discovered several years ago, and the chances it’s still on your device are low. Though we do keep our entire back catalog available in the RSS feed, most podcast players trim down what they keep locally.
PyCoder’s Weekly
Issue #732: Web Scraping, Altair Charts, OpenAI's API, and More (April 28, 2026)
Django Weblog
Renew Your PyCharm License and Support Django
Only a few days remain to support the Django Software Foundation through our annual JetBrains fundraiser.
You can now use the offer for new purchases and annual renewals. If your PyCharm Professional subscription expires this year, this is a great time to renew or extend it for up to 12 months.
Get 30% off PyCharm Professional, and 100% of proceeds from qualifying purchases and renewals go to the DSF to help fund Django Fellows, community programs, events, and the future of Django.
👉 Offer ends May 1: Learn more about the fundraiser
👉 Claim 30% off here: Get the JetBrains offer
Mariatta
PyCascades 2026 Recap
PyCascades 2026 Recap
PyCascades 2026 took place in Vancouver this year. I only get to attend on the first day, because I had a 5 a.m. flight to Washington DC the morning after.
Still, the first day’s talks were all very insightful and interesting. I’m waiting for all the talks to be published so that I could catch up on the ones I missed.
Here are notes on the talks I got to see.
Real Python
Testing Your Code With Python's unittest
Learn how to use Python's unittest framework to write unit tests for your code, including test cases, fixtures, and test suites.
Quiz: Use Codex CLI to Enhance Your Python Projects
Test your understanding of how to install Codex CLI, use Plan mode, and refine features with natural language in your terminal.
Quiz: Testing Your Code With Python's unittest
Test your understanding of Python unittest basics, including TestCase, assertions, fixtures, subtests, and test discovery.
PyPy
PyPy v7.3.22 release
PyPy v7.3.22: release of python 2.7, 3.11
The PyPy team is proud to release version 7.3.22 of PyPy after the previous release on March 13, 2026. This is a bug-fix release that fixes several issues in the JIT. Among them, a long-standing JIT bug that started appearing when some instance optimizations exposed it. We also cleaned up many of the remaining stdlib test suite failures, which improves CPython compatibility around line numbers in dis.dis, signatures and objclass attributes for builtins, and other quality of life features.
There is now an RPython _pickle module that mirrors
the CPython one, greatly speeding up pickling operations. Where before PyPy was
5.7x slower than CPython on the pickle benchmark from the pyperformance
benchmark suite, now it is only 1.6x slower [0]. We also added pypy
pickler extensions to dump and load lists using list strategies, and enabled
them in the ForkingPickler used by multiprocessing, speeding up cases where
such objects are passed between PyPy multiprocessing instances.
We also added an RPython json encoder, speeding up json_bench from being 2.6x slower than CPython to being 0.7x (meaning faster).
The release includes two different interpreters:
PyPy2.7, which is an interpreter supporting the syntax and the features of Python 2.7 including the stdlib for CPython 2.7.18+ (the
+is for backported security updates)PyPy3.11, which is an interpreter supporting the syntax and the features of Python 3.11, including the stdlib for CPython 3.11.15.
The interpreters are based on much the same codebase, thus the double release. This is a micro release, all APIs are compatible with the other 7.3 releases.
We recommend updating. You can find links to download the releases here:
We would like to thank our donors for the continued support of the PyPy project. If PyPy is not quite good enough for your needs, we are available for direct consulting work. If PyPy is helping you out, we would love to hear about it and encourage submissions to our blog via a pull request to https://github.com/pypy/pypy.org
We would also like to thank our contributors and encourage new people to join the project. PyPy has many layers and we need help with all of them: bug fixes, PyPy and RPython documentation improvements, or general help with making RPython's JIT even better.
If you are a python library maintainer and use C-extensions, please consider making a HPy / CFFI / cppyy version of your library that would be performant on PyPy. In any case, cibuildwheel supports building wheels for PyPy.
Footnotes
[0]Once a PR to pyperformance to use the _pickle module on PyPy is accepted
What is PyPy?
PyPy is a Python interpreter, a drop-in replacement for CPython It's fast (PyPy and CPython performance comparison) due to its integrated tracing JIT compiler.
We also welcome developers of other dynamic languages to see what RPython can do for them.
We provide binary builds for:
x86 machines on most common operating systems (Linux 32/64 bits, Mac OS 64 bits, Windows 64 bits)
64-bit ARM machines running Linux (
aarch64) and macos (macos_arm64).
PyPy supports Windows 32-bit, Linux PPC64 big- and little-endian, Linux ARM 32 bit, RISC-V RV64IMAFD Linux, and s390x Linux but does not release binaries. Please reach out to us if you wish to sponsor binary releases for those platforms. Downstream packagers provide binary builds for debian, Fedora, conda, OpenBSD, FreeBSD, Gentoo, and more.
What else is new?
For more information about the 7.3.22 release, see the full changelog.
Please update, and continue to help us make pypy better.
Cheers, The PyPy Team
Armin Ronacher
Before GitHub
April 27, 2026
Python Engineering at Microsoft
Python Environments Extension for VS Code- April Update
The April 2026 release update includes the Python Environments extension... Keep on reading to learn more!
The post Python Environments Extension for VS Code- April Update appeared first on Microsoft for Python Developers Blog.
Talk Python to Me
#546: Self hosting apps for Python people
The cloud is convenient until it isn't. You upload your photos, sync your contacts, click through the cookie banners. Then prices go up again or you read about a family that lost their entire Google account over a medical photo sent to a doctor. At some point, the question shifts from "why would I run this myself?" to "why aren't I?" My guest this week is Alex Kretzschmar, head of DevRel at Tailscale, longtime host of the Self-Hosted podcast, and co-founder of Linuxserver.io. We cover what self-hosting really means in 2026, the apps worth running yourself like Immich and Home Assistant, why Docker Compose ties it all together, and how Tailscale lets you reach any of it from anywhere, without opening a single port. If you've been thinking about pulling your digital life back behind your own walls, this is your roadmap.
EuroPython
Humans of EuroPython: Martin Borus
Today, we’d like to share an interview with Martin Borus, a member of the EuroPython 2025 Operations team and a returning conference contributor.
PyCon
Asking the Key Questions: Q&A with the PyCon US 2026 keynote speaker Lin Qiao
Ari Lamstein
A Web App for Exploring Foreign‑Born Population Trends
I just created a web app for exploring trends in the foreign-born population in the United States. The app lets you pick a location and see how the size of the foreign-born population there has changed over time. A core purpose of the project is to let people track how the foreign‑born population changes as […]
Rodrigo Girão Serrão
TIL #143 – Resolve a lazy import manually
Learn how to work around the Python machinery to resolve an explicit lazy import manually.
A couple of articles ago I wrote about how you could inspect a lazy import.
Apparently, you can use a similar trick to check the attributes and methods that a lazy import has:
>>> lazy import json
>>> dir(globals()["json"])
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'resolve']Apart from a large number of dunder methods and dunder attributes, you'll find the method resolve.
You can run help(globals()["json"].resolve) to get the help text on that method:
Help on built-in function resolve:
resolve() method of builtins.lazy_import instance
resolves the lazy import and returns the actual objectThis shows that it's the method resolve that resolves a lazy import.
If you call the method, you can get access to the resolved module:
>>> lazy import json
>>> resolved_json = globals()["json"].resolve()
>>> resolved_json
<module 'json' from '/Users/rodrigogs/.local/share/uv/python/cpython-3.15.0a8-macos-aarch64-none/lib/python3.15/json/__init__.py'>After calling resolve, the lazy module doesn't disappear automatically:
>>> globals()["json"]
<lazy_import 'json'>Which shows that the mechanism that's responsible for reification most likely calls the method resolve and then reassigns the name of the module to the module returned by resolve.
In a way, it's as if the reification process ran something like
globals()["json"] = globals()["json"].resolve()In hindsight, this isn't too surprising. After all, Python tends to be very consistent. The only mistery that remains is what triggers the reification process. How is it that Python can detect when something touches the lazy import..?
Real Python
How to Conceptualize Python Fundamentals for Greater Mastery
Master Python fundamentals by learning how to conceptualize core concepts like variables, loops, and functions for better understanding and retention.
Django Weblog
It's time to redesign djangoproject.com
If you've felt like djangoproject.com could use a refresh, you're not alone. The site has served the community well for a long time, it’s beloved by a lot of people but doesn’t reflect where Django is today or who we want to reach. We've been working on a redesign behind the scenes, and we want to share where we're headed and how you can get involved.
Why a redesign
The case has been building for a while. The excellent user research report from 20tab documented in detail what current site users struggle with, and the more recent community discussion on homepage redesigns on the forum focuses on the image issue.
In her recent talk Debunking Django Myths, Sarah Boyce, one of our Django Fellows who helps maintain the project, walked through the gap between how Django is perceived and what it actually offers in 2026. Our website is one of the places where the gap is widest, and we need to close it.
Debunking Django Myths - Sarah Boyce @ Python Unplugged on PyTV
It’s harder than it looks on the surface, as it’s essential the site serves both as a showcase of the value of Django for newcomers; and as a central information space for our users; and as an online and in-person community hub; and a fundraising and sustainability tool for our Django Software Foundation.
How we're approaching this
We're planning the work in three phases.
Discovery and groundwork. This is where we’re at right now. Before anything gets designed, we need clarity on what the site should communicate: Django's value, who we're speaking to, and what success looks like. That means a marketing strategy (at least bigger-picture). Possibly additional user research focused on new users. Definitely site analytics so we know how different aspects of the site are working. And a redesign brief we can share with UX and visual design experts. We also need to be building up capacity in UX, Information Architecture (IA), and marketing, since those areas of expertise are essential for the success of the website but not well represented in our working groups.
Design. From there we'll move into IA, mockups, and low-fidelity prototypes. We expect this visual work will be component-driven, producing a small design system and pattern library that can support a section-by-section rollout rather than a big-bang launch. The homepage is the most visible surface and a natural focus, but it might be easier for our volunteers to first look at more specific sections (docs, donation flows, community) before tackling the more complex multi-purpose areas.
Build. For that, we want to work with our existing volunteer contributors as much as possible, so implementation will be incremental against mockups that reflect the long-term goal. This keeps the site working and evolving while we make progress on the design.
Who's doing the work
We hope to do most of this with existing volunteers. The Website working group, the Accessibility team, and the Social Media working group. Working with paid contractors for specific tasks if Django Software Foundation finances allow. A project this size really needs both: the continuity of volunteers who know Django and our community and Foundation, and focused professional time for the pieces that need it.
Where you come in
If you have relevant experience in any of the following, we'd genuinely love to hear from you:
- UX and interaction design
- User research
- Visual design
- Information Architecture, content strategy, or copywriting
- Marketing
Check out the Django forum thread we’re using for ongoing updates, come say hi in DMs, or chime in on the tracking issue for this work. Our Discord server is a good place to reach out too.
And separately - a good redesign will cost real money. We'd like some of this work to be handled by paid contractors where it makes sense, and that depends on what the Foundation can afford. If you're in a position to support the DSF financially, it directly helps us make that possible. Thanks for caring about this! Let's make djangoproject.com as good as the framework and community it represents.