Python 3.14 was launched on seventh October 2025. Right here we summarise some
of the extra attention-grabbing adjustments and a few tendencies in Python growth and data-science
over the previous 12 months. We are going to spotlight the next:

• the colorful Python command-line interface;
• project-management instrument uv;
• free-threading;
• and a short abstract of different developments.

The Python 3.14 launch notes
additionally describe the adjustments to base Python.

Vibrant REPL

At Leaping Rivers we now have taught lots of people to program in Python.
All through a programming profession you get used to creating, and studying
from, errors. The commonest errors made in introductory
programming classes should journey you up in 10 years time: unmatched
parentheses, typos, lacking quote symbols, unimported dependencies.

Our Python coaching programs are offered utilizing
Jupyter. Jupyter
notebooks have syntax highlighting that makes it simple to determine an
unfinished string, or a mis-spelled key phrase.

However, most Python learners don’t use Jupyter (or different high-level
programming instruments) on day one – they experiment with Python on the
command line. You may kind “python” into your shell/terminal window and
begin programming into the “REPL” (read-evaluate-print loop).

Any effort to make the REPL simpler to work with shall be useful to
starting programmers. So the introduction of syntax highlighting within the
Python 3.14 REPL is actually useful.

uv and bundle growth

One of many massive tendencies in Python growth inside 2025, is the rise of
the venture administration instrument
uv. This can be a Rust-based command-line instrument
and can be utilized to initialise a bundle / venture construction, to specify
the event and runtime atmosphere of a venture, and to publish a
bundle to PyPI.

At Leaping Rivers, we now have used poetry for most of the jobs that uv
excels at. Python is used for the info preparation duties for
diffify.com, and we use
poetry to make sure that our builders every use
exactly the identical bundle variations when engaged on that venture (See our present
weblog collection on Poetry). However,
poetry doesn’t forestall builders utilizing totally different variations of Python.
For that, we’d like a second instrument like
pyenv (which permits switching
between totally different Python variations) or for every developer to have the
similar Python model put in on their machine.

uv goes a step additional than poetry and permits us to pin Python
variations for a venture. Let’s use uv to put in Python 3.14, in order that
we are able to check out options within the new launch.

First comply with the
directions for putting in uv.

Then on the command line, we’ll use uv to create a brand new venture the place
we’ll use Python 3.14.

# [bash]
cd ~/temp
mkdir blog-py3.14
cd blog-py3.14

# Which variations of Python 3.14 can be found through uv?
uv python record | grep 3.14
# cpython-3.14.0rc2-linux-x86_64-gnu 
# cpython-3.14.0rc2+freethreaded-linux-x86_64-gnu 

You’ll see one thing comparable whatever the working system that you just
use. That lists two variations of Python 3.14 – one with an non-compulsory
system known as “Free Threading” (see later). We’ll set up each variations
of Python:

uv python set up cpython-3.14.0rc2-linux-x86_64-gnu
uv python set up cpython-3.14.0rc2+freethreaded-linux-x86_64-gnu

Customers of pyenv will be capable to set up Python 3.14 in an identical
method.

We will choose between the 2 totally different Python variations on the command
line. First utilizing the model that doesn’t have free threading:

uv run --python=3.14 python
# Python 3.14.0rc2 (foremost, Aug 18 2025, 19:19:22) [Clang 20.1.4 ] on linux
# ...
>>> import sys
>>> sys._is_gil_enabled()
# True

Then utilizing the model with free threading (word the t suffix)

uv run --python=3.14t python
# ...
# Python 3.14.0rc2 free-threading construct (foremost, Aug 18 2025, 19:19:12) [Clang 20.1.4 ] on linux
# ...
>>> import sys
>>> sys._is_gil_enabled()
# False

Mission creation and administration with uv

uv is able to far more than permitting us to change between
totally different variations of Python. The next instructions initialise a Python
venture with uv:

# From ~/temp/blog-py3.14

# Point out the default python model for the venture
uv python pin 3.14

# Initialise a venture within the present listing
uv init .

# Test the Python model
uv run python --version
# Python 3.14.0rc2

This provides some recordsdata for venture metadata (pyproject.toml, README.md)
and model management:

tree -a -L 1
# .
# ├── .git
# ├── .gitignore
# ├── foremost.py
# ├── pyproject.toml
# ├── .python-version
# ├── README.md
# ├── uv.lock
# └── .venv
#
# 2 directories, 6 recordsdata

Now we are able to add bundle dependencies utilizing uv add and
different normal project-management duties. However one factor I needed to
spotlight is that uv permits us to begin a Jupyter pocket book, utilizing the
venture’s Python interpreter, with out both including jupyter as a
dependency or explicitly defining a kernel for jupyter:

uv run --with jupyter jupyter lab

Creating a brand new pocket book utilizing the default Python 3 kernel within the
JupyterLab session that
begins, ought to guarantee you might be utilizing the at present energetic Python 3.14
atmosphere.

Threading

Python 3.13 launched an experimental characteristic, ‘Free-threading’, that
is now formally supported as of three.14.

First although, what’s a ’thread’? When a program runs in your pc,
there are many totally different duties occurring. A few of these duties may
run independently of one another. You, because the programmer, could have to
clarify to the pc which duties can run independently. A thread is a
approach of cordoning-off a kind of duties; it’s a approach of telling the
pc that your software program is working on, that this activity right here can run
individually from these duties there, and the logic for working
this activity too. (Principally).

Python has allowed builders to outline threads for some time. When you have
a couple of duties which might be largely impartial of one another, every of those
duties can run in a separate thread. Threads can entry the identical reminiscence
area, which means that they will entry and modify shared variables in a Python
session. On the whole, this additionally implies that a computation in a single thread
may replace a worth that’s utilized by one other thread, or that two
totally different threads may make conflicting updates to the identical variable.
This freedom can result in bugs. The CPython interpreter was initially
written with a locking mechanism (the World Interpreter Lock, GIL) that
prevented totally different threads from working on the similar time (even when
a number of processors had been accessible) and restricted the attain of those bugs.

Historically, you’d have used threads for “non-CPU-bound duties” in
Python. These are the sorts of duties that might be unaffected by having
extra, or sooner, processors accessible to the Python occasion: community
visitors, file entry, ready for consumer enter. For CPU-bound duties, like
calculations and data-processing, you can use Python’s
‘multiprocessing’ library (though some libraries like ‘numpy’ have
their very own low-level mechanisms for splitting work throughout cores). This
begins a number of Python cases, every doing a portion of the
processing, and permits a workload to be partitioned throughout a number of
processors.

The primary different variations between threading and multiprocessing in
Python are in reminiscence and information administration. With threading, you could have one
Python occasion, with every thread gaining access to the identical reminiscence
area. With multiprocessing, you could have a number of Python cases that
work independently: the cases don’t share reminiscence, so to partition a
workload utilizing multiprocessing, Python has to ship copies of (subsets
of) your information to the brand new cases. This might imply that that you must
retailer two or extra copies of a big dataset in reminiscence when utilizing
multiprocessing upon it.

Simultaneous processing throughout threads that share memory-space is now
potential utilizing the free-threaded construct of Python. Many third-party
packages have been rewritten to accommodate this new construct and you’ll
study extra about free-threading and the progress of the adjustments within the
“Python Free-Threading Information”.

As a simple-ish instance, lets contemplate pure language processing.
There’s a fantastic weblog publish about parallel processing with the
nltk bundle on the
“WZB Information Science Weblog”.
We are going to prolong that instance to make use of free-threading.

ntlk gives entry to a number of the
Mission Gutenberg books, and we are able to
entry this information as follows:

# foremost.py
import nltk

def setup():
 nltk.obtain("gutenberg")
 nltk.obtain("punkt_tab")
 nltk.obtain('averaged_perceptron_tagger_eng')
 corpus = { f_id: nltk.corpus.gutenberg.uncooked(f_id)
 for f_id in nltk.corpus.gutenberg.fileids()
 }
 return corpus

corpus = setup()

The important thing-value pairs in corpus are the abbreviated book-title and
contents for 18 books. For instance:

corpus["austen-emma.txt"]
# [Emma by Jane Austen 1816]
#
# VOLUME I
#
# CHAPTER I
#
#
# Emma Woodhouse, good-looking, intelligent, and wealthy, with a cushty residence ...

A regular a part of a text-processing workflow is to tokenise and tag the
“parts-of-speech” (POS) in a doc. We will do that utilizing two nltk
capabilities:

# foremost.py ... continued
def tokenise_and_pos_tag(doc):
 return nltk.pos_tag(nltk.word_tokenize(doc))

A operate to sequentially tokenise and POS-tag the contents of a corpus
of books may be written:

# foremost.py ... continued
def tokenise_seq(corpus):
 tokens = {
 f_id: tokenise_and_pos_tag(doc)
 for f_id, doc in corpus.objects()
 }
 return tokens

It’s essential set up or construct Python in a selected solution to make use of
“Free-threaded” Python. Within the above, we put in Python “3.14t” utilizing
uv, so we are able to evaluate the pace of free-threaded and sequential,
single-core, processing.

We are going to use the
timeit bundle to
analyse processing pace, from the command line.

# Activate the threaded model of Python 3.14
uv python pin 3.14t

# Set up the dependencies for our foremost.py script
uv add timeit nltk

# Time the `tokenise_seq()` operate
# -- however don't time any setup code...
PYTHON_GIL=0 
 uv run python -m timeit 
 --setup "import foremost; corpus = foremost.setup()" 
 "foremost.tokenise_seq(corpus)"

# [lots of output messages]
# 1 loop, better of 5: 53.1 sec per loop

After some preliminary steps the place the nltk datasets had been downloaded and the
corpus object was created (neither of which had been timed, as a result of these
steps had been a part of the timeit --setup block), tokenise_seq(corpus) was
run a number of instances and the quickest pace was round 53 seconds.

A small word: we now have used the atmosphere variable PYTHON_GIL=0 right here.
This makes it specific that we’re utilizing free-threading (turning off the
GIL). This wouldn’t usually be essential to make the most of
free-threading (in Python “3.14t”), however was wanted as a result of one of many
dependencies of nltk hasn’t
been validated for the free-threaded construct but.

To jot down a threaded-version of the identical, we introduce two capabilities. The
first is a helper that takes (filename, document-content) pairs and
returns (filename, processed-document) pairs:

def tupled_tokeniser(pair):
 file_id, doc = pair
 return file_id, tokenise_and_pos_tag(doc)

The second operate creates a Thread-pool, benefiting from as many CPUs as there can be found
on my machine (16, counted by multiprocessing.cpu_count()). Every doc is processed as a
separate thread and we look ahead to the entire paperwork to be processed earlier than returning outcomes to the
caller:

import multiprocessing as mp
from concurrent.futures import ThreadPoolExecutor, wait
# ...
def tokenise_threaded(corpus):
 with ThreadPoolExecutor(max_workers=mp.cpu_count()) as tpe:
 strive:
 futures = [
 tpe.submit(tupled_tokeniser, pair)
 for pair in corpus.items()
 ]
 wait(futures)
 lastly:
 # output is an inventory of (file-id, information) pairs
 tokens = [f.result() for f in futures]
 return tokens

# Time the `tokenise_threaded()` operate
# -- however don't time any setup code...
PYTHON_GIL=0 
 uv run python -m timeit 
 --setup "import foremost; corpus = foremost.setup()" 
 "foremost.tokenise_threaded(corpus)"
# [lots of output messages]
# 1 loop, better of 5: 32.5 sec per loop

I may see that each core was used when processing the paperwork, utilizing the
htop instrument on Ubuntu. At factors through the run, every of the 16 CPUs was at
close to to 100% use (whereas just one or two CPUs had been busy at any time through the sequential run):

However, regardless of utilizing 16x as many CPUs, the multithreaded model of the
processing script was solely about 40% sooner. There was solely 18 books in
the dataset and a few disparity between the e book lengths (the bible,
containing tens of millions of phrases was processed a lot slower than the others).
Possibly the pace up can be better with a bigger or extra balanced
dataset.

Within the publish on the WZB Information Science weblog, there’s a multiprocessing
implementation of the above. Working their multiprocessing code with 16
CPUs gave an identical pace as much as multithreading (minimal time 31.2 seconds).
Certainly, if I used to be penning this code for an actual venture, multiprocessing would
stay my selection, as a result of the evaluation for one e book can proceed independently of
that for another e book and information volumes aren’t that massive.

Different Information

Python 3.14 has additionally launched some enhancements to exception-handling, a brand new method to
string templating and enhancements to the usage of concurrent interpreters.
See the
Python 3.14 launch notes for additional particulars.

Within the wider Python Information Science ecosystem, a couple of different developments have occurred or are due
earlier than the top of 2025:

• The primary secure launch of the
  Positron IDE was made in August;
• Pandas 3.0 is due earlier than the top of the
  12 months, and can introduce strings as a data-type, copy-on-write behaviour, and implicit entry to
  columns in DataFrame-modification code;
• Instruments that ingest DataFrames have gotten agnostic to DataFrame library by means of the Narwahls
  venture. See the
  Plotly write-up
  on this topic.

Python information science progresses at such a pace that we are able to solely actually scratch the floor right here.
Have we missed something within the wider Python ecosystem (2025 version) that can make an enormous
distinction to your information work? Tell us on
LinkedIn or
Bluesky.

For updates and revisions to this text, see the authentic publish

Associated