Python News Roundup: April 2025

Python 3.14.0a6 Released on Pi Day

The Python development team has rolled out the sixth alpha version of Python 3.14, marking the penultimate release in the planned alpha series. The date of this particular preview release coincided with Pi Day, which is celebrated annually on March 14 (3/14) in the honor of the mathematical constant π, traditionally marked by eating pies.

As always, the changes and improvements planned for the final Python 3.14 release, which is slated for October later this year, are outlined in the changelog and the online documentation. The major new features include:

• PEP 649: Deferred Evaluation of Annotations
• PEP 741: Python Configuration C API
• PEP 761: Deprecating PGP Signatures for CPython Artifacts
• Improved Error Messages
• A New Type of Interpreter
• Support for UUID Versions 6, 7, and 8
• Python Removals and Deprecations
• C API Removals and Deprecations

Compared to the previous alpha release last month, Python 3.14.0a6 brings a broad mix of bug fixes, performance improvements, new features, and continued enhancements for tests and documentation. Overall, this release packs nearly five hundred commits, most of which address specific pull requests and issues.

Remember that alpha releases aren’t meant to be used in production! That said, if you’d like to get your hands dirty and give this early preview a try, then you have several choices when it comes to installing preview releases.

If you’re a macOS or Windows user, then you can download the Python 3.14.0a6 installer straight from the official release page. To run Python without installation, which might be preferable in corporate environments, you can also download a slimmed-down, embeddable package that’s been precompiled for Windows. In such a case, you simply unpack the archive and double-click the Python executable.

If you’re on Linux, then you may find it quicker to install the latest alpha release through pyenv, which helps manage multiple Python versions alongside each other:

$ pyenv update
$ pyenv install 3.14.0a6
$ pyenv shell 3.14.0a6
$ python --version
Python 3.14.0a6

Don’t forget to update pyenv itself first to fetch the list of available versions. Next, install Python 3.14.0a6 and set it as the default version for your current shell session. That way, when you enter python, you’ll be running the sixth alpha release until you decide to close the terminal window.

Alternatively, you can use Docker to pull the corresponding image and run a container with Python 3.14.0a6 by using the following commands:

$ docker run -it --rm python:3.14.0a6
Python 3.14.0a6 (main, Mar 18 2025, 03:31:04) [GCC 12.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> exit

$ docker run -it --rm -v $(pwd):/app python:3.14.0a6 python /app/hello.py
Hello, World!

The first command drops you into the Python REPL, where you can interactively execute Python code and test snippets in real time. The other command mounts your current directory into the container and runs a Python script named hello.py from that directory. This lets you run local Python scripts within the containerized environment.

Finally, if none of the methods above work for you, then you can build the release from source code. You can get the Python source code from the downloads page mentioned earlier or by cloning the python/cpython repository from GitHub:

$ git clone git@github.com:python/cpython.git --branch v3.14.0a6 --single-branch
$ cd cpython/
$ ./configure --enable-optimizations
$ make -j $(nproc)
$ ./python
Python 3.14.0a6 (tags/v3.14.0a6:77b2c933ca, Mar 26 2025, 17:43:06) [GCC 13.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

The --single-branch option tells your Git client to clone only the specified tag (v3.14.0a6) and its history without downloading all the other branches from the remote repository. The make -j $(nproc) command compiles Python using all available CPU cores, which speeds up the build process significantly. Once the build is complete, you can run the newly compiled Python interpreter with ./python.

PEP 758: Parenthesized Exceptions (Accepted)

After extensive discussions on the Python forum, the community has reached an agreement on the final shape of PEP 758, which proposes to drop the mandatory parentheses around multiple exception types being intercepted. This proposal has been accepted by the Steering Council and is expected to be delivered with Python 3.14 later this year.

Currently, when you want to catch multiple exceptions and handle them with the same block of code, Python requires you to enclose the exception types in parentheses. This applies to both the standard except clause and the newer except* expression used for exception groups. Omitting the parentheses results in an immediate syntax error:

>>> from pathlib import Path
>>> path = Path("/root/.python_history")
>>> try:
...     print(path.read_text(encoding="utf-8"))
... except FileNotFoundError, PermissionError:
...     print(f"Couldn't open the file: {path}")
...
  File "<python-input-4>", line 3
    except FileNotFoundError, PermissionError:
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
SyntaxError: multiple exception types must be parenthesized

Fixing this problem boils down to adding a pair of parentheses around the listed exceptions, just as the error message above suggests:

>>> try:
...     print(path.read_text(encoding="utf-8"))
... except (FileNotFoundError, PermissionError):
...     print(f"Couldn't read the file: {path}")
...
Couldn't open the file: /root/.python history

One could argue that this requirement makes the syntax inconsistent with other comma-separated constructs in Python, where parentheses are optional. For example, tuple literals and generator expressions can sometimes get away without them.

This somewhat surprising behavior was carried over from legacy Python 2, where parentheses were necessary to avoid ambiguity due to the language’s peculiar syntax. You can expand the collapsible section below to find out more details about it:

# Python 2.x

import codecs

path = "/root/.python_history"

try:
    with codecs.open(path, mode="rb", encoding="utf-8") as file:
        print file.read().decode("utf-8")
except (IOError, LookupError), ex:
    print ex

# ...

try:
    with codecs.open(path, mode="rb", encoding="utf-8") as file:
        print file.read().decode("utf-8")
except IOError, ex:
    print ex

This old quirk was one of many changes addressed in Python 3. Now, the equivalent syntax for intercepting raised exceptions looks like this:

>>> try:
...     print(path.read_text(encoding="utf-8"))
... except (FileNotFoundError, PermissionError) as error:
...     print(error)
...
[Errno 13] Permission denied: '/root/.python_history'

Instead of a comma, you use the as keyword to declare a variable scoped to the immediate except block. In this case, parentheses help communicate that Python binds one of the listed exception types to the variable error.

Now, imagine skipping the parentheses for the same expression:

except FileNotFoundError, PermissionError as error:

Which of the two exception types does the as statement bind the variable to? If you followed the same logic as used in structural pattern matching, then only the last exception type, PermissionError, would be bound to the variable error. But that’s not what actually happens in this context!

To prevent confusion, the new PEP 758 will only allow skipping the parentheses when the expression appears without the as keyword, like in the first example in this section. Otherwise, the code will result in the same syntax error you saw earlier.

Going forward, you’ll have a choice whether to use the parentheses or not when catching multiple exceptions. But you won’t have easy access to the raised exception without them. In practice, this PEP introduces a cosmetic change that will probably make the language slightly more appealing to beginners, though experienced programmers are unlikely to notice much difference.

PyCon US Travel Grants Break Records

The organizers of PyCon US 2025 received an unprecedented number of travel grant applications, breaking another record with 952 submissions from 87 countries, totaling nearly $1.7 million in requested aid. Despite a budget of $266,000 for travel grants, the team was able to offer 272 full travel grants and 33 ticket-only grants, amounting to approximately $384,000—about 23% of the total requests.

Funding for these grants comes from various sources, including PyCon US ticket sales, sponsorships, contributions from Python Core Developers, the Packaging Working Group, the Python Software Foundation (PSF), and generous donations from PyLadies. Additionally, the OpenEDG Python Institute provided direct sponsorship for the 2025 travel grants.

The selection process prioritized global representation, first-time attendees, individuals seeking job opportunities, as well as students, educators, and community organizers. Notably, about 75% of the awarded funds were allocated to applicants from 58 countries outside the United States, emphasizing PyCon US’s commitment to fostering a diverse and international Python community.

For more details on the travel grant process, you can read the full blog post.

The PSF Awards Thomas Wouters

The Python Software Foundation (PSF) has awarded Thomas Wouters with a Distinguished Service Award in recognition of his exceptional contributions spanning over 25 years. Thomas has helped lead important projects, including managing the releases of Python 3.12, 3.13, and 3.14. He has also served on key leadership groups like the Python Steering Council and the PSF Board.

In addition to his technical achievements, Thomas is widely admired for his efforts to make the Python community friendly and open to everyone. His work continues to inspire developers around the world, helping to ensure Python remains accessible and welcoming to all.

Read more in the PSF blog announcement.

Major Python Libraries Updated

The Python ecosystem is constantly evolving, with ongoing improvements to tools, frameworks, and libraries. Several important Python projects released updated versions last month.

What’s Next for Python?

With the Python 3.14 alpha series nearing completion, the next significant milestone will be the first beta release, bringing us one step closer to the stable release scheduled for October. The recently accepted PEP 758 and the enhancements outlined in Python 3.14’s roadmap promise to make Python more intuitive and robust.

Also, keep an eye out for Django 5.2, scheduled for release later this month. This long-term support version includes eagerly anticipated features like native support for composite primary keys, making your web applications more efficient and powerful.

Stay tuned for more updates, and as always, happy Pythoning!