Nearly annually, Python releases a new version. The most recent version, Python 3.13, will be available on May 8, 2024, following Python 3.12 in that order. This version introduced many new features and improvements. This is a pre-release of the next Python version, which introduced some new features as well as improvements to the existing ones. In this article, we will see what has been changed in Python version 3.13.

1. A Better Interactive Interpreter

Python 3.13 introduces significant improvements to the interactive interpreter along with enhanced error messages. The new interactive interpreter now supports colorization, providing a more visually appealing experience. This color support extends to tracebacks and doctest output as well. Users have the option to disable colorization through the PYTHON_COLORS and NO_COLOR environment variables.

Additionally, Python 3.12 includes a basic JIT (Just-In-Time) compiler, as per PEP 744. Although currently disabled by default, this compiler shows promising performance improvements, with plans for further enhancements in subsequent releases.

2. Experimental Just-in-Time (JIT) Compilation

Python introduces an experimental just-in-time (JIT) compiler which, when enabled, can speed up certain Python programs. The JIT compiler works by translating specialized Tier 1 bytecode to a new internal Tier 2 intermediate representation (IR), which is optimized for translation to machine code. Several optimization passes are applied to the Tier 2 IR before it’s interpreted or translated to machine code.

Configuration options (–enable-experimental-jit) allow users to control the JIT’s behavior at build and runtime, including enabling or disabling the JIT and the Tier 2 interpreter.

Potential Benefits of JIT Compiler

• Significant performance improvements for specific code sections that benefit from machine code execution.
• Opens doors for future optimizations that weren’t previously possible with bytecode interpretation.

3. Experimental Free-Threaded CPython

CPython now supports running with the Global Interpreter Lock (GIL) disabled, allowing for free-threaded execution when configured with –disable-gil. Free-threaded execution enables better utilization of available CPU cores by running threads in parallel, benefiting programs designed for threading.

C-API extension modules need to be specifically built for the free-threaded build, and extensions should indicate support for running with the GIL disabled using appropriate mechanisms.

Understanding the GIL

• The Global Interpreter Lock (GIL) is a mechanism in CPython that ensures only one thread can execute Python bytecode at a time.
• This guarantees data integrity in Python’s single-threaded nature but limits the ability to leverage multiple CPU cores effectively for certain tasks

Potential Benefits of Free-Threaded CPython

For CPU-bound tasks that can be effectively divided among multiple threads, Free-Threaded CPython has the potential to significantly improve performance by utilizing multiple CPU cores. This could be particularly beneficial for scientific computing, data analysis, and other computationally intensive workloads.

4. Improved Error Reporting and Guidance

Error tracking in Python has been improved in the latest version. The interpreter now colorizes error messages when displaying tracebacks by default. In another feature, the error message suggests the correct keyword argument, if an incorrect keyword was passed to a function.

Sometimes when a script has the same name as a standard library module, Python now provides a detailed error message and suggests renaming the module for better understanding.

>>> sys.version_info
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'sys' is not defined. Did you forget to import 'sys'?

5. Interactive Shell Makeover (New REPL)

Python 3.13 introduces a much-anticipated improvement for interactive development, a brand new REPL (Read-Eval-Print Loop). This interactive shell makeover aims to provide a more user-friendly and informative experience for Python programmers.

Features of New REPL

Python 3.13 brings a revamped REPL with several enhancements designed to improve the interactive development experience:

• Colorful Enhancements (Linux/macOS): Output now has color by default, making code and error messages easier to read and understand. (Note: This feature is currently not available on Windows.)
• Integrated Help (F1): Quickly access the pydoc help browser directly within the REPL by pressing F1. No more switching between windows or terminals to find documentation.
• Command History Navigation (F2): Effortlessly browse through your command history using the F2 key. This allows you to revisit previous commands and experiment with variations quickly.
• Block Paste Mode (F3): For working with larger code blocks, a dedicated paste mode is available with F3. This simplifies pasting code snippets into the REPL without worrying about line breaks or indentation issues.
• Simplified Exit (exit/quit): You can now simply type exit or quit to leave the REPL, eliminating the need for function calls like exit().

Benefits of New REPL (Read-Eval-Print Loop)

These improvements in the new REPL aim to streamline the interactive development process. Features like color highlighting and integrated help make it easier to understand code behavior and identify issues. Easy command history navigation and block paste mode expedite experimentation and code refinement.

6. Incremental Garbage Collection

Python 3.12 introduces incremental garbage collection, which significantly reduces maximum pause times for larger heaps. This improvement is particularly beneficial for applications with large amounts of memory allocation and deallocation

# Python 3.12
import gc
gc.isincremental()  # Returns True

This feature allows Python applications to run more smoothly, with reduced impact from garbage collection pauses, leading to better overall performance and responsiveness.

7. Improved Error Reporting and Guidance

Error tracking in Python has been improved in the latest version. The interpreter now colorizes error messages when displaying tracebacks by default. In another feature, the error message suggests the correct keyword argument, if an incorrect keyword was passed to a function.

Sometimes when a script has the same name as a standard library module, Python now provides a detailed error message and suggests renaming the module for better understanding.

8. Memory Optimization for Docstrings

Python 3.13 introduces a subtle but impactful change aimed at improving memory efficiency: Memory Optimization for Docstrings. This feature tackles a hidden source of memory usage and file size associated with docstrings in Python code. Limitations of Traditional docstrings in Python are as follows:

• Traditionally, docstrings in Python included any leading indentation spaces.
• While seemingly harmless, these extra spaces contributed to the overall size of the compiled bytecode files (.pyc files) and potentially increased memory usage when the code was executed.

Benefits of Memory Optimization for Docstrings

• Memory Optimization for Docstrings addresses this inefficiency. It automatically removes any leading indentation from docstrings before the compilation process.
• This ensures that only the actual docstring content is stored, leading to:
  • Reduced memory footprint for compiled bytecode files.
  • Potentially lower memory usage during program execution, especially for projects with extensive docstrings.

9. Enhance Performance in Modules

Python 3.12 introduces several optimizations to enhance performance in various modules and functions:

Improved Performance of textwrap.indent()

The textwrap.indent() function now performs approximately 30% faster for large input sizes than before. This enhancement improves the efficiency of text manipulation operations.

Improved Import Times for Standard Library

Several standard library modules have seen significant improvements in import times. For instance, the import time of the typing module has been reduced by around a third by removing dependencies on re and contextlib.

10. Removal of Deprecated Modules (“Dead Batteries”)

Deprecated modules are functionalities in Python’s standard library that are considered outdated, insecure, or no longer actively maintained. While they might still work in older Python versions, they are discouraged for use in new projects.

Why Remove Deprecated Modules?

• Keeping deprecated modules around can lead to confusion for developers, especially beginners, who might unknowingly use outdated functionalities.
• They can also introduce security vulnerabilities if not maintained properly.
• Removing them encourages developers to adopt newer, more secure, and better-supported alternatives.

Benefits of Removing Deprecated Modules

• Cleaner and More Secure Codebase: By removing outdated modules, the Python core developers ensure a cleaner and more secure standard library.
• Encourages Modern Practices: It pushes developers to adopt newer, more secure, and better-maintained functionalities.

Major new features of the 3.13 series, compared to 3.12