An Improved Interactive Interpreter (REPL)

If you run Python without specifying any script or code, you’ll find yourself insidePython’s interactive interpreter. This interpreter is informally called the REPL because it’s based on a read-evaluate-print loop. The REPLreads your input,evaluates it, andprints the result beforelooping back and doing the same thing again.

The Python REPL has been around for decades, and it supports an explorative workflow that makes Python a beginner-friendly language. Unfortunately, the interpreter has been missing several features you may have come to expect, including multiline editing and efficient pasting of code.

Begin by starting the REPL. You can do this by typingpython in yourterminal. Depending on your setup, you may have to writepy,python3, or evenpython3.13 instead. One way to recognize that you’re using the new interpreter shipping with Python 3.13 is that the prompt consisting of three chevrons (>>>) is subtly colored:

One improvement is that you can now use REPL-specific commands without calling them with parentheses as if they are Python functions. Here are some of the commands and keyboard shortcuts you can use:

• exit orquit: Exit the interpreter
• clear: Clear the screen
• help orF1: Access the help system
• F2: Open the history browser
• F3: Enter paste mode

You can learn more about these options inPython 3.13 Preview: A Modern REPL.

Recalling code you’ve written earlier has been cumbersome in the REPL before Python 3.13, especially if you’re working with a block of code spanning several lines. Traditionally, you’ve had to bring back each line one by one by repeatedly pressingUp. Now in 3.13, you can bring back the whole block of code with a singleUp keystroke.

To try this for yourself, enter the following code in your REPL:

>>>numbers=range(3,13)>>>[...(number-3)**3fornumberinnumbers...ifnumber%2==1...][0, 8, 64, 216, 512]

You’re creating a somewhat complexlist comprehension that calculates an offset cube of a range of numbers, but only if the numbers are odd. The important part is that for readability, you split the list comprehension over several lines. Now try hitting thatUp key! The interpreter recalls all four lines at once, and you can continue to use your arrow keys to move around inside of the expression.

You can make changes to your code and run it again. To execute the updated code, you need to move your cursor to the end of the last line in the code block. If you pressEnter inside the expression, you’ll create a new empty line instead:

The ability to recall and edit multiline statements is a huge time-saver and will make you more efficient when working with the REPL.

Another convenience coming in Python 3.13 is proper support for pasting code. In Python 3.12 and earlier, you’d need to make sure that your code doesn’t contain any blank lines before you could copy and paste it. In the new version, pasted code is treated as a unit and executes just as it would inside a script.

This makes it more convenient to use the REPL to interactively tweak and debug your scripts. As an example, say that you want to write a script that can printrandom numbers, maybe toact as dice in a tabletop game you’re playing:

importrandomnum_faces=6print("Hit enter to roll die (q to quit, number for # of faces) ")whileTrue:roll=input()ifroll.lower().startswith("q"):breakifroll.isnumeric():num_faces=int(roll)result=random.randint(1,num_faces)print(f"Rolling a d{num_faces:<2d} -{result:2d}")

If you try to copy and paste this code into an older REPL, then it won’t work. The blank line inside thewhile loop causes issues. You enter an infinite loop that seemingly doesn’t do anything. To stop the loop, you can typeq and hitEnter or pressCtrl+C.

In Python 3.13, pasting works without a hitch:

>>>importrandom......num_faces=6......print("Hit enter to roll die (q to quit, number for # of faces) ")...whileTrue:...roll=input()...ifroll.lower().startswith("q"):...break...ifroll.isnumeric():...num_faces=int(roll)......result=random.randint(1,num_faces)...print(f"Rolling a d{num_faces:<2d} -{result:2d}")...Hit enter to roll die (q to quit, number for # of faces)13Rolling a d13 -  10Rolling a d13 -   5Rolling a d13 -   3q

Note that the prompt displays as three dots (...) for all the code that you paste, indicating that it’s all part of one code unit. In this example, you choose to roll ad13, a thirteen-sided die, three times.

Another arena where your Python developer experience gets a small boost in Python 3.13 is through improved error messages, which you’ll learn about next.

Better Error Messages

The REPL is great to work with when you first start using Python, and another feature you quickly run into is Python’s error messages. It hasn’t always felt like the error messages were trying to help you. However, over the last several releases, they’ve gotten friendlier and more helpful:

• Python 3.10 improved many error messages as they gotless technical and more precise.
• Python 3.11 addedmore information in tracebacks, making it more convenient to figure out which code is causing issues.
• Python 3.12 madeimport errors more straightforward to deal with.

Python 3.13 continues this great tradition of enhancing your developer experience. In this release, color is added to the tracebacks shown when you encounter a runtime error. Additionally, more kinds of error messages provide you with suggestions on how to fix errors. You’ll look closer at these in this section.

First, you’ll provoke Python and create a runtime error to get a glimpse of the colored tracebacks. Open your REPL and defineinverse() as follows:

>>>definverse(number):...return1/number...

Theinverse() function calculates the multiplicative inverse of a number. One issue thatinverse() doesn’t account for, is that zero doesn’t have an inverse. In your function, you see this becauseinverse(0) raises aZeroDivisionError:

Your tracebacks now have colors, with important information highlighted in red and purple. In general, this should make error messages easier to read and understand.

However, if you don’t like the colors, you canturn them off by setting thePYTHON_COLORS environment variable to0.

Since Python 3.10, error messages have included aDid you mean suggestion feature that can help you out if you misspell a keyword, function name, or even a module name. In Python 3.13, the suggestions are expanded to include keyword arguments in function calls. Say that you’re trying to sort a list of numbers in descending order:

>>>numbers=[2,0,2,4,1,0,0,1]>>>sorted(numbers,reversed=True)Traceback (most recent call last):  File"<python-input-1>", line1, in<module>sorted(numbers,reversed=True)~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^TypeError:sort() got an unexpected keyword argument 'reversed'.           Did you mean 'reverse'?>>>sorted(numbers,reverse=True)[4, 2, 2, 1, 1, 0, 0, 0]

You try to usereverse=True to sort the numbers in reverse order. At first, you make a typo and call the argumentreversed with ad at the end. Python notices this and helpfully suggests that you meantreverse.

Some of the advanced features in Python are backed by simple mechanisms. For example, to create your own Python module, you only need to create a file named with a.py suffix. This is great for exploring the language, but also opens the door for things to go wrong in interesting ways.

The following scenario is something you’ve probably run into. Recall the dice-rolling script fromearlier. Say that you had called the filerandom.py instead:

importrandomnum_faces=6print("Hit enter to roll die (q to quit, number for # of faces) ")whileTrue:roll=input()ifroll.lower().startswith("q"):breakifroll.isnumeric():num_faces=int(roll)result=random.randint(1,num_faces)print(f"Rolling a d{num_faces:<2d} -{result:2d}")

Your game is waiting on the table and you’re excited to start rolling the dice. Run the script and let randomness unfold:

$pythonrandom.pyHit enter to roll die (q to quit, number for # of faces)Traceback (most recent call last):  File "/home/realpython/random.py", line 1, in <module>    import random  File "/home/realpython/random.py", line 13, in <module>    result = random.randint(1, num_faces)             ^^^^^^^^^^^^^^AttributeError: module 'random' has no attribute 'randint' (consider                renaming '/home/realpython/random.py' since it has the same                name as the standard library module named 'random' and the                import system gives it precedence)

Error messages likemodule ‘random’ has no attribute ‘randint’ has confused Python developers for decades. Surely,randint() is one of the functions in therandom module!

In Python 3.13, you no longer need to scratch your head, as the error message points out what’s likely the problem. When you createdrandom.py, you created a newrandom module that shadows the one in the standard library. To fix the problem, you should rename your script.

Renamerandom.py back toroll_dice.py and run it again:

$pythonroll_dice.pyHit enter to roll die (q to quit, number for # of faces)Rolling a d6  -   3Rolling a d6  -   1Rolling a d6  -   320Rolling a d20 -  13q

Your script is no longer hidingrandom from the standard library. In the example above, you first roll a regular six-sided die three times, before switching to a twenty-sided die.

You’ll see a similar error message if you happen to shadow a third-party package as well. In general, you should be careful with naming your top-level Python files the same as libraries that you plan to import.

The continued work on improving your developer experience helps Python defend its position as a beginner-friendly language.

Free-Threaded Python: Look Ma, No GIL

High-level languages like Python provide some conveniences for you as a developer. For example, you can trust that Python will handle memory for you. You don’t need to worry about allocating memory before initializing a data structure, and you don’t need to remember to free the memory when you’re done working with it.

Another programming problem that Python helps you with is making sure that your code is thread-safe. Simply put, for code to be thread-safe, it needs to ensure that two different threads of execution don’t update the same part of memory at the same time.

Python’s solution to this is a bit heavy-handed. It uses a global interpreter lock (GIL) to ensure that only one thread accesses the memory at a time. For most operations, a thread must first acquire the GIL. Because this lock is global—there’s only one GIL—most Python programs are effectively single-threaded, even when they’re running on modern hardware with several CPUs available.

Historically, the GIL proved to be a simple and effective solution to addingbindings to C libraries that weren’t thread-safe. The GIL has likely played a significant role in Python’s rise in popularity as a programming language.

As the number of CPUs available in computers has increased over the years, the GIL has become more of a troublemaker than a hero. The community has attempted to remove the GIL from the language several times. The most recent attempt, initialized by Sam Gross, is by far the most promising. In fact, you can set up a specialfree-threaded version of Python 3.13 that doesn’t have a global interpreter lock.

Trying out the free-threaded version of Python requires some time and effort. You may be able to get a version from your platform’s regular distribution channel. If not, you can either download Python’s source code and build it yourself, or run Python through Docker. For more information, seeGet Your Hands on the New Features in the free threading preview.

The free-threaded Python executable is typically namedpython3.13t with at suffix. Once you have your hands on a free-threaded version of Python, you can choose to enable or disable the GIL each time you run Python:

$CODE='import pyfeatures; print(pyfeatures.FreeThreading())'$python3.13-c"$CODE"Free Threading: unsupported$python3.13t-c"$CODE"Free Threading: enabled ✨$python3.13t-Xgil=1-c"$CODE"Free Threading: disabled

You enable the GIL and turn off free threading by setting-X gil=1. Thepyfeatures module needed to run the above code is available in the downloadable materials. It contains functionality for detecting the status of free threading.

Note that enabling the GIL on the free-threaded version isn’t completely equivalent to running the standard version of Python. At least in early versions of Python 3.13, running the free-threaded version with the GIL enabled shows some issues with performance:

This particular benchmark is run on a computer with four CPUs. Note that the graph for free-threaded Python with the GIL disabled is close to flat for the first four threads. This is very promising, as it indicates that this version of Python is able to take advantage of all cores on the computer.

If you’re interested in learning more about this benchmark, then go ahead and readMeasure the Performance Improvements of Python 3.13 which goes more in-depth on the performance of free-threaded Python.

Removing the GIL is a massive undertaking that will hopefully make Python more performant in the future. In the next section, you’ll look at another feature aimed at speeding up Python.

Experimental JIT Compiler

Python is an interpreted language. This is in contrast to languages like C and Rust, which are all compiled languages. In an interpreted language, you need a runtime like a Python interpreter to run your code. Compiled code, on the other hand, can typically be run directly on your system.

There are advantages and disadvantages to both models. Python is often a language that’s efficient for developers, where new code can be tested quickly. But, the code itself may run slower than equivalent compiled code.

A just-in-time, or JIT, compiler provides a kind of middle ground, where the interpreter may choose to compile some code while a program is running in order to speed it up. In Python 3.13, there’s a new, experimental JIT compiler. The fact that it’s experimental means that it’s present in Python’s source code, but it’s not enabled by default.

If you want to try out the JIT compiler, you need to set up a special version of Python 3.13 with the JIT enabled. This is similar to what you need to do to try out free-threaded Python, although with different build flags.

Python’s JIT compiler is based on an algorithm calledcopy-and-patch. The interpreter will look for patterns in your code that match pre-compiled templates and fill in the machine code with specific information like memory addresses of variables.

JIT compilation can be effective and give better performance in code where the same operation is repeated over and over again, giving the JIT compiler time to analyze and translate your code. In one benchmark, which repeatedly calculated theFibonacci series, you can see a small improvement in performance with the JIT:

In this benchmark, Python 3.13 with the JIT enabled is faster than both Python 3.12 and regular Python 3.13. However, the JIT isn’t ready for everyday use yet, and you should limit yourself to experimenting with it. Hopefully, the JIT will have more impact in future Python releases.

To learn more about the above benchmark, as well as the new experimental JIT compiler, dig intoPython 3.13 Preview: Free Threading and a JIT Compiler.

Improvements to Static Typing

While Python is a dynamically typed language, you can add static type information in optionaltype hints. You can run a separate type checker likemypy orPyright to validate your code, or you can rely on your IDE to advise you about issues.

The foundations of Python’s static type system were defined inPEP 484 and introduced in Python 3.5. In November 2023,PEP 729 established theTyping Council and formalized the type system through atyping specification.

The Typing Council governs the Python type system and aims to make it useful, usable, and stable. It maintains the typing specification and advisesPython’s Steering Council ontyping-related PEPs. The initial members of the Typing Council are:

• Rebecca Chen
• Shantanu Jain
• Carl Meyer
• Eric Traut
• Jelle Zijlstra

In addition to providing more clarity in the governance of Python’s type system, the community has implemented some code-related changes as well. The following PEPs have been accepted for Python 3.13:

• PEP 696: Type defaults for type parameters
• PEP 742: Narrowing types withTypeIs
• PEP 705:TypedDict: Read-only items
• PEP 702: Marking deprecations using the type system

In this tutorial, you’ll focus on the first two changes: type defaults and improved type narrowing. If you’re interested in learning more about read-onlyTypedDict items or deprecations, have a look at their respective PEPs or check out the downloadable materials. The latter contains examples that you can play with on your own.

Similar to other features in the language, typing improvements are tied to a specific version of Python. However, they also require that the type checker you’re using implements the new feature. When possible, new features are backported to older Python versions through thetyping_extensions library. For example, you can useTypeIs on, say, Python 3.10 by importing fromtyping_extensions instead oftyping.

(venv)$python-mpipinstallpyright

Python 3.12 introduced anew syntax for type generics. Ageneric type is one that’s parametrized by another type. For example, alist is a generic type as you can have a list of strings or a list of integers. Both are lists, but they are parametrized by different types, namely strings and integers.

Traditionally, you’ve needed to explicitly define type variables usingTypeVar. Since Python 3.12, you can declare type variables in a more compact[T] syntax using square brackets:

fromcollectionsimportdequeclassQueue[T]:def__init__(self)->None:self.elements:deque[T]=deque()defpush(self,element:T)->None:self.elements.append(element)defpop(self)->T:returnself.elements.popleft()

In this example, you create a genericqueue based ondeque. You can use the queue as follows:

>>>fromgeneric_queueimportQueue>>>string_queue=Queue[str]()>>>string_queue.push("three")>>>string_queue.push("thirteen")>>>integer_queue=Queue[int]()>>>integer_queue.push(3)>>>integer_queue.push(13)

You declare thatstring_queue will be a queue with string elements by adding[str] in square brackets when you create the instance. Similarly,[int] specifies thatinteger_queue will have integer elements. If you leave out the square brackets and callQueue() directly, then your queue can have elements of arbitrary type.

You can now specify atype default for these kinds of generic classes. This default will be assumed when you don’t explicitly define a type:

fromcollectionsimportdequeclassQueue[T=str]:def__init__(self)->None:self.elements:deque[T]=deque()defpush(self,element:T)->None:self.elements.append(element)defpop(self)->T:returnself.elements.popleft()string_queue=Queue()reveal_type(string_queue)integer_queue=Queue[int]()reveal_type(integer_queue)

You define the type default similarly to how you specify default arguments for functions. The syntax[T=str] means that if the type ofT isn’t specified, then it’ll bestr. To confirm this, you use the specialreveal_type(). This function is understood by your type checker, but will fail if you run your code:

$pyright--pythonversion3.13generic_queue.pygeneric_queue.py  generic_queue.py:15:13 - information: Type of "string_queue" is "Queue[str]"  generic_queue.py:18:13 - information: Type of "integer_queue" is "Queue[int]"0 errors, 0 warnings, 2 informations

When you run Pyright on your code,reveal_type() confirms thatstring_queue is a queue of strings, even if you haven’t explicitly specified it.

Type defaults is a small addition that can make working with generics more convenient.

Python 3.10 introducedtype guards. These allow you to narrow union types. Consider the following example of a recursively defined tree structure:

 1fromtypingimportTypeGuard 2 3typeTree=list[Tree|int] 4 5defis_tree(obj:object)->TypeGuard[Tree]: 6returnisinstance(obj,list)andall( 7is_tree(elem)orisinstance(elem,int)foreleminobj 8) 910defget_left_leaf_value(tree_or_leaf:Tree|int)->int:11ifis_tree(tree_or_leaf):12returnget_left_leaf_value(tree_or_leaf[0])13else:14returntree_or_leaf

Here,is_tree() acts as a type guard that can identify trees. In your code, aTree is a nested list of integers. The recursiveget_left_leaf_value() function takes either aTree or a single integer. However, after checkingis_tree(), you can safely access the first element of the tree on line 12.

Type guards have some limitations where they don’t work well with generic types and they only provide positive guarantees. The latter means that the type checker isn’t allowed to do any type narrowing if the type guard returnsFalse.

In the example above, this means that for a type checker,tree_or_leaf on line 14 is still of typeTree | int:

$pyright--pythonversion3.13tree.pytree.py  tree.py:14:16 - error: Type "Tree | int" isn't assignable to return type "int"    Type "Tree | int" is not assignable to type "int"      "list[Tree | int]" is not assignable to "int" (reportReturnType)1 error, 0 warnings, 0 informations

Here, your type checker complains about the type in your secondreturn statement. However, since this is in theelse branch, you know thattree_or_leaf is anint. To convince your type checker of this, you’d need another type guard for integers.

TypeIs is similar toTypeGuard but it provides more type narrowing information to the type checker, and solves the issue with the example above. In many cases, you can useTypeIs as a drop-in replacement forTypeGuard:

 1fromtypingimportTypeIs 2 3typeTree=list[Tree|int] 4 5defis_tree(obj:object)->TypeIs[Tree]: 6returnisinstance(obj,list)andall( 7is_tree(elem)orisinstance(elem,int)foreleminobj 8) 910defget_left_leaf_value(tree_or_leaf:Tree|int)->int:11ifis_tree(tree_or_leaf):12returnget_left_leaf_value(tree_or_leaf[0])13else:14returntree_or_leaf

You’ve replacedTypeGuard withTypeIs. This provides more information to the type checker. In particular, it knows thattree_or_leaf can’t be aTree if you enter theelse branch on line 13, sotree_or_leaf must be an integer in this case. You can confirm this by running Pyright:

$pyright--pythonversion3.13tree.py0 errors, 0 warnings, 0 informations

You can read more about type narrowing and the difference betweenTypeGuard andTypeIs in thetyping specification.

While Python’s type system is constantly evolving, most of the new features are actually incremental improvements on existing capabilities. This reflects that static typing in Python is fairly mature at this point.

Other Pretty Cool Features

You’ve seen the highlights of what’s coming in Python 3.13. However, each new release of Python contains tons of little changes contributed by enthusiastic developers. In this section, you’ll check out some of the improvements that don’t necessarily get the big headlines.

$python-mjson.tooldog_friend.json{    "name": "Frieda",    "age": 8}$python-mhttp.serverServing HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

$python-mrandomusage: random.py [-h] [-c CHOICE [CHOICE ...] | -i N | -f N] [input ...]positional arguments:  input                 if no options given, output depends on the input                            string or multiple: same as --choice                            integer: same as --integer                            float: same as --floatoptions:  -h, --help            show this help message and exit  -c, --choice CHOICE [CHOICE ...]                        print a random choice  -i, --integer N       print a random integer between 1 and N inclusive  -f, --float N         print a random floating-point number between 0 and N

$python-mrandomOsloBerlinLondonKrakowBelgradeGrazKrakow$python-mrandom63$python-mrandom6.03.132801224231027

$python-mrandom--float61.4284991504686064

>>>fromtypingimportNamedTuple>>>classPerson(NamedTuple):...name:str...place:str...version:str...>>>person=Person(name="Geir Arne",place="Oslo",version="3.12")

>>>person=Person(name=person.name,place=person.place,version="3.13")>>>personPerson(name='Geir Arne', place='Oslo', version='3.13')

>>>fromdatetimeimportdate>>>today=date.today()>>>todaydatetime.date(2024, 9, 30)>>>today.replace(day=1)datetime.date(2024, 9, 1)>>>today.replace(month=12,day=24)datetime.date(2024, 12, 24)

>>>importcopy>>>person=Person(name="Geir Arne",place="Oslo",version="3.12")>>>copy.replace(person,version="3.13")Person(name='Geir Arne', place='Oslo', version='3.13')>>>copy.replace(today,day=1)datetime.date(2024, 9, 1)

>>>personPerson(name='Geir Arne', place='Oslo', version='3.12')

>>>frompathlibimportPath>>>Path("music")PosixPath('music')>>>forpathinPath("music").glob("*"):...print(path)...music/operamusic/rap

music/│├── opera/│   ├── flower_duet.txt│   ├── habanera.txt│   └── nabucco.txt│└── rap/    ├── bedlam_13-13.txt    └── fight_the_power.txt

$lsmusic/**music/opera:flower_duet.txt  habanera.txt  nabucco.txtmusic/rap:bedlam_13-13.txt  fight_the_power.txt

>>>forpathinPath("music").glob("**"):...print(path)...musicmusic/operamusic/rap>>>forpathinPath("music").glob("**/*"):...print(path)...music/operamusic/rapmusic/opera/nabucco.txtmusic/opera/flower_duet.txtmusic/opera/habanera.txtmusic/rap/bedlam_13-13.txtmusic/rap/fight_the_power.txt

>>>forpathinPath("music").glob("**"):...print(path)...musicmusic/operamusic/rapmusic/rap/bedlam_13-13.txtmusic/rap/fight_the_power.txtmusic/opera/nabucco.txtmusic/opera/flower_duet.txtmusic/opera/habanera.txt

>>>forpathinPath("music").glob("**/"):...print(path)...musicmusic/operamusic/rap

>>>importglob>>>pattern=glob.translate("music/**/*.txt")>>>pattern'(?s:music/(?!\\.)[^/]*/(?!\\.)[^/]*\\.txt)\\Z'

>>>importre>>>re.match(pattern,"music/opera/flower_duet.txt")<re.Match object; span=(0, 27), match='music/opera/flower_duet.txt'>>>>re.match(pattern,"music/progressive_rock/")>>>re.match(pattern,"music/progressive_rock/fandango.txt")<re.Match object; span=(0, 35), match='music/progressive_rock/fandango.txt'>

>>>importdataclasses>>>@dataclasses.dataclass...classPerson:..."""Model a person with a name, location, and Python version."""...name:str...place:str...version:str...>>>Person.__doc__'Model a person with a name, location, and Python version.'

>>>importdataclasses>>>dataclasses.replace.__doc__'Return a new object replacing specified fields with new values.\n\n    This is especially useful for frozen classes.  Example usage::\n\n       @dataclass(frozen=True)\n      class C:\n          x: int\n           y: int\n\n      c = C(1, 2)\n      c1 = replace(c, x=3)\n       assert c1.x == 3 and c1.y == 2\n    '>>>len(dataclasses.replace.__doc__)299>>>print(dataclasses.replace.__doc__)Return a new object replacing specified fields with new values.    This is especially useful for frozen classes.  Example usage::      @dataclass(frozen=True)      class C:          x: int          y: int      c = C(1, 2)      c1 = replace(c, x=3)      assert c1.x == 3 and c1.y == 2

>>>importdataclasses>>>dataclasses.replace.__doc__'Return a new object replacing specified fields with new values.\n\nThis is especially useful for frozen classes.  Example usage::\n\n   @dataclass(frozen=True)\n  class C:\n      x: int\n      y: int\n\n   c = C(1, 2)\n  c1 = replace(c, x=3)\n  assert c1.x == 3 and c1.y == 2\n'>>>len(dataclasses.replace.__doc__)263>>>print(dataclasses.replace.__doc__)Return a new object replacing specified fields with new values.This is especially useful for frozen classes.  Example usage::  @dataclass(frozen=True)  class C:      x: int      y: int  c = C(1, 2)  c1 = replace(c, x=3)  assert c1.x == 3 and c1.y == 2

So, Should You Upgrade to Python 3.13?

You’ve seen several of the features coming in Python 3.13. There are even many more that you can read about in thePython changelog. Improved features not covered in this tutorial include:

• Argparse supportsdeprecating options, arguments, and subcommands in your command-line applications.
• Defined semantics forlocals() ensuringmore consistency when peeking into the local namespace.
• Thedead batteries that weredeprecated in Python 3.11 have beenremoved.
• iOS andAndroid are nowsupported platforms for Python at thetier 3 level.

Additionally, Python’sannual release cycle has beenrevised toextend full support from eighteen months to a full two years. Each release will still get security fixes for five years:

The diagram shows the life cycles of Python 3.13 and the upcoming 3.14 and 3.15.

So, having seen all these new improvements, should you upgrade to Python 3.13? Like for every release, the answer is a clear and loudit depends!

There isn’t any big reason not to update yourlocal environment that you use for exploring the language. The new REPL and improved error messages are nice quality-of-life upgrades and you might see some small performance improvements. That said, if you don’t use the built-in REPL, there aren’t any super attractive features that you need to jump on either.

If you’remaintaining a library, especially one that uses Python’s C-API, you should start testing with Python 3.13, both the regular version and the free-threaded one. It’s important to surface any bugs in the implementation as soon as possible. Adding a bug report is a great contribution to the language. Your library may also need some updates to be compatible with free threading.

For code that’srunning in production, you should be as diligent as ever with testing your code on Python 3.13 before upgrading your runtime. While a lot of testing has been done since Python 3.13 reached beta in May 2024, there are always bugs that surface after the official release. For critical code, you’ll be fine with running on Python 3.12 until its full support ends inApril 2025.

A question that’s independent of when you upgrade your Python is when you should start using the new features. Again, it depends on your code and your situation.

This time around, there aren’t any big syntax changes, likef-strings, thewalrus operator, or thematch…case statement in the past. Instead, there are some functions, likecopy.replace() andglob.translate() that will only be available for you on Python 3.13.

If youwork on an application where you can control the running environment, you can use Python 3.13 features as soon as you’ve upgraded the environment. If you work on a team, then you need to make sure everyone’s on board and upgraded before you introduce any incompatible syntax.

If youwrite a library that others use, then you don’t know which version of Python they’ll be using. In this case, it pays off to be more conservative and ideally support each version throughout its lifetime. Python 3.8 reaches end-of-support inOctober 2024, so you could start looking at requiring Python 3.9 as your minimal version.

Moving forward, there will bebugfix releases of Python 3.13. These are planned to be released approximately every two months. If you start using Python 3.13, you should stay up-to-date with the bugfix updates, and upgrade your environment as they become available.

Conclusion

A new Python release is always great news! You’ve been on a tour of the features and improvements that have been updated in Python 3.13. Send some appreciation to all the volunteers that put time and effort into the development!

In this tutorial, you’ve seen new features and improvements, like:

• Improvements made to theinteractive interpreter (REPL)
• Clearer error messages that can help you fix common mistakes
• Advancements done inremoving the global interpreter lock (GIL) and making Python free-threaded
• The implementation of anexperimental Just-In-Time (JIT) compiler
• A host of minor upgrades toPython’s static type system

You probably won’t be able to take advantage of the new features right away, but you should install Python 3.13 on your system and play with it.

Take the Quiz: Test your knowledge with our interactive “Python 3.13: Cool New Features for You to Try” quiz. You’ll receive a score upon completion to help you track your learning progress:

---

Interactive Quiz

Python 3.13: Cool New Features for You to Try

In this quiz, you'll test your understanding of the new features introduced in Python 3.13. By working through this quiz, you'll review the key updates and improvements in this version of Python.