Python is a widely-used programming language that has undergone significant development in recent years. Python 3.11 is set to bring new and improved features to the language, with the active involvement of the community in its development and the creation of an annual release cycle.
The Faster CPython project at Microsoft suggests that we can expect to see further evolution and advancements in Python’s efficiency and syntax in the coming years.
Some key features that have been added in this new version of Python include improvements in performance, syntax, and the standard library. This includes changes to the memory management system and new features to optimize function calls at runtime, new ways to define and call functions, as well as new ways to work with collections of data.
The standard library has also been updated to include new modules and functions that make it easier to work with common tasks such as working with dates and times, network programming, and cryptography.
With the release of the latest version, Python 3.11, there are several new and enhanced features that developers should be aware of.
These include:
- improved performance,
- enhanced support for parallelism and concurrency,
- and new language features such as pattern matching and improved typing.
Python 3.11 is set to be released on October 24th, 2022, and is sure to bring new and exciting features that will make programming in Python even more efficient and enjoyable. As a developer, it’s important to stay up-to-date with the latest version of Python to take advantage of the new and enhanced features it offers.
What’s new in Latest version of python?
This achievement has been possible, among other things, without needing to alter the memory consumption of Python 3.11, which has remained unchanged until now. In fact, the changes have come from two main areas, as explained by the Python developers in their documentation:
- The startup speed: “In Python 3.11, the core modules essential to Python startup are ‘frozen’. This means that their code objects are statically allocated by the interpreter”
- Runtime acceleration: “Python frameworks are created every time Python calls a Python function. The structure of the internal framework has been optimized to contain only essential information. Previously, they contained additional debugging and memory management information “.
- Related to the latter, a basic aspect of how Python works has changed: if before every call to a Python function called, in turn, a C function that interpreted it, now when CPython detects a Python function calling another Python function , sets up a new framework and “jumps” to the new code within it, which avoids calling the C interpret function.
Syntax Changes in Python 3.11
There are a few new syntax changes in Python 3.11. For one, dictionary values can now be accessed with square brackets, like so:
my_dict = {‘a’: 1, ‘b’: 2}
print(my_dict[‘a’])
This prints out 1, as expected. Additionally, you can now use the yield keyword in generators, and the main module is now run when you execute a Python script. These are just a few examples—for a more comprehensive list, check out the official documentation.
Key Enhancements in Python 3.11
Python 3.11 is the latest release of the Python language. It comes with several enhancements and changes, which we’ll take a look at in this article.
Some of the key enhancements include:
- A new, more efficient garbage collector
- Built-in TLS support
Error signaling improvements
The latest advancement in code debugging interpreters is the inclusion of error signaling through console messages. With version 3.11, instead of just identifying the line, the specific expression that caused the exception will be highlighted.
For example, for the following code:
def division(x: int, y: int):
return x / y
print(division(10, 0))
We are shown the following exception:
Exception handling improvements
The idea of Exception Groups has been introduced, enabling the grouping of multiple exceptions and utilizing the new “except*” syntax for managing them. This allows for multiple blocks of code to be executed within a single “try” block, effectively managing concurrent and nested exceptions. As an example, the following code demonstrates the handling of two grouped exceptions:
try:
raise ExceptionGroup(“group”, [TypeError(), ValueError()])
except* ValueError:
print(“This will be handled first.”)
except* TypeError:
print(“Then this will be handled.”)
On the other hand, adding notes to increase their contextual information is also introduced to exceptions. For this, the new method is used add_note().
try:
raise TypeError(“Bad type”)
except TypeError as e:
e.add_note(“Extra information”)
raise
Support for the TOML format
The latest version of Python is the tomllib module, which is responsible for parsing the widely-used TOML format. This format has become the go-to choice for new metadata storage format for Python programs. The tomllib module is easy to use and it allows you to easily read and write TOML files:
import tomllib
with open(“pyproject.toml”,”rb”) as f:
data = tomllib.load(f)
By using the function loads, we can also work with python strings:
import tomllib
data = “””
python-version = “3.11.0”
dependencies = [
“numpy>=1.23.0”
]
“””
tomllib.loads(data)
The addition of type annotations to the standard library
Perhaps the most significant change in Python 3.11 is the addition of type annotations to the standard library.
This allows you to indicate the types of parameters and return values for functions and methods, which can help with debugging and performance analysis.
Performance Improvements With Python 3.11
Python 3.11 comes with some great performance improvements. One of the most notable is the new compiler, which is now written entirely in Python! This means that your code will be significantly faster, as there are no extra steps to compile the code.
In addition, there have been improvements to the garbage collector that make it more efficient for both small and large applications. Memory management is also improved, so if you’re running a memory-intensive application it should run more smoothly.
We are going to illustrate a case in which this improvement is perceptible with the following code:
x = 1
for i in range(300):
x += i
As we can see, we always work with integral types and, therefore, we have a stable type for which we can use optimized addition operations. Running this snippet 1,000,000 times in Python 3.10 takes 8,822 seconds; while in version 3.11, it is 7,110 seconds, representing a significant increase of 20%.
Finally, many other libraries have been improved to speed up the process of running your code. This includes asyncio, which is used to manage concurrent operations, as well as JSON and YAML libraries which are used for parsing data in web APIs.
All of these changes contribute to making Python 3.11 faster and more efficient than previous versions.
New Modules Added in Python 3.11
Python 3.11 has added several new modules that make it even easier to develop in Python. Two of the most notable additions are the asyncio module and the concurrent.futures module.
The asyncio module allows developers to write asynchronous code with ease, making it possible to run multiple tasks simultaneously and reduce the amount of time needed for complex tasks to be completed. It also simplifies the debugging process and helps streamlining development processes.
The concurrent.futures module provides support for running multiple concurrent tasks in a robust manner and allows developers to take advantage of parallelism more easily. This is great for taking advantage of all the computing power available in modern CPUs and GPUs, allowing them to work together efficiently when working with huge sets of data or complex operations.
What Should Developers Be Aware of With Python 3.11?
There are a few things that developers should keep in mind when working with Python 3.11.
The biggest change is the switch to the new Python type system.
This means that developers need to learn the nuances of the new type system and be aware of how it affects their code. Additionally, some of the existing built-in types have been removed or changed, so developers should be sure to double check their code for any references to those types.
Another thing to be aware of is that some modules may not be compatible with Python 3.11, particularly ones that rely on third-party libraries or C extensions written in different languages such as C++. Developers should check for compatibility with any external modules before attempting to use them in their code.
Lastly, there are some syntax changes with Python 3.11 which may cause issues with legacy code written in previous versions of Python, so developers should consider using the new syntax offered in this version when writing new code and taking special care when dealing with legacy code.
Other new features
Version 3.11 introduces several new features that are worth mentioning:
- A context manager has been added for the chdir method, allowing for directory changes to be limited to the scope of that context manager.
- The datetime.UTC alias has been added for datetime.timezone.UTC.
- The re module now supports atomic groups (?>…) and positive quantifiers (*+, ++, ?+, {m,n}+).
- The time.sleep() function now has Increased precision to nanosecond level (if available on the Unix system).
- The new TaskGroup class has been added to the asyncio module, allowing for the grouping and waiting for completion of tasks.
Conclusion
The updates to the typing module and improvements in exception handling demonstrate a trend towards the use of Python in more complex software.
Additionally, version 3.11’s focus on speed enhancements shows that the community is making efforts to improve the language’s performance. It is likely that future versions will continue to prioritize performance improvements.
As you can see, Python 3.11 has a lot of new features. While some of them are simply refinements of existing features, others are entirely new. It’s worth trying out the new features to see how they can improve your development process.
