by Bartosz Zaczyński Publication date Nov 10, 2025 Reading time estimate 26m community news

Python 3.14 is out now, bringing t-strings, deferred annotations, better error messages, and plenty more to explore. As developers start adopting the new version, Python 3.15 begins its alpha phase, and Python 3.9 officially retires. Meanwhile, Django 6.0 enters beta, new PEPs propose lazy imports and changes to the assert syntax, and the PSF makes waves with a notable funding decision.

Here’s what’s been happening in the world of Python!

Python Releases

Last month’s headline news was the release of Python 3.14—a milestone update that introduces significant enhancements to the language itself and its runtime. Meanwhile, hot on its heels, the core team has begun development of Python 3.15. As Python continues to evolve, we must also bid farewell to an older release. Python 3.9 has reached its end of life, reminding everyone to keep their environments up to date for safety and support.

Python 3.14 Final Released

Python 3.14.0 was released on October 7, 2025, delivering a packed set of improvements and new capabilities. This is a major release that the community has been eagerly awaiting, and it doesn’t disappoint. Some of the most notable features of Python 3.14 include:

• Deferred annotations by default: Following years of work on PEP 563, PEP 649, and PEP 749, Python now evaluates type annotations lazily. Forward references in annotations no longer need a special __future__ import, and a new annotationlib module provides tools to introspect annotations as real objects instead of strings.
• Template strings (t-strings): PEP 750 introduces t-strings, a new string literal prefix t"" that returns a Template object, capturing both static and interpolated parts of the string. This feature enables custom processing of string templates and safer substitution patterns, offering a more controlled alternative to f-strings.
• Modernized REPL and error messages: Building on improvements from Python 3.13, the interactive Python REPL gets real-time syntax highlighting and smarter auto-completion. Syntax and runtime errors are also more informative and user-friendly, helping developers diagnose issues faster.
• Multiple interpreters in the standard library: PEP 734 adds a concurrent.interpreters module, finally exposing Python’s long-existing multiple interpreter support to Python code. This allows spawning isolated interpreters within a single process, unlocking new concurrency models and multi-core usage without separate processes.
• Free-threaded Python: An officially supported build variant allows running Python without the Global Interpreter Lock (GIL), paving the way for true multi-core parallelism.

In addition to these headline features, Python 3.14 comes with numerous smaller enhancements and optimizations. There’s a new compression.zstd module for Zstandard compression (PEP 784) and support for UUID versions 6-8 with faster generation for existing versions. Additionally, there are optional brackets in except statements (PEP 758) and built-in HMAC implementations from the HACL* project for improved security.

The standard library tools like unittest, argparse, json, and calendar now produce colored output on the terminal, and the new zero-overhead debugger interface (PEP 768) lays the groundwork for more powerful debugging tools. Official installers for Python 3.14 even include an experimental JIT compiler enabled by default, hinting at performance boosts on the horizon.

With so much new in Python 3.14, now is a great time to experiment with it. Many of these features, like t-strings and annotation changes, are fully available by default, while others, such as the no-GIL build or JIT, may require special opt-in. You can read more in the official What’s new in Python 3.14 document for a comprehensive overview.

As always, be sure to check that your critical third-party libraries support Python 3.14 before upgrading in production, but initial support is strong with many popular projects already shipping wheels for 3.14. Congratulations to the core developers and community on this significant release!

Python 3.15 Alpha 1 Released

Even as Python 3.14 takes center stage, the core development team has promptly turned the page to Python 3.15. In mid-October, Python 3.15.0a1 was released as the first alpha of the next version. This overlap is part of Python’s now-annual cadence—while one version is finalized, planning and development for the next are already in motion.

Python 3.15 is scheduled for final release in October 2026. The alpha period, which will run through April 2026, is when new features land. As of alpha 1, only a few initial enhancements are present, since many features are still under development.

Notably, Python 3.15.0a1 includes PEP 686, which will make UTF-8 the default character encoding for open files, eliminating locale-dependent default encodings. It also has a new dedicated profiling API (PEP 799) to better support performance, and a C API for more efficient bytes object creation (PEP 782). Naturally, improvements to error messages continue as well.

Alpha releases are intended for testing only. You wouldn’t use them in production, but they’re invaluable for library maintainers and curious users to try out emerging changes. If you maintain a distribution package, now is a good time to start ensuring compatibility with Python 3.15. And if you’re just interested in what’s coming, you can install a pre-release version alongside your stable Python.

The Python 3.15 Release Schedule lays out the roadmap with monthly alpha releases through early 2026, a feature freeze by May (beta phase), and a final 3.15.0 release. This overlapping development cycle means we get to enjoy new Python features every year without missing a beat.

One side benefit of testing alpha releases is that you can provide feedback or catch regressions early. So, if you have time, give 3.15.0a1 a spin in a test environment. It’s an exciting glimpse into Python’s future, even if most of the big changes are yet to come in subsequent alphas.

Python 3.9 Reaches End of Life

Exactly five years after its initial release, Python 3.9 has officially reached its end of life (EOL) as of October 2025. This means that Python 3.9 will no longer receive security fixes or bug patches going forward. If you’re still using Python 3.9 in any projects, then now is the time to plan an upgrade to a later version—Python 3.10 or later—because continuing to run an EOL Python version poses security risks.

The end of life comes as no surprise. PEP 596 set Python 3.9’s support timeline to expire in October 2025. The core developers prepared one final security release, Python 3.9.25, which was published on Halloween (October 31, 2025) as a last hurrah for the 3.9 series. In a lighthearted announcement, release manager Łukasz Langa quipped that:

Python 3.9 is now officially dead… since it’s Halloween 🎃 (Source)

With that release, the 3.9 branch in CPython’s GitHub repository is now closed, and no further updates will be made.

Why does this matter? Running an unsupported Python means that any new vulnerabilities discovered in the interpreter or the standard library won’t be patched for that version. In today’s security climate, that’s a serious concern.

Additionally, many major projects in the Python ecosystem stop supporting a Python version once it’s EOL. For example, NumPy and various other libraries have already dropped support for 3.9 or will do so now that it’s retired. Over time, you’ll find it harder to install or update packages if you’re stuck on Python 3.9.

Upgrading to a newer Python brings security, peace of mind, and access to all the features and performance improvements added in the last few years (3.10, 3.11, 3.12, 3.13, and now 3.14). The Python Software Foundation (PSF) and the community strongly encourage users to upgrade as soon as feasible. If you’ve been comfortable on Python 3.9 until now, a good target is to jump to 3.13 or 3.14, which will be supported for the longest time into the future.

Farewell, Python 3.9. As Łukasz Langa noted, it was a pivotal release that introduced many things, like the new parser enabling structural pattern matching, and the move to annual releases. But it’s time to move on to newer, greater things. If you haven’t already, consider this your wake-up call to upgrade and experience what modern Python has to offer.

Django 6.0 Beta 1 Released

The Django team has given us a first peek at Django 6.0, releasing Django 6.0 beta 1 on October 22, 2025. This beta marks the second stage of Django’s 6.0 release cycle and is a chance for developers to try out the upcoming features and changes in one of the most popular Python web frameworks.

Django 6.0 is shaping up to be an ambitious release. According to the in-development release notes, several significant new features are included:

• Content Security Policy (CSP) support: Django 6.0 adds built-in support for setting Content Security Policy headers to mitigate cross-site scripting (XSS) and other injection attacks. A new middleware, context processor, and settings will make it easier to declare and enforce CSP rules in your Django apps.
• Template partials: The Django template language gains support for template partials. You can define reusable named snippets within a template using the {% partialdef %} tag and render them with {% partial %}. This feature allows for cleaner, more maintainable templates without repetition or splitting everything into separate files.
• Background tasks framework: Django 6.0 introduces a new built-in Tasks framework for running background jobs outside the request–response cycle. You can decorate functions with @task and enqueue them via the provided API, and Django will integrate with task runner processes. Note that while the framework provides the queuing hooks, you’ll still need an external worker or process to consume and execute the tasks.
• Modernized email backend: Django updates its email utilities to use Python’s EmailMessage API under the hood. This replaces the older legacy email approach and improves Unicode handling. For most users, this change will be behind the scenes, but it modernizes a core component.
• Python 3.12+ only: Notably, Django 6.0 supports only Python 3.12, 3.13, and 3.14 as runtime environments. The previous version, Django 5.2, is the last to support Python 3.10 and 3.11. So, Django is dropping older Python support and embracing the latest versions, which brings performance and typing improvements but means you’ll need to upgrade Python before adopting Django 6.0.

Under the hood, there are many other tweaks and deprecations. For example, new QuerySet fetch modes were added. The release notes hint at improvements to how QuerySet.raw() and subqueries behave with composite primary keys, and certain legacy APIs related to queryset prefetching have been removed in line with deprecations from Django 5.x.

As always with a major Django release, you’ll want to read the release notes carefully for any breaking changes. According to Django’s roadmap, a release candidate for 6.0 is expected in a few weeks, and the final Django 6.0 release is planned for early December, around December 3, 2025. That means now is the ideal time for Django developers to install the beta and test their projects.

The Django team explicitly asks the community to test things early and often to help catch bugs before the final release. If you do try the beta, remember that only bugs in new features or regressions will be fixed between now and the final, so focus your testing on the new functionality and any upgrade issues.

You can install Django 6.0 beta 1 from PyPI:

As with all pre-releases, it’s not for production use, but it’s a great opportunity to prepare your projects and plugins for the coming changes. Django 6.0 looks to continue Django’s tradition of evolving with the times, adding features developers need while maintaining that batteries-included ethos. Give it a try and provide feedback to make the final release as robust as possible!

PEP Highlights

Two Python Enhancement Proposals have been in the spotlight recently, each with a very different outcome. One is a draft PEP that could bring explicit lazy imports to the language, potentially speeding up application startup times. The other is a PEP proposing a tweak to the assert statement syntax, which was debated and ultimately rejected by Python’s Steering Council.

Here’s a closer look at what’s being proposed (or not) in these PEPs and what it means for Python developers.

PEP 810 Drafted: Explicit Lazy Imports

Currently, Python developers who want to defer imports have a few workarounds available, though none are ideal:

• The most common approach is to move imports inside functions or methods so they only execute when that code path runs.
• Another technique involves using importlib.import_module() to dynamically load modules on demand, but this requires extra code and loses the clarity of standard import statements.
• Some projects use third-party solutions or custom import hooks, but these can be fragile and hard to maintain.

While these techniques work, they often make code less readable and require developers to manually manage what should be a straightforward task.

Explicit lazy imports (PEP 810) is a newly drafted proposal that suggests adding a lazy import syntax to Python. The idea is to allow developers to mark specific import statements as lazy, meaning the module won’t actually be loaded until the first time it’s used. This could significantly reduce startup time and memory overhead for certain applications.

The motivation behind lazy imports is clear. In many Python programs, especially those with many dependencies, importing every module upfront can waste time and memory if some of them are never actually needed at runtime. PEP 810 aims to provide a first-class language feature to defer imports in a controlled, opt-in way.

Under this proposal, you could write code like this:

When using the lazy import statement, Python would bind the name immediately but not execute the target module’s code until the first time you actually use that name. After that, it’d behave just like a normal import. The key idea is that nothing happens until first use.

It’s important to note that PEP 810 is still a draft and hasn’t been accepted yet. If it is indeed accepted, then it would likely target Python 3.15, as that’s the version mentioned in the PEP. We might see it in action in the alpha releases later in the Python 3.15 development cycle. For now, it’s an exciting idea that could give Python applications a speed boost without compromising readability.

PEP 679 Rejected: New Assert Syntax

Not all PEP ideas make it into Python. One recent proposal that was rejected is PEP 679, which aimed to introduce a new assert statement syntax using parentheses. Specifically, PEP 679 proposed allowing syntax like below to be interpreted as a valid assertion:

This would’ve been a small change to make the assert statement more foolproof for beginners, but after consideration, the Steering Council decided against it.

Why was this PEP needed in the first place? It addresses a well-known pitfall: if you mistakenly put parentheses around the condition and message in an assert statement—thinking assert is a function—Python currently sees it as a single tuple. Consequently, the assertion will always succeed because a non-empty tuple is truthy:

This code example doesn’t do what you intend. It effectively asserts a Python tuple, not the comparison. This mistake is common enough that Python 3.10 and later already emits a SyntaxWarning when it detects an assert (expression, "message") pattern.

PEP 679 wanted to go further and officially support parentheses in assert, so that the above code would be correctly understood as assert expression, "message" rather than a tuple. The rationale was that this could eliminate the footgun entirely and also allow nicer formatting of long assertions over multiple lines without using backslashes (\).

However, on October 24, 2025, the Steering Council announced that they had rejected PEP 679. In their reasoning, they acknowledged that the problem is real, but felt that the existing warning is sufficient to catch most cases. Transitioning to a new special-case syntax would add complexity to the language and potentially confuse learners. Ultimately, they concluded that the benefit was not compelling enough to justify the change.

The Python community has been as active as ever, with several notable events and announcements this past month. From major conference updates and funding decisions to personal milestones and new publications, there’s been plenty happening beyond the core language itself. Up next—a closer look at a few of these community updates.

PyCon US 2026 Opens the Call for Proposals

PyCon US 2026 is coming, and the Call for Proposals (CFP) is now open! PyCon US will be hitting the West Coast. For the first time ever, the conference is taking place in Long Beach, California. The dates are set for May 13–19, 2026, with the main conference talks scheduled for May 15–17.

The PyCon team just launched the 2026 conference website:

PyCon US 2026 Website

They’re inviting talk proposals, tutorial ideas, posters, and Charlas (Spanish-language talks) from speakers of all experience levels and backgrounds. If you have something interesting to share about Python, whether it’s a beginner-friendly introduction or an advanced deep dive, PyCon wants to hear from you. The deadline to submit proposals is December 19, 2025, so you have until then to craft and submit your ideas.

PyCon US 2026 will follow an in-person format with no livestreams. Recordings of all talks and keynotes will be made available on YouTube afterward. Notably, the PyCon organizers highlighted new thematic talk tracks this year:

1. The Future of AI with Python
2. Trailblazing Python Security

These focused tracks suggest the conference is especially interested in content around AI/ML and security topics, given how critical and popular those areas are in the Python world right now.

For more details on how to submit a proposal, check out the PyCon US 2026 CFP page and the official PyCon blog post. Whether you want to give a talk, run a tutorial, or present a poster, now’s the time to start planning. PyCon’s slogan is “come for the language, stay for the community,” and contributing a proposal is one of the best ways to be part of that community.

Good luck to all who submit. Maybe we’ll see you on stage in Long Beach next year!

PSF Pulls $1.5M Government Grant Proposal

In a bold move, the Python Software Foundation has withdrawn a $1.5 million grant proposal that it had submitted to a U.S. government program earlier this year. The PSF’s decision, announced in late October, was driven by concerns that accepting the grant would force the organization to compromise on its core values around diversity and inclusion.

Back in January 2025, the PSF applied for a National Science Foundation grant under a program aimed at improving open-source security, specifically to fund work on Python and PyPI security enhancements. The good news is that the proposal was approved for funding. The bad news is that it came with strings attached. After the approval, the NSF included a clause requiring that grant recipients:

(…) not operate programs that advance or promote diversity, equity, and inclusion. (Source)

In other words, to take the money, the PSF would have to essentially suspend or eliminate any DEI initiatives. For an organization like the PSF, this was a show-stopper. The PSF’s mission explicitly includes supporting a diverse Python community.

In their public statement, the PSF noted that DEI is central to its mission and values, and such a restriction is intrinsically incompatible with those values. Moreover, the clause was so broad that it could affect all PSF activities, not just how the grant money was used, and even threatened clawbacks of funds if violated, which is a risk the board was not willing to accept.

As a result, the PSF’s Board of Directors unanimously voted to withdraw the grant application and decline the funding. If you value what the PSF does, from PyCon to PyPI to community grants and more, consider contributing in whatever way you can. The foundation’s strength comes from Python’s community, and this incident is a reminder of how closely they’re intertwined.

Christopher Bailey Becomes a PSF Fellow Member

We’re delighted to share some great news from within the Real Python family. Christopher Bailey has been inducted as a PSF Fellow for 2025 Q3:

Christopher Bailey, PSF Fellow

As many of you know, Christopher is the host of The Real Python Podcast and an all-around community contributor. The Python Software Foundation awards the Fellow distinction to individuals who have made significant contributions to the Python community, and Christopher certainly fits that bill.

This honor recognizes his contributions to Python education and outreach, not only through the podcast where he interviews developers and shares insights but also through his involvement in community events and initiatives. Fellows are nominated by their peers and approved by the PSF, so it’s a special form of recognition from the community.

From all of us at Real Python, congratulations to Christopher on becoming a PSF Fellow! It’s well-deserved, and we’re proud to have a colleague who creates fantastic content for Python learners while also being acknowledged at the highest levels of the community for his impact. If you haven’t listened to The Real Python Podcast, then this is a great time to check it out and see why Christopher’s work is so valued.

And yes, that means we now have a PSF Fellow on the Real Python team. How cool is that?

Talk Python in Production Book Published

Python developers looking to level up their deployment and infrastructure skills have a new resource to dive into. Michael Kennedy, host of the Talk Python To Me podcast, has released a new book titled Talk Python in Production. The book was just published in October and is Michael’s first solo book project:

Talk Python in Production by Michael Kennedy

In the book, Michael shares a decade’s worth of experience managing the infrastructure for Talk Python’s online services. The book is designed as a hands-on guide for Python developers who want to master real-world deployment and DevOps practices.

It takes what he calls a “stack-native” approach, focusing on how to run your applications on your own servers. For example, rather than relying purely on proprietary cloud services, it encourages the use of Docker and Nginx in a cost-effective and scalable way.

Some of the topics covered include:

• Containerizing applications with Docker
• Using Nginx as a reverse proxy and for TLS
• Setting up continuous deployment
• Leveraging CDNs and caching for performance
• Monitoring your applications

The philosophy is to show how a small team—or even a solo developer—can run a full web application stack with minimal cloud lock-in and at a fraction of the cost of hyper-scaled architectures. As the book’s description puts it, it’s about having more control over your deployment and avoiding unnecessary complexity.

The book also comes with extra goodies, including an accompanying GitHub repository of code examples and configurations, high-resolution diagrams, and even audio segments where Michael discusses each chapter. They’re kind of like mini-podcasts, which enrich the learning experience. He’s really packed it with supplementary resources to make it as practical as possible.

Early feedback on the book has been very positive, with readers saying it’s a refreshing take on Python deployment that cuts through the buzzwords and overly complex setups.

If you’ve ever felt intimidated by deploying your Python apps or are tired of feeling locked into expensive cloud services, this book might be exactly what you need. Michael’s writing style and teaching approach—as podcast listeners will know—is clear and accessible, so the content is approachable even if you’re not a DevOps guru.

You can find Talk Python in Production on Talk Python’s website, with options to buy an e-book or read it online. It’s also available in print on Amazon. You can also listen to an interview with Michael about the book on The Real Python Podcast, episode 272.

Congratulations to Michael on the launch of the book! It’s always great to see new learning material from folks in the community, and this one looks like it’ll help a lot of developers confidently take their code into the production realm.

Real Python Roundup

The Real Python team published another set of learning resources last month to help you stay ahead with Python and beyond. Whether you’re polishing your fundamentals or diving into advanced topics, there’s always something new to spark your curiosity. You can take your first steps with Python, explore the latest language features, or dive deeper into everyday topics like logging, optional arguments, and data analysis with Polars and pandas.

New video courses dive into some of the most practical and intriguing corners of Python. You’ll get up to speed with new features in Python 3.14, explore how descriptors power object-oriented design, and learn to speed up your code with concurrency. There’s even a hands-on data exploration project that combines Polars and interactive marimo notebooks.

If you want to put your Python knowledge to the test, last month’s quizzes are a great place to start. You can review the new features and syntax improvements in Python 3.14, revisit the essentials of getting started with the language, and challenge yourself with topics like optional arguments, logging, and data handling with Polars. Each quiz is a quick, interactive way to reinforce what you’ve learned and keep your skills sharp.

If you love discovering how Python is used in the real world, tune in to The Real Python Podcast. Join Christopher Bailey as he chats with developers, educators, and community voices about everything from getting started with Python and optimizing performance to exploring version 3.14’s new features. It’s a great way to stay inspired and deepen your Python knowledge wherever you are.

Real Python’s reference area keeps growing, offering a quick, reliable way to look up key Python terms and concepts. With hundreds of concise entries, each linked to in-depth tutorials, courses, and quizzes, you can get clear definitions at a glance or dive deeper when you’re ready to explore. It’s a handy resource for learners at every stage of their Python journey.

What’s Next for Python?

November brings an exciting milestone for the Python community with the official release of Python 3.14. This update introduces a range of improvements, from clearer syntax error messages to new language features that refine how developers write and debug code. As the community begins to adopt the new release, discussions around performance, backward compatibility, and library support are already gaining momentum.

Looking ahead, we’ll keep you up to date with practical guides, deep dives into new tools, and stories from across the ecosystem. Whether you’re just getting started with Python or refining your expertise, we’ll help you navigate what’s new, what’s changing, and what’s coming next. Until then, keep experimenting, stay curious, and most importantly, happy Pythoning!