Text of docs.python.org › 3.16 › whatsnew › 3.2.html as Styx crawled it on Oct 8, 2026. The page may have changed since. Only its words are kept, without pictures or layout, and only the first part of a long page.

Open the live page

What’s New In Python 3.2 — Python 3.16.0a0 documentation

Navigation index modules | next | previous | Python » 3.16.0a0 Documentation » What’s New in Python » What’s New In Python 3.2 | Theme | What’s New In Python 3.2 ¶ Author : Raymond Hettinger This article explains the new features in Python 3.2 as compared to 3.1. Python 3.2 was released on February 20, 2011. It focuses on a few highlights and gives a few examples. For full details, see the Misc/NEWS file. See also PEP 392 - Python 3.2 Release Schedule PEP 384: Defining a Stable ABI ¶ In the past, extension modules built for one Python version were often not usable with other Python versions.

Particularly on Windows, every feature release of Python required rebuilding all extension modules that one wanted to use. This requirement was the result of the free access to Python interpreter internals that extension modules could use. With Python 3.2, an alternative approach becomes available: extension modules which restrict themselves to a limited API (by defining Py_LIMITED_API) cannot use many of the internals, but are constrained to a set of API functions that are promised to be stable for several releases.

As a consequence, extension modules built for 3.2 in that mode will also work with 3.3, 3.4, and so on. Extension modules that make use of details of memory structures can still be built, but will need to be recompiled for every feature release. See also PEP 384 - Defining a Stable ABI PEP written by Martin von Löwis. PEP 389: Argparse Command Line Parsing Module ¶ A new module for command line parsing, argparse , was introduced to overcome the limitations of optparse which did not provide support for positional arguments (not just options), subcommands, required options and other common patterns of specifying and validating options.

This module has already had widespread success in the community as a third-party module. Being more fully featured than its predecessor, the argparse module is now the preferred module for command-line processing. The older module is still being kept available because of the substantial amount of legacy code that depends on it. Here’s an annotated example parser showing features like limiting results to a set of choices, specifying a metavar in the help screen, validating that one or more positional arguments is present, and making a required option: import argparse parser = argparse .

ArgumentParser ( description = 'Manage servers' , # main description for help epilog = 'Tested on Solaris and Linux' ) # displayed after help parser . add_argument ( 'action' , # argument name choices = [ 'deploy' , 'start' , 'stop' ], # three allowed values help = 'action on each target' ) # help msg parser . add_argument ( 'targets' , metavar = 'HOSTNAME' , # var name used in help msg nargs = '+' , # require one or more targets help = 'url for target machines' ) # help msg explanation parser . add_argument ( '-u' , '--user' , # -u or --user option required = True , # make it a required argument help = 'login as user' ) Example of calling the parser on a command string: >>> cmd = 'deploy sneezy.example.com sleepy.example.com -u skycaptain' >>> result = parser . parse_args ( cmd . split ()) >>> result . action 'deploy' >>> result . targets ['sneezy.example.com', 'sleepy.example.com'] >>> result . user 'skycaptain' Example of the parser’s automatically generated help: >>> parser . parse_args ( '-h' . split ()) usage: manage_cloud.py [-h] -u USER {deploy,start,stop} HOSTNAME [HOSTNAME ...] Manage servers positional arguments: {deploy,start,stop} action on each target HOSTNAME url for target machines optional arguments: -h, --help show this help message and exit -u USER, --user USER login as user Tested on Solaris and Linux An especially nice argparse feature is the ability to define subparsers, each with their own argument patterns and help displays: import argparse parser = argparse .

ArgumentParser ( prog = 'HELM' ) subparsers = parser . add_subparsers () parser_l = subparsers . add_parser ( 'launch' , help = 'Launch Control' ) # first subgroup parser_l . add_argument ( '-m' , '--missiles' , action = 'store_true' ) parser_l . add_argument ( '-t' , '--torpedos' , action = 'store_true' ) parser_m = subparsers . add_parser ( 'move' , help = 'Move Vessel' , # second subgroup aliases = ( 'steer' , 'turn' )) # equivalent names parser_m . add_argument ( '-c' , '--course' , type = int , required = True ) parser_m . add_argument ( '-s' , '--speed' , type = int , default = 0 ) $ ./helm.py --help # top level help (launch and move) $ ./helm.py launch --help # help for launch options $ ./helm.py launch --missiles # set missiles=True and torpedos=False $ ./helm.py steer --course 180 --speed 5 # set movement parameters See also PEP 389 - New Command Line Parsing Module PEP written by Steven Bethard.

Migrating optparse code to argparse for details on the differences from optparse . PEP 391: Dictionary Based Configuration for Logging ¶ The logging module provided two kinds of configuration, one style with function calls for each option or another style driven by an external file saved in a configparser format. Those options did not provide the flexibility to create configurations from JSON or YAML files, nor did they support incremental configuration, which is needed for specifying logger options from a command line.

To support a more flexible style, the module now offers logging.config.dictConfig() for specifying logging configuration with plain Python dictionaries. The configuration options include formatters, handlers, filters, and loggers. Here’s a working example of a configuration dictionary: { "version" : 1 , "formatters" : { "brief" : { "format" : " %(levelname)-8s : %(name)-15s : %(message)s " }, "full" : { "format" : " %(asctime)s %(name)-15s %(levelname)-8s %(message)s " } }, "handlers" : { "console" : { "class" : "logging.StreamHandler" , "formatter" : "brief" , "level" : "INFO" , "stream" : "ext://sys.stdout" }, "console_priority" : { "class" : "logging.StreamHandler" , "formatter" : "full" , "level" : "ERROR" , "stream" : "ext://sys.stderr" } }, "root" : { "level" : "DEBUG" , "handlers" : [ "console" , "console_priority" ]}} If that dictionary is stored in a file called conf.json , it can be loaded and called with code like this: >>> import json , logging.config >>> with open ( 'conf.json' ) as f : ... conf = json . load ( f ) ... >>> logging . config . dictConfig ( conf ) >>> logging . info ( "Transaction completed normally" ) INFO : root : Transaction completed normally >>> logging . critical ( "Abnormal termination" ) 2011-02-17 11:14:36,694 root CRITICAL Abnormal termination See also PEP 391 - Dictionary Based Configuration for Logging PEP written by Vinay Sajip.

PEP 3148: The concurrent.futures module ¶ Code for creating and managing concurrency is being collected in a new top-level namespace, concurrent . Its first member is a futures package which provides a uniform high-level interface for managing threads and processes. The design for concurrent.futures was inspired by the java.util.concurrent package. In that model, a running call and its result are represented by a Future object that abstracts features common to threads, processes, and remote procedure calls.

That object supports status checks (running or done), timeouts, cancellations, adding callbacks, and access to results or exceptions. The primary offering of the new module is a pair of executor classes for launching and managing calls. The goal of the executors is to make it easier to use existing tools for making parallel calls. They save the effort needed to setup a pool of resources, launch the calls, create a results queue, add time-out handling, and limit the total number of threads, processes, or remote procedure calls.

Ideally, each application should share a single executor across multiple components so that process and thread limits can be centrally managed. This solves the design challenge that arises when each component has its own competing

The rest of this page is on the live site.