Vad är nytt i Python 3.2

Författare:

Raymond Hettinger

I den här artikeln förklaras de nya funktionerna i Python 3.2 jämfört med 3.1. Python 3.2 släpptes den 20 februari 2011. Den fokuserar på några få höjdpunkter och ger några exempel. För fullständig information, se filen Misc/NEWS.

Se även

PEP 392 - Python 3.2 Utgivningsschema

PEP 384: Att definiera en stabil ABI

Tidigare var tilläggsmoduler som byggts för en Python-version ofta inte användbara med andra Python-versioner. Särskilt på Windows krävde varje funktionsversion av Python att man byggde om alla tilläggsmoduler som man ville använda. Detta krav var resultatet av den fria tillgången till Pythons tolkinterna som tilläggsmoduler kunde använda.

Med Python 3.2 blir ett alternativt tillvägagångssätt tillgängligt: tilläggsmoduler som begränsar sig till ett begränsat API (genom att definiera Py_LIMITED_API) kan inte använda många av de interna funktionerna, men begränsas till en uppsättning API-funktioner som lovas vara stabila i flera utgåvor. Som en följd av detta kommer tilläggsmoduler som byggts för 3.2 i det läget också att fungera med 3.3, 3.4 och så vidare. Tilläggsmoduler som använder detaljer i minnesstrukturer kan fortfarande byggas, men de måste kompileras om för varje funktionsversion.

Se även

PEP 384 - Att definiera en stabil ABI

PEP skriven av Martin von Löwis.

PEP 389: Argparse-modul för parsning av kommandoraden

En ny modul för kommandoradsanalys, argparse, introducerades för att övervinna begränsningarna i optparse som inte hade stöd för positionella argument (inte bara alternativ), underkommandon, obligatoriska alternativ och andra vanliga mönster för att ange och validera alternativ.

Denna modul har redan haft stor framgång i gemenskapen som en tredjepartsmodul. Modulen argparse är mer komplett än sin föregångare och är nu den föredragna modulen för kommandoradsbehandling. Den äldre modulen hålls fortfarande tillgänglig på grund av den stora mängd äldre kod som är beroende av den.

Här är ett kommenterat exempel på en parser som visar funktioner som att begränsa resultaten till en uppsättning val, ange en metavar i hjälpskärmen, validera att ett eller flera positionsargument finns och göra ett obligatoriskt alternativ:

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')

Exempel på anrop av parsern på en kommandosträng:

>>> 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'

Exempel på den automatiskt genererade hjälpen i parsern:

>>> 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

En särskilt trevlig argparse-funktion är möjligheten att definiera underparsers, var och en med sina egna argumentmönster och hjälpdisplayer:

import argparse
parser = argparse.ArgumentParser(prog='HELM')
subparsers = parser.add_subparsers()

parser_l = subparsers.add_parser('launch', help='Launch Control') # första undergruppen
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='Flytta fartyg', # andra undergruppen
                                 alias=('styra', 'vända'))         # likvärdiga namn
parser_m.add_argument('-c', '--course', type=int, required=True)
parser_m.add_argument('-s', '--speed', type=int, default=0)
$ ./helm.py --help # hjälp på högsta nivå (start och flytt)
$ ./helm.py launch --help # hjälp för avfyrningsalternativ
$ ./helm.py launch --missiles # ställ in missiler=True och torpeder=False
$ ./helm.py steer --kurs 180 --hastighet 5 # ställ in rörelseparametrar

Se även

PEP 389 - Ny modul för parsning av kommandorader

PEP skriven av Steven Bethard.

Migrera optparse-kod till argparse för detaljer om skillnaderna från optparse.

PEP 391: Ordboksbaserad konfiguration för loggning

Modulen logging tillhandahöll två typer av konfigurering, en stil med funktionsanrop för varje alternativ eller en annan stil som drivs av en extern fil som sparas i formatet configparser. Dessa alternativ gav inte flexibiliteten att skapa konfigurationer från JSON- eller YAML-filer, och de stödde inte heller inkrementell konfiguration, vilket behövs för att ange loggaralternativ från en kommandorad.

För att stödja en mer flexibel stil erbjuder modulen nu logging.config.dictConfig() för att ange loggningskonfiguration med vanliga Python-ordböcker. Konfigurationsalternativen inkluderar formaterare, hanterare, filter och loggar. Här är ett fungerande exempel på en konfigurationsordbok:

{"version": 1,
 "formatter": {"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"]}}

Om ordlistan lagras i en fil som heter conf.json, kan den laddas och anropas med kod som denna:

>>> 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

Se även

PEP 391 - Konfiguration baserad på ordbok för loggning

PEP skriven av Vinay Sajip.

PEP 3148: Modulen concurrent.futures

Kod för att skapa och hantera samtidighet samlas i ett nytt namnrymd på högsta nivå, concurrent. Dess första medlem är ett futures-paket som tillhandahåller ett enhetligt gränssnitt på hög nivå för hantering av trådar och processer.

Utformningen av concurrent.futures har inspirerats av paketet java.util.concurrent. I den modellen representeras ett pågående anrop och dess resultat av ett Future-objekt som abstraherar funktioner som är gemensamma för trådar, processer och fjärrproceduranrop. Objektet stöder statuskontroller (körs eller görs), timeouts, avbrytanden, tillägg av callbacks och åtkomst till resultat eller undantag.

Den nya modulen består främst av ett par exekverande klasser för att starta och hantera anrop. Målet med exekveringsmodulerna är att göra det enklare att använda befintliga verktyg för att göra parallella anrop. De sparar det arbete som krävs för att konfigurera en resurspool, starta anrop, skapa en resultatkö, lägga till timeout-hantering och begränsa det totala antalet trådar, processer eller fjärrproceduranrop.

Helst bör varje applikation dela en enda exekverare mellan flera komponenter så att process- och trådgränser kan hanteras centralt. Detta löser den designutmaning som uppstår när varje komponent har sin egen konkurrerande strategi för resurshantering.

Båda klasserna har ett gemensamt gränssnitt med tre metoder: submit() för att schemalägga ett anrop och returnera ett Future-objekt; map() för att schemalägga många asynkrona anrop åt gången, och shutdown() för att frigöra resurser. Klassen är en context manager och kan användas i en with-sats för att säkerställa att resurser automatiskt frigörs när pågående futures är klara med exekveringen.

Ett enkelt exempel på ThreadPoolExecutor är en start av fyra parallella trådar för kopiering av filer:

import concurrent.futures, shutil
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as e:
    e.submit(shutil.copy, 'src1.txt', 'dest1.txt')
    e.submit(shutil.copy, 'src2.txt', 'dest2.txt')
    e.submit(shutil.copy, 'src3.txt', 'dest3.txt')
    e.submit(shutil.copy, 'src3.txt', 'dest4.txt')

Se även

PEP 3148 - Futures – Utför beräkningar asynkront

PEP skriven av Brian Quinlan.

Kod för parallell URL-läsning med trådar, ett exempel där trådar används för att hämta flera webbsidor parallellt.

Kod för beräkning av primtal i parallell, ett exempel som demonstrerar ProcessPoolExecutor.

PEP 3147: Kataloger för PYC-förvar

Pythons system för att cachelagra bytekod i .pyc-filer fungerade inte bra i miljöer med flera Python-tolkar. Om en tolk stötte på en cachad fil som skapats av en annan tolk, skulle den kompilera om källkoden och skriva över den cachade filen, och därmed förlora fördelarna med cachning.

Frågan om ”pyc-fighter” har blivit mer uttalad eftersom det har blivit vanligt att Linux-distributioner levereras med flera versioner av Python. Dessa konflikter uppstår också med CPython-alternativ som Unladen Swallow.

För att lösa detta problem har Pythons importmaskineri utökats så att olika filnamn används för varje tolk. I stället för att Python 3.2 och Python 3.3 och Unladen Swallow konkurrerar om en fil som heter ”mymodule.pyc”, kommer de nu att leta efter ”mymodule.cpython-32.pyc”, ”mymodule.cpython-33.pyc” och ”mymodule.unladen10.pyc”. Och för att förhindra att alla dessa nya filer rör till källkatalogerna samlas pyc-filerna nu i en ”__pycache__”-katalog som lagras under paketkatalogen.

Bortsett från filnamnen och målkatalogerna har det nya systemet några aspekter som är synliga för programmeraren:

  • Importerade moduler har nu ett __cached__-attribut som lagrar namnet på den faktiska filen som importerades:

    >>> import collections
    >>> collections.__cached__
    'c:/py32/lib/__pycache__/collections.cpython-32.pyc'
    
  • Den tagg som är unik för varje tolk är tillgänglig från modulen imp:

    >>> import imp
    >>> imp.get_tag()
    'cpython-32'
    
  • Skript som försöker härleda källfilnamnet från den importerade filen måste nu vara smartare. Det räcker inte längre att bara ta bort ”c” från ett ”.pyc”-filnamn. Använd istället de nya funktionerna i modulen imp:

    >>> imp.source_from_cache('c:/py32/lib/__pycache__/collections.cpython-32.pyc')
    'c:/py32/lib/collections.py'
    >>> imp.cache_from_source('c:/py32/lib/collections.py')
    'c:/py32/lib/__pycache__/collections.cpython-32.pyc'
    
  • Modulerna py_compile och compileall har uppdaterats för att återspegla den nya namnkonventionen och målkatalogen. Kommandoradsuppmaningen compileall har nya alternativ: -i för att ange en lista över filer och kataloger som ska kompileras och -b som gör att bytecode-filer skrivs till sin gamla plats i stället för till __pycache__.

  • Modulen importlib.abc har uppdaterats med nya abstract base classes för laddning av bytecode-filer. De föråldrade ABC:erna, PyLoader och PyPycLoader, har utgått (instruktioner om hur man håller sig kompatibel med Python 3.1 finns i dokumentationen).

Se även

PEP 3147 - Kataloger för PYC-förvar

PEP skriven av Barry Warsaw.

PEP 3149: ABI-version märkta .so-filer

PYC-repository-katalogen gör det möjligt att samlokalisera flera bytecode-cache-filer. Denna PEP implementerar en liknande mekanism för delade objektfiler genom att ge dem en gemensam katalog och distinkta namn för varje version.

Den gemensamma katalogen är ”pyshared” och filnamnen särskiljs genom att identifiera Python-implementationen (t.ex. CPython, PyPy, Jython etc.), versionsnumren för major och minor samt valfria build-flaggor (t.ex. ”d” för debug, ”m” för pymalloc, ”u” för wide-unicode). För ett godtyckligt paket ”foo” kan du se dessa filer när distributionspaketet installeras:

/usr/share/pyshared/foo.cpython-32m.so
/usr/share/pyshared/foo.cpython-33md.so

I Python är taggarna tillgängliga från funktioner i modulen sysconfig:

>>> import sysconfig
>>> sysconfig.get_config_var('SOABI')       # find the version tag
'cpython-32mu'
>>> sysconfig.get_config_var('EXT_SUFFIX')  # find the full filename extension
'.cpython-32mu.so'

Se även

PEP 3149 - ABI-version taggade .so-filer

PEP skriven av Barry Warsaw.

PEP 3333: Python Web Server Gateway-gränssnitt v1.0.1

Denna informativa PEP klargör hur bytes/text-frågor ska hanteras av WSGI-protokollet. Utmaningen är att stränghantering i Python 3 hanteras mest bekvämt med typen str även om HTTP-protokollet i sig är bytesorienterat.

PEP:n skiljer mellan så kallade native strings som används för rubriker och metadata för begäran/svar och byte strings som används för huvuddelen av begäran och svar.

De inbyggda strängarna är alltid av typen str men begränsas till kodpunkter mellan U+0000 och U+00FF som kan översättas till byte med hjälp av Latin-1-kodning. Dessa strängar används för nycklar och värden i miljöordlistan och för svarsrubriker och status i funktionen start_response(). De måste följa RFC 2616 med avseende på kodning. Det vill säga, de måste antingen vara ISO-8859-1-tecken eller använda RFC 2047 MIME-kodning.

För utvecklare som portar WSGI-applikationer från Python 2, här är de viktigaste punkterna:

  • Om appen redan använde strängar för rubriker i Python 2 behövs ingen ändring.

  • Om appen i stället kodade utdatahuvuden eller avkodade inmatningshuvuden måste huvudena kodas om till Latin-1. Till exempel måste en utdatahuvud som kodats i utf-8 med hjälp av h.encode('utf-8') nu konverteras från bytes till inbyggda strängar med h.encode('utf-8').decode('latin-1').

  • Värden som ges ut av en applikation eller skickas med metoden write() måste vara byte-strängar. Funktionen start_response() och environ måste använda inbyggda strängar. De två kan inte blandas.

För serverimplementerare som skriver CGI-till-WSGI-vägar eller andra CGI-liknande protokoll måste användarna kunna komma åt miljön med hjälp av inbyggda strängar även om den underliggande plattformen kan ha en annan konvention. För att överbrygga detta gap har modulen wsgiref en ny funktion, wsgiref.handlers.read_environ() för omkodning av CGI-variabler från os.environ till inbyggda strängar och returnering av en ny ordbok.

Se även

PEP 3333 - Python Web Server Gateway-gränssnitt v1.0.1

PEP skriven av Phillip Eby.

Andra språkliga förändringar

Några mindre ändringar som gjorts i Python-språkets kärna är:

  • Strängformatering för format() och str.format() har fått nya möjligheter för formattecknet #. Tidigare, för heltal i binär, oktal eller hexadecimal, orsakade det att utdata prefixades med ’0b’, ’0o’ eller ’0x’ respektive. Nu kan den även hantera flyttal, komplex och decimal, vilket gör att utdata alltid har en decimalpunkt även om inga siffror följer efter den.

    >>> format(20, '#o')
    '0o24'
    >>> format(12.34, '#5.0f')
    '  12.'
    

    (Föreslagen av Mark Dickinson och implementerad av Eric Smith i bpo-7094.)

  • Det finns också en ny metod str.format_map() som utökar möjligheterna med den befintliga metoden str.format() genom att acceptera godtyckliga mapping-objekt. Den här nya metoden gör det möjligt att använda strängformatering med något av Pythons många ordboksliknande objekt som defaultdict, Shelf, ConfigParser eller dbm. Det är också användbart med anpassade dict-underklasser som normaliserar nycklar före uppslagning eller som tillhandahåller en __missing__()-metod för okända nycklar:

    >>> import shelve
    >>> d = shelve.open('tmp.shl')
    >>> 'The {project_name} status is {status} as of {date}'.format_map(d)
    'The testing project status is green as of February 15, 2011'
    
    >>> class LowerCasedDict(dict):
    ...     def __getitem__(self, key):
    ...         return dict.__getitem__(self, key.lower())
    ...
    >>> lcd = LowerCasedDict(part='widgets', quantity=10)
    >>> 'There are {QUANTITY} {Part} in stock'.format_map(lcd)
    'There are 10 widgets in stock'
    
    >>> class PlaceholderDict(dict):
    ...     def __missing__(self, key):
    ...         return '<{}>'.format(key)
    ...
    >>> 'Hello {name}, welcome to {location}'.format_map(PlaceholderDict())
    'Hello <name>, welcome to <location>'
    

(Föreslagen av Raymond Hettinger och implementerad av Eric Smith i bpo-6081.)

  • Tolken kan nu startas med ett tyst alternativ, -q, som förhindrar att information om copyright och version visas i det interaktiva läget. Alternativet kan introspekteras med hjälp av attributet sys.flags:

    $ python -q
    >>> sys.flags
    sys.flags(debug=0, division_warning=0, inspect=0, interactive=0,
    optimize=0, dont_write_bytecode=0, no_user_site=0, no_site=0,
    ignore_environment=0, verbose=0, bytes_warning=0, quiet=1)
    

    (Bidrag från Marcin Wojdyr i bpo-1772833).

  • Funktionen hasattr() fungerar genom att anropa getattr() och upptäcka om ett undantag uppstår. Denna teknik gör det möjligt att upptäcka metoder som skapas dynamiskt av __getattr__() eller __getattribute__() som annars inte skulle finnas med i klassordlistan. Tidigare skulle hasattr fånga upp alla undantag och eventuellt maskera verkliga fel. Nu har hasattr stramats upp så att den bara fångar AttributeError och låter andra undantag passera igenom:

    >>> class A:
    ...     @property
    ...     def f(self):
    ...         return 1 // 0
    ...
    >>> a = A()
    >>> hasattr(a, 'f')
    Traceback (most recent call last):
      ...
    ZeroDivisionError: integer division or modulo by zero
    

    (Upptäckt av Yury Selivanov och åtgärdad av Benjamin Peterson; bpo-9666.)

  • str() för ett flytande eller komplext tal är nu samma som dess repr(). Tidigare var str() kortare men det skapade bara förvirring och behövs inte längre nu när den kortaste möjliga repr() visas som standard:

    >>> import math
    >>> repr(math.pi)
    '3.141592653589793'
    >>> str(math.pi)
    '3.141592653589793'
    

    (Föreslagen och implementerad av Mark Dickinson; bpo-9337.)

  • memoryview-objekt har nu en release()-metod och de stöder nu också protokollet för kontexthantering. Detta gör det möjligt att i rätt tid frigöra alla resurser som förvärvades när en buffert begärdes från det ursprungliga objektet.

    >>> with memoryview(b'abcdefgh') as v:
    ...     print(v.tolist())
    [97, 98, 99, 100, 101, 102, 103, 104]
    

    (Tillagd av Antoine Pitrou; bpo-9757.)

  • Tidigare var det olagligt att ta bort ett namn från den lokala namnrymden om det förekom som en fri variabel i ett nästlat block:

    def outer(x):
        def inner():
            returnera x
        inner()
        del x
    

    Detta är nu tillåtet. Kom ihåg att målet för en except-sats rensas, så den här koden som brukade fungera med Python 2.6, gav upphov till ett SyntaxError med Python 3.1 och fungerar nu igen:

    def f():
        def print_error():
            print(e)
        försök:
            något
        except Exception as e:
            print_error()
            # implicit "del e" här
    

    (Se bpo-4617.)

  • Struct sequence types är nu underklasser till tuple. Detta innebär att C-strukturer som de som returneras av os.stat(), time.gmtime() och sys.version_info nu fungerar som en named tuple och nu fungerar med funktioner och metoder som förväntar sig en tuple som argument. Detta är ett stort steg framåt när det gäller att göra C-strukturerna lika flexibla som deras rena Python-motsvarigheter:

    >>> import sys
    >>> isinstance(sys.version_info, tuple)
    True
    >>> 'Version %d.%d.%d %s(%d)' % sys.version_info
    'Version 3.2.0 final(0)'
    

    (Föreslagen av Arfrever Frehtes Taifersar Arahesis och implementerad av Benjamin Peterson i bpo-8413.)

  • Det är nu lättare att kontrollera varningar med hjälp av miljövariabeln PYTHONWARNINGS som ett alternativ till att använda -W på kommandoraden:

    $ export PYTHONWARNINGS='ignore::RuntimeWarning::,once::UnicodeWarning::'
    

    (Föreslagen av Barry Warsaw och implementerad av Philip Jenvey i bpo-7301.)

  • En ny varningskategori, ResourceWarning, har lagts till. Den utfärdas när potentiella problem med resursförbrukning eller -rensning upptäcks. Den är avstängd som standard i normala versionsbyggen, men kan aktiveras med hjälp av modulen warnings eller på kommandoraden.

    En ResourceWarning utfärdas när tolken stängs av om listan gc.garbage inte är tom, och om gc.DEBUG_UNCOLLECTABLE är inställd skrivs alla objekt som inte kan samlas in ut. Detta är tänkt att göra programmeraren medveten om att deras kod innehåller problem med att avsluta objekt.

    En ResourceWarning utfärdas också när ett filobjekt förstörs utan att uttryckligen ha stängts. Även om deallokeringen för ett sådant objekt säkerställer att den underliggande operativsystemresursen (vanligtvis en filbeskrivare) stängs, kan fördröjningen i deallokeringen av objektet ge upphov till olika problem, särskilt under Windows. Här är ett exempel på hur du aktiverar varningen från kommandoraden:

    $ python -q -Wdefault
    >>> f = open("foo", "wb")
    >>> del f
    __main__:1: ResourceWarning: unclosed file <_io.BufferedWriter name='foo'>
    

    (Tillagd av Antoine Pitrou och Georg Brandl i bpo-10093 och bpo-477863.)

  • range-objekt har nu stöd för metoderna index och count. Detta är en del av ett försök att få fler objekt att fullt ut implementera collections.Sequence abstrakt basklass. Som ett resultat kommer språket att ha ett mer enhetligt API. Dessutom stöder range-objekt nu skivning och negativa index, även med värden som är större än sys.maxsize. Detta gör range mer kompatibelt med listor:

    >>> range(0, 100, 2).count(10)
    1
    >>> range(0, 100, 2).index(10)
    5
    >>> range(0, 100, 2)[5]
    10
    >>> range(0, 100, 2)[0:5]
    range(0, 10, 2)
    

    (Bidrag från Daniel Stutzbach i bpo-9213, av Alexander Belopolsky i bpo-2690, och av Nick Coghlan i bpo-10889.)

  • Den inbyggda funktionen callable() från Py2.x har återuppstått. Den ger ett kortfattat och läsbart alternativ till att använda en abstrakt basklass i ett uttryck som isinstance(x, collections.Callable):

    >>> callable(max)
    True
    >>> callable(20)
    False
    

    (Se bpo-10518.)

  • Pythons importmekanism kan nu läsa in moduler som är installerade i kataloger med icke-ASCII-tecken i sökvägsnamnet. Detta löste ett irriterande problem med hemkataloger för användare med icke-ASCII-tecken i sina användarnamn.

(Krävde omfattande arbete av Victor Stinner i bpo-9425.)

Nya, förbättrade och utfasade moduler

Pythons standardbibliotek har genomgått betydande underhållsinsatser och kvalitetsförbättringar.

Den största nyheten för Python 3.2 är att email-paketet, mailbox-modulen och nntplib-modulerna nu fungerar korrekt med bytes/text-modellen i Python 3. För första gången finns det korrekt hantering av meddelanden med blandade kodningar.

I hela standardbiblioteket har frågor om kodning och text kontra bytes uppmärksammats mer noggrant. I synnerhet kan interaktioner med operativsystemet nu bättre utbyta icke-ASCII-data med hjälp av Windows MBCS-kodning, lokalmedvetna kodningar eller UTF-8.

En annan viktig nyhet är att stödet för SSL-anslutningar och säkerhetscertifikat har förbättrats avsevärt.

Dessutom implementerar nu fler klasser en context manager för att stödja bekväm och tillförlitlig resursrensning med hjälp av en with-sats.

e-post

Användbarheten av email-paketet i Python 3 har till stor del åtgärdats genom R. David Murrays omfattande arbete. Problemet var att e-postmeddelanden vanligtvis läses och lagras i form av bytes snarare än str text, och de kan innehålla flera kodningar inom ett enda e-postmeddelande. Så e-postpaketet måste utökas för att analysera och generera e-postmeddelanden i bytesformat.

  • Med de nya funktionerna message_from_bytes() och message_from_binary_file() samt de nya klasserna BytesFeedParser och BytesParser kan binära meddelandedata analyseras till modellobjekt.

  • Med bytes som indata till modellen kommer get_payload() som standard att avkoda en meddelandekropp som har en Content-Transfer-Encoding8bit med hjälp av den teckenuppsättning som anges i MIME-rubrikerna och returnera den resulterande strängen.

  • Givet bytes som indata till modellen kommer Generator att konvertera meddelandekroppar som har en Content-Transfer-Encoding8bit till att istället ha en 7bit Content-Transfer-Encoding.

    Rubriker med okodade icke-ASCII-byte anses vara RFC 2047-kodade med teckenuppsättningen unknown-8bit.

  • En ny klass BytesGenerator producerar bytes som utdata och bevarar alla oförändrade icke-ASCII-data som fanns i indata som användes för att bygga modellen, inklusive meddelandetexter med en Content-Transfer-Encoding8bit.

  • Klassen smtplib SMTP accepterar nu en byte-sträng för msg-argumentet till metoden sendmail(), och en ny metod, send_message() accepterar ett Message-objekt och kan eventuellt hämta adresserna from_addr och to_addrs direkt från objektet.

(Föreslagen och implementerad av R. David Murray, bpo-4661 och bpo-10321.)

elementträd

Paketet xml.etree.ElementTree och dess motsvarighet xml.etree.cElementTree har uppdaterats till version 1.3.

Flera nya och användbara funktioner och metoder har lagts till:

Två metoder har utgått:

  • xml.etree.ElementTree.getchildren() använd list(elem) istället.

  • xml.etree.ElementTree.getiterator() använd Element.iter istället.

För mer information om uppdateringen, se Introducing ElementTree på Fredrik Lundhs webbplats.

(Bidrag från Florent Xicluna och Fredrik Lundh, bpo-6472.)

functools

  • Modulen functools innehåller en ny dekorator för cachelagring av funktionsanrop. functools.lru_cache() kan spara upprepade frågor till en extern resurs när resultaten förväntas bli desamma.

    Om du till exempel lägger till en cachningsdekorator i en databasfrågefunktion kan du spara databasåtkomst för populära sökningar:

    >>> import functools
    >>> @functools.lru_cache(maxsize=300)
    ... def get_phone_number(name):
    ...     c = conn.cursor()
    ...     c.execute('SELECT phonenumber FROM phonelist WHERE name=?', (name,))
    ...     return c.fetchone()[0]
    
    >>> for name in user_requests:
    ...     get_phone_number(name)        # cached lookup
    

    För att hjälpa till att välja en effektiv cachestorlek är wrapped-funktionen instrumenterad för att spåra cachestatistik:

    >>> get_phone_number.cache_info()
    CacheInfo(hits=4805, misses=980, maxsize=300, currsize=300)
    

    Om telefonlistans tabell uppdateras kan det föråldrade innehållet i cacheminnet rensas med:

    >>> get_phone_number.cache_clear()
    

    (Bidraget kommer från Raymond Hettinger och innehåller designidéer från Jim Baker, Miki Tebeka och Nick Coghlan; se recipe 498245, recipe 577479, bpo-10586, och bpo-10593)

  • Dekoratorn functools.wraps() lägger nu till ett attribut __wrapped__ som pekar på den ursprungliga anropsbara funktionen. Detta gör att inkapslade funktioner kan introspekteras. Den kopierar också __annotations__ om den är definierad. Och nu hoppar den också elegant över saknade attribut som __doc__ som kanske inte är definierade för den inkapslade anropbara funktionen.

    I exemplet ovan kan cacheminnet tas bort genom att återställa den ursprungliga funktionen:

    >>> get_phone_number = get_phone_number.__wrapped__    # uncached function
    

    (Av Nick Coghlan och Terrence Cole; bpo-9567, bpo-3445, och bpo-8814.)

  • För att hjälpa till att skriva klasser med rika jämförelsemetoder kommer en ny dekorator functools.total_ordering() att använda befintliga metoder för likhet och olikhet för att fylla i de återstående metoderna.

    Om du till exempel anger __eq__ och __lt__ kommer total_ordering() att fylla i __le__, __gt__ och __ge__:

    @total_beställning
    klass Student:
        def __eq__(self, other):
            return ((self.efternamn.lower(), self.förnamn.lower()) ==
                    (other.efternamn.lower(), other.förnamn.lower()))
    
        def __lt__(self, annan):
            return ((self.efternamn.lower(), self.förnamn.lower()) <
                    (andra.efternamn.lägre(), andra.förnamn.lägre()))
    

    Med dekoratorn total_ordering fylls de återstående jämförelsemetoderna i automatiskt.

    (Bidrag från Raymond Hettinger.)

  • För att underlätta portning av program från Python 2 konverterar funktionen functools.cmp_to_key() en gammaldags jämförelsefunktion till modern key function:

    >>> # locale-aware sort order
    >>> sorted(iterable, key=cmp_to_key(locale.strcoll))
    

    Exempel på sortering och en kortfattad sorteringshandledning finns i handledningen Sorting HowTo.

    (Bidrag från Raymond Hettinger.)

itertools

  • Modulen itertools har en ny funktion accumulate() som bygger på APL:s operator scan och Numpys funktion accumulate:

    >>> from itertools import accumulate
    >>> list(accumulate([8, 2, 50]))
    [8, 10, 60]
    
    >>> prob_dist = [0.1, 0.4, 0.2, 0.3]
    >>> list(accumulate(prob_dist))      # cumulative probability distribution
    [0.1, 0.5, 0.7, 1.0]
    

    Ett exempel på användning av accumulate() finns i exempel för slumpmodulen.

    (Bidrag från Raymond Hettinger och med designförslag från Mark Dickinson.)

samlingar

  • Klassen collections.Counter har nu två former av subtraktion på plats, den befintliga operatorn -= för mättande subtraktion och den nya metoden subtract() för vanlig subtraktion. Den förra är lämplig för multisets som bara har positiva räkningar, och den senare är mer lämplig för användningsfall som tillåter negativa räkningar:

    >>> from collections import Counter
    >>> tally = Counter(dogs=5, cats=3)
    >>> tally -= Counter(dogs=2, cats=8)    # saturating subtraction
    >>> tally
    Counter({'dogs': 3})
    
    >>> tally = Counter(dogs=5, cats=3)
    >>> tally.subtract(dogs=2, cats=8)      # regular subtraction
    >>> tally
    Counter({'dogs': 3, 'cats': -5})
    

    (Bidrag från Raymond Hettinger.)

  • Klassen collections.OrderedDict har en ny metod move_to_end() som tar en befintlig nyckel och flyttar den till antingen den första eller sista positionen i den ordnade sekvensen.

    Standardinställningen är att flytta ett objekt till den sista positionen. Detta motsvarar att förnya en post med od[k] = od.pop(k).

    En snabb ”move-to-end”-operation är användbar för att sekvensera poster. En ordnad ordbok kan t.ex. användas för att spåra åtkomstordning genom att åldra poster från den äldsta till den senast åtkomna.

    >>> from collections import OrderedDict
    >>> d = OrderedDict.fromkeys(['a', 'b', 'X', 'd', 'e'])
    >>> list(d)
    ['a', 'b', 'X', 'd', 'e']
    >>> d.move_to_end('X')
    >>> list(d)
    ['a', 'b', 'd', 'e', 'X']
    

    (Bidrag från Raymond Hettinger.)

  • Klassen collections.deque har fått två nya metoder count() och reverse() som gör dem mer utbytbara mot list-objekt:

    >>> from collections import deque
    >>> d = deque('simsalabim')
    >>> d.count('s')
    2
    >>> d.reverse()
    >>> d
    deque(['m', 'i', 'b', 'a', 'l', 'a', 's', 'm', 'i', 's'])
    

    (Bidrag från Raymond Hettinger.)

gängning

Modulen threading har en ny Barrier synkroniseringsklass för att få flera trådar att vänta tills alla har nått en gemensam barriärpunkt. Barriärer är användbara för att se till att en uppgift med flera förhandsvillkor inte körs förrän alla föregångaruppgifter är klara.

Barriärer kan fungera med ett godtyckligt antal trådar. Detta är en generalisering av en Rendezvous som är definierad för endast två trådar.

Implementerad som en tvåfasig cyklisk barriär är Barrier-objekt lämpliga för användning i loopar. De separata faserna fyllning och dränering säkerställer att alla trådar släpps (dräneras) innan någon av dem kan loopa tillbaka och återinträda i barriären. Barriären återställs helt efter varje cykel.

Exempel på användning av barriärer:

från trådning import Barriär, Tråd

def hämta_röster(webbplats):
    valsedlar = conduct_election(webbplats)
    all_polls_closed.wait() # räkna inte förrän alla vallokaler är stängda
    totals = sammanfatta(valsedlar)
    publicera(webbplats, totalsummor)

all_polls_closed = Barriär(len(webbplatser))
för webbplats i webbplatser:
    Thread(target=get_votes, args=(site,)).start()

I det här exemplet upprätthåller barriären en regel om att rösterna inte får räknas på någon vallokal förrän alla vallokaler har stängts. Lägg märke till hur en lösning med en barriär liknar en lösning med threading.Thread.join(), men trådarna hålls vid liv och fortsätter att utföra arbete (sammanställning av röster) efter att barriärpunkten har passerats.

Om någon av de föregående uppgifterna kan hänga sig eller försenas kan en barriär skapas med en valfri timeout-parameter. Om timeout-perioden sedan löper ut innan alla föregångaruppgifter når barriärpunkten, släpps alla väntande trådar och ett BrokenBarrierError-undantag tas upp:

def get_votes(webbplats):
    röstsedlar = conduct_election(webbplats)
    försök:
        all_polls_closed.wait(timeout=midnatt - time.now())
    except BrokenBarrierError:
        lockbox = försegla_röstsedlar(röstsedlar)
        queue.put(låda)
    else:
        totals = sammanfatta(valsedlar)
        publicera(webbplats, totalsumma)

I det här exemplet tillämpar barriären en mer robust regel. Om vissa vallokaler inte hinner bli klara före midnatt tar barriären timeout och valsedlarna förseglas och läggs i en kö för senare hantering.

Se Barrier Synchronization Patterns för fler exempel på hur barriärer kan användas i parallella beräkningar. Det finns också en enkel men grundlig förklaring av barriärer i The Little Book of Semaphores, avsnitt 3.6.

(Bidrag från Kristján Valur Jónsson med en API-granskning av Jeffrey Yasskin i bpo-8777.)

datetime och tid

  • Modulen datetime har en ny typ timezone som implementerar gränssnittet tzinfo genom att returnera en fast UTC-offset och ett tidszonnamn. Detta gör det enklare att skapa tidszonsmedvetna datetime-objekt:

    >>> from datetime import datetime, timezone
    
    >>> datetime.now(timezone.utc)
    datetime.datetime(2010, 12, 8, 21, 4, 2, 923754, tzinfo=datetime.timezone.utc)
    
    >>> datetime.strptime("01/01/2000 12:00 +0000", "%m/%d/%Y %H:%M %z")
    datetime.datetime(2000, 1, 1, 12, 0, tzinfo=datetime.timezone.utc)
    
  • Dessutom kan timedelta-objekt nu multipliceras med float och divideras med float och int-objekt. Och timedelta-objekt kan nu divideras med varandra.

  • Metoden datetime.date.strftime() är inte längre begränsad till år efter 1900. Det nya årtalsintervallet som stöds är från 1000 till och med 9999.

  • När ett tvåsiffrigt årtal används i en tidstupel, har tolkningen styrts av time.accept2dyear. Standardvärdet är True vilket innebär att för ett tvåsiffrigt årtal gissas århundradet enligt POSIX-reglerna som styr strptime-formatet %y.

    Från och med Py3.2 kommer användning av heuristiken för gissning av århundraden att ge upphov till en DeprecationWarning. Istället rekommenderas det att time.accept2dyear sätts till False så att stora datumintervall kan användas utan gissningar:

    >>> import time, warnings
    >>> warnings.resetwarnings()      # remove the default warning filters
    
    >>> time.accept2dyear = True      # guess whether 11 means 11 or 2011
    >>> time.asctime((11, 1, 1, 12, 34, 56, 4, 1, 0))
    Warning (from warnings module):
      ...
    DeprecationWarning: Century info guessed for a 2-digit year.
    'Fri Jan  1 12:34:56 2011'
    
    >>> time.accept2dyear = False     # use the full range of allowable dates
    >>> time.asctime((11, 1, 1, 12, 34, 56, 4, 1, 0))
    'Fri Jan  1 12:34:56 11'
    

    Flera funktioner har nu betydligt utökade datumintervall. När time.accept2dyear är false kommer funktionen time.asctime() att acceptera alla årtal som ryms i ett C int, medan funktionerna time.mktime() och time.strftime() kommer att acceptera hela det intervall som stöds av motsvarande operativsystemfunktioner.

(Bidrag från Alexander Belopolsky och Victor Stinner i bpo-1289118, bpo-5094, bpo-6641, bpo-2706, bpo-1777412, bpo-8013 och bpo-10827.)

matematik

Modulen math har uppdaterats med sex nya funktioner som inspirerats av C99-standarden.

Funktionen isfinite() är ett pålitligt och snabbt sätt att upptäcka speciella värden. Den returnerar True för vanliga tal och False för Nan eller Infinity:

>>> from math import isfinite
>>> [isfinite(x) for x in (123, 4.56, float('Nan'), float('Inf'))]
[True, True, False, False]

Funktionen expm1() beräknar e**x-1 för små värden på x utan den precisionsförlust som vanligtvis följer med subtraktion av nästan lika stora mängder:

>>> from math import expm1
>>> expm1(0.013671875)   # more accurate way to compute e**x-1 for a small x
0.013765762467652909

Funktionen erf() beräknar en sannolikhetsintegral eller Gaussisk felfunktion. Den komplementära felfunktionen, erfc(), är 1 - erf(x):

>>> from math import erf, erfc, sqrt
>>> erf(1.0/sqrt(2.0))   # portion of normal distribution within 1 standard deviation
0.682689492137086
>>> erfc(1.0/sqrt(2.0))  # portion of normal distribution outside 1 standard deviation
0.31731050786291404
>>> erf(1.0/sqrt(2.0)) + erfc(1.0/sqrt(2.0))
1.0

Funktionen gamma() är en kontinuerlig utvidgning av faktorialfunktionen. Se https://en.wikipedia.org/wiki/Gamma_function för detaljer. Eftersom funktionen är relaterad till faktorialtal blir den stor även för små värden på x, så det finns också en lgamma()-funktion för att beräkna den naturliga logaritmen av gammafunktionen:

>>> from math import gamma, lgamma
>>> gamma(7.0)           # six factorial
720.0
>>> lgamma(801.0)        # log(800 factorial)
4551.950730698041

(Bidrag från Mark Dickinson.)

abc

Modulen abc har nu stöd för abstractclassmethod() och abstractstaticmethod().

Dessa verktyg gör det möjligt att definiera en abstrakt basklass som kräver att en viss klassmetod() eller statiskmetod() implementeras:

klass Temperatur(metaklass=abc.ABCMeta):
    @abc.abstractclassmethod
    def from_fahrenheit(cls, t):
        ...
    @abc.abstractclassmethod
    def from_celsius(cls, t):
        ...

(Patch inlämnad av Daniel Urban; bpo-5867.)

io

Klassen io.BytesIO har en ny metod, getbuffer(), som ger funktionalitet som liknar memoryview(). Den skapar en redigerbar vy av data utan att göra en kopia. Buffertens slumpmässiga åtkomst och stöd för slice-notation är väl lämpade för redigering på plats:

>>> REC_LEN, LOC_START, LOC_LEN = 34, 7, 11

>>> def change_location(buffer, record_number, location):
...     start = record_number * REC_LEN + LOC_START
...     buffer[start: start+LOC_LEN] = location

>>> import io

>>> byte_stream = io.BytesIO(
...     b'G3805  storeroom  Main chassis    '
...     b'X7899  shipping   Reserve cog     '
...     b'L6988  receiving  Primary sprocket'
... )
>>> buffer = byte_stream.getbuffer()
>>> change_location(buffer, 1, b'warehouse  ')
>>> change_location(buffer, 0, b'showroom   ')
>>> print(byte_stream.getvalue())
b'G3805  showroom   Main chassis    '
b'X7899  warehouse  Reserve cog     '
b'L6988  receiving  Primary sprocket'

(Bidrag från Antoine Pitrou i bpo-5506.)

reprlib

När man skriver en __repr__()-metod för en egen container är det lätt att glömma bort att hantera fallet där en medlem refererar tillbaka till containern själv. Pythons inbyggda objekt som list och set hanterar självreferenser genom att visa ”…” i den rekursiva delen av representationssträngen.

För att hjälpa till att skriva sådana __repr__()-metoder har modulen reprlib en ny dekorator, recursive_repr(), för att upptäcka rekursiva anrop till __repr__() och ersätta dem med en platshållarsträng:

>>> class MyList(list):
...     @recursive_repr()
...     def __repr__(self):
...         return '<' + '|'.join(map(repr, self)) + '>'
...
>>> m = MyList('abc')
>>> m.append(m)
>>> m.append('x')
>>> print(m)
<'a'|'b'|'c'|...|'x'>

(Bidrag från Raymond Hettinger i bpo-9826 och bpo-9840.)

loggning

Förutom den ordboksbaserade konfigurationen som beskrivs ovan innehåller paketet logging många andra förbättringar.

Loggningsdokumentationen har utökats med en grundläggande handledning, en avancerad handledning, och en kokbok med loggningsrecept. Dessa dokument är det snabbaste sättet att lära sig mer om loggning.

Uppsättningsfunktionen logging.basicConfig() har fått ett style-argument för att stödja tre olika typer av strängformatering. Det är som standard ”%” för traditionell %-f-formatering, kan sättas till ”{” för den nya str.format()-stilen, eller kan sättas till ”$” för den shell-stilformatering som tillhandahålls av string.Template. Följande tre konfigurationer är likvärdiga:

>>> from logging import basicConfig
>>> basicConfig(style='%', format="%(name)s -> %(levelname)s: %(message)s")
>>> basicConfig(style='{', format="{name} -> {levelname} {message}")
>>> basicConfig(style='$', format="$name -> $levelname: $message")

Om ingen konfiguration görs innan en loggningshändelse inträffar finns det nu en standardkonfiguration som använder en StreamHandler riktad till sys.stderr för händelser på WARNING-nivå eller högre. Tidigare skulle en händelse som inträffade innan en konfiguration konfigurerades antingen ge upphov till ett undantag eller tyst släppa händelsen beroende på värdet för logging.raiseExceptions. Den nya standardhanteraren lagras i logging.lastResort.

Användningen av filter har förenklats. Istället för att skapa ett Filter-objekt kan predikatet vara vilken Python-kallbar som helst som returnerar True eller False.

Det finns ett antal andra förbättringar som ger ökad flexibilitet och förenklar konfigurationen. Se moduldokumentationen för en fullständig lista över ändringar i Python 3.2.

csv

Modulen csv stöder nu en ny dialekt, unix_dialect, som använder citattecken för alla fält och en traditionell Unix-stil med '\n' som radavslutare. Det registrerade dialektnamnet är unix.

Klassen csv.DictWriter har en ny metod, writeheader() för att skriva ut en första rad för att dokumentera fältnamnen:

>>> import csv, sys
>>> w = csv.DictWriter(sys.stdout, ['name', 'dept'], dialect='unix')
>>> w.writeheader()
"name","dept"
>>> w.writerows([
...     {'name': 'tom', 'dept': 'accounting'},
...     {'name': 'susan', 'dept': 'Salesl'}])
"tom","accounting"
"susan","sales"

(Ny dialekt föreslagen av Jay Talbot i bpo-5975, och den nya metoden föreslagen av Ed Abraham i bpo-1537721.)

contextlib

Det finns ett nytt och lite häpnadsväckande verktyg ContextDecorator som är till hjälp för att skapa en context manager som gör dubbel tjänst som en funktionsdekorator.

Som en bekvämlighet används denna nya funktionalitet av contextmanager() så att ingen extra ansträngning behövs för att stödja båda rollerna.

Den grundläggande idén är att både kontexthanterare och funktionsdekoratorer kan användas för pre-action och post-action wrappers. Kontexthanterare omsluter en grupp satser med hjälp av ett with-sats och funktionsdekoratorer omsluter en grupp satser som är inneslutna i en funktion. Ibland finns det alltså ett behov av att skriva en pre-action eller post-action wrapper som kan användas i båda rollerna.

Till exempel är det ibland användbart att paketera funktioner eller grupper av satser med en logger som kan spåra tidpunkten för inmatning och tidpunkten för avslutning. I stället för att skriva både en funktionsdekorator och en kontexthanterare för uppgiften, ger contextmanager() båda möjligheterna i en enda definition:

from contextlib import contextmanager
import logging

logging.basicConfig(level=logging.INFO)

@contextmanager
def track_entry_and_exit(name):
    logging.info('Entering: %s', name)
    yield
    logging.info('Exiting: %s', name)

Tidigare skulle detta bara ha kunnat användas som en kontexthanterare:

med track_entry_and_exit('widget loader'):
    print('En tidskrävande aktivitet sker här')
    ladda_widget()

Nu kan den även användas som inredningsdetalj:

@track_entry_and_exit('widgetladdare')
def aktivitet():
    print('Någon tidskrävande aktivitet sker här')
    ladda_widget()

Att försöka uppfylla två roller samtidigt innebär vissa begränsningar för tekniken. Kontexthanterare har normalt flexibiliteten att returnera ett argument som kan användas av en with-sats, men det finns ingen parallell för funktionsdekoratorer.

I exemplet ovan finns det inte något rent sätt för kontexthanteraren track_entry_and_exit att returnera en loggningsinstans för användning i brödtexten i slutna satser.

(Bidrag från Michael Foord i bpo-9110.)

decimaltal och bråk

Mark Dickinson skapade ett elegant och effektivt system för att säkerställa att olika numeriska datatyper har samma hashvärde när deras faktiska värden är lika (bpo-8188):

assert hash(Fraktion(3, 2)) == hash(1,5) == \
       hash(Decimal("1,5")) == hash(komplex(1,5, 0))

En del av hashdetaljerna visas genom ett nytt attribut, sys.hash_info, som beskriver hashvärdets bitbredd, primtalsmodulen, hashvärdena för infinity och nan samt den multiplikator som används för imaginärdelen av ett tal:

>>> sys.hash_info
sys.hash_info(width=64, modulus=2305843009213693951, inf=314159, nan=0, imag=1000003)

Ett tidigt beslut om att begränsa interoperabiliteten för olika numeriska typer har lättats upp. Det är fortfarande inte tillåtet (och inte heller lämpligt) att ha implicit mixning i aritmetiska uttryck som Decimal('1.1') + float('1.1') eftersom det senare förlorar information i processen att konstruera den binära floaten. Men eftersom befintliga flyttalsvärden kan konverteras förlustfritt till antingen en decimal eller rationell representation, är det vettigt att lägga till dem i konstruktorn och stödja jämförelser av blandad typ.

Liknande ändringar har gjorts i fractions.Fraction så att metoderna from_float() och from_decimal() inte längre behövs (bpo-8294):

>>> from decimal import Decimal
>>> from fractions import Fraction
>>> Decimal(1.1)
Decimal('1.100000000000000088817841970012523233890533447265625')
>>> Fraction(1.1)
Fraction(2476979795053773, 2251799813685248)

En annan användbar förändring för modulen decimal är att attributet Context.clamp nu är offentligt. Detta är användbart för att skapa kontexter som motsvarar de decimala utbytesformat som anges i IEEE 754 (se bpo-8540).

(Bidrag från Mark Dickinson och Raymond Hettinger.)

ftp

Klassen ftplib.FTP har nu stöd för kontexthanteringsprotokollet för att ovillkorligen konsumera socket.error-undantag och stänga FTP-anslutningen när den är klar:

>>> from ftplib import FTP
>>> with FTP("ftp1.at.proftpd.org") as ftp:
        ftp.login()
        ftp.dir()

'230 Anonymous login ok, restrictions apply.'
dr-xr-xr-x   9 ftp      ftp           154 May  6 10:43 .
dr-xr-xr-x   9 ftp      ftp           154 May  6 10:43 ..
dr-xr-xr-x   5 ftp      ftp          4096 May  6 10:43 CentOS
dr-xr-xr-x   3 ftp      ftp            18 Jul 10  2008 Fedora

Andra filliknande objekt som mmap.mmap och fileinput.input() har också automatiskt stängande kontexthanterare:

med fileinput.input(files=('log1.txt', 'log2.txt')) som f:
    för rad i f:
        process(rad)

(Bidrag från Tarek Ziadé och Giampaolo Rodolà i bpo-4972, och från Georg Brandl i bpo-8046 och bpo-1286.)

Klassen FTP_TLS accepterar nu en context-parameter, som är ett ssl.SSLContext-objekt som gör det möjligt att samla SSL-konfigurationsalternativ, certifikat och privata nycklar i en enda (potentiellt långlivad) struktur.

(Bidrag från Giampaolo Rodolà; bpo-8806.)

popen

Funktionerna os.popen() och subprocess.Popen() stöder nu with-satser för automatisk stängning av filbeskrivare.

(Bidrag från Antoine Pitrou och Brian Curtin i bpo-7461 och bpo-10554.)

välj

Modulen select har nu ett nytt, konstant attribut, PIPE_BUF, som anger det minsta antal byte som garanterat inte blockeras när select.select() säger att en pipa är klar för skrivning.

>>> import select
>>> select.PIPE_BUF
512

(Tillgänglig på Unix-system. Patch av Sébastien Sablé i bpo-9862)

gzip och zipfil

gzip.GzipFile implementerar nu io.BufferedIOBase abstrakt basklass (förutom truncate())). Den har också en peek()-metod och stödjer filobjekt som inte kan tittas på och som är nollfyllda.

Modulen gzip har även fått funktionerna compress() och decompress() för enklare komprimering och dekomprimering i minnet. Tänk på att text måste kodas som bytes innan komprimering och dekomprimering:

>>> import gzip
>>> s = 'Three shall be the number thou shalt count, '
>>> s += 'and the number of the counting shall be three'
>>> b = s.encode()                        # convert to utf-8
>>> len(b)
89
>>> c = gzip.compress(b)
>>> len(c)
77
>>> gzip.decompress(c).decode()[:42]      # decompress and convert to text
'Three shall be the number thou shalt count'

(Bidrag från Anand B. Pillai i bpo-3488; och av Antoine Pitrou, Nir Aides och Brian Curtin i bpo-9962, bpo-1675951, bpo-7471 och bpo-2846.)

Klassen zipfile.ZipExtFile har också omarbetats internt för att representera filer som lagras i ett arkiv. Den nya implementeringen är betydligt snabbare och kan förpackas i ett io.BufferedReader-objekt för att öka hastigheten ytterligare. Den löser också ett problem där sammanflätade anrop till read och readline gav fel resultat.

(Patch inlämnad av Nir Aides i bpo-7610.)

tarfil

Klassen TarFile kan nu användas som en kontexthanterare. Dessutom har dess metod add() ett nytt alternativ, filter, som styr vilka filer som läggs till i arkivet och gör det möjligt att redigera filens metadata.

Det nya alternativet filter ersätter den äldre, mindre flexibla parametern exclude som nu är föråldrad. Om den anges måste den valfria filter-parametern vara en nyckelordsargument. Den användartillhandahållna filterfunktionen accepterar ett TarInfo-objekt och returnerar ett uppdaterat TarInfo-objekt, eller om den vill att filen ska uteslutas kan funktionen returnera None:

>>> import tarfile, glob

>>> def myfilter(tarinfo):
...     if tarinfo.isfile():             # only save real files
...         tarinfo.uname = 'monty'      # redact the user name
...         return tarinfo

>>> with tarfile.open(name='myarchive.tar.gz', mode='w:gz') as tf:
...     for filename in glob.glob('*.txt'):
...         tf.add(filename, filter=myfilter)
...     tf.list()
-rw-r--r-- monty/501        902 2011-01-26 17:59:11 annotations.txt
-rw-r--r-- monty/501        123 2011-01-26 17:59:11 general_questions.txt
-rw-r--r-- monty/501       3514 2011-01-26 17:59:11 prion.txt
-rw-r--r-- monty/501        124 2011-01-26 17:59:11 py_todo.txt
-rw-r--r-- monty/501       1399 2011-01-26 17:59:11 semaphore_notes.txt

(Föreslagen av Tarek Ziadé och implementerad av Lars Gustäbel i bpo-6856.)

hashlib

Modulen hashlib har två nya konstanta attribut som listar de hashingalgoritmer som garanterat finns i alla implementationer och de som är tillgängliga i den aktuella implementationen:

>>> import hashlib

>>> hashlib.algorithms_guaranteed
{'sha1', 'sha224', 'sha384', 'sha256', 'sha512', 'md5'}

>>> hashlib.algorithms_available
{'md2', 'SHA256', 'SHA512', 'dsaWithSHA', 'mdc2', 'SHA224', 'MD4', 'sha256',
'sha512', 'ripemd160', 'SHA1', 'MDC2', 'SHA', 'SHA384', 'MD2',
'ecdsa-with-SHA1','md4', 'md5', 'sha1', 'DSA-SHA', 'sha224',
'dsaEncryption', 'DSA', 'RIPEMD160', 'sha', 'MD5', 'sha384'}

(Föreslagen av Carl Chenet i bpo-7418.)

ast

Modulen ast har ett underbart allmänt verktyg för säker utvärdering av uttryckssträngar med Pythons litterala syntax. Funktionen ast.literal_eval() fungerar som ett säkert alternativ till den inbyggda funktionen eval() som lätt kan missbrukas. Python 3.2 lägger till bytes och set literaler till listan över typer som stöds: strängar, bytes, tal, tupler, listor, dicts, set, booleaner och None.

>>> from ast import literal_eval

>>> request = "{'req': 3, 'func': 'pow', 'args': (2, 0.5)}"
>>> literal_eval(request)
{'args': (2, 0.5), 'req': 3, 'func': 'pow'}

>>> request = "os.system('do something harmful')"
>>> literal_eval(request)
Traceback (most recent call last):
  ...
ValueError: malformed node or string: <_ast.Call object at 0x101739a10>

(Implementerat av Benjamin Peterson och Georg Brandl.)

os

Olika operativsystem använder olika kodningar för filnamn och miljövariabler. Modulen os tillhandahåller två nya funktioner, fsencode() och fsdecode(), för kodning och avkodning av filnamn:

>>> import os
>>> filename = 'Sehenswürdigkeiten'
>>> os.fsencode(filename)
b'Sehensw\xc3\xbcrdigkeiten'

Vissa operativsystem tillåter direkt åtkomst till kodade bytes i miljön. Om så är fallet kommer konstanten os.supports_bytes_environ att vara true.

För direktåtkomst till kodade miljövariabler (om sådana finns), använd den nya funktionen os.getenvb() eller använd os.environb som är en bytesversion av os.environ.

(Bidrag från Victor Stinner.)

shutil

Funktionen shutil.copytree() har fått två nya alternativ:

  • ignore_dangling_symlinks: när symlinks=False så att funktionen kopierar en fil som en symlänk pekar på, inte själva symlänken. Detta alternativ kommer att tysta felet som uppstår om filen inte existerar.

  • copy_function: är en anropbar funktion som kommer att användas för att kopiera filer. shutil.copy2() används som standard.

(Bidrag från Tarek Ziadé.)

Dessutom har modulen shutil nu stöd för archiving operations för zipfiler, okomprimerade tarfiler, gzippade tarfiler och bzippade tarfiler. Det finns även funktioner för att registrera ytterligare filformat för arkivering (t.ex. xz-komprimerade tarfiler eller anpassade format).

De viktigaste funktionerna är make_archive() och unpack_archive(). Som standard arbetar båda i den aktuella katalogen (som kan ställas in med os.chdir()) och i alla underkataloger. Arkivets filnamn måste specificeras med ett fullständigt sökvägsnamn. Arkiveringssteget är icke-destruktivt (originalfilerna lämnas oförändrade).

>>> import shutil, pprint

>>> os.chdir('mydata')  # change to the source directory
>>> f = shutil.make_archive('/var/backup/mydata',
...                         'zip')      # archive the current directory
>>> f                                   # show the name of archive
'/var/backup/mydata.zip'
>>> os.chdir('tmp')                     # change to an unpacking
>>> shutil.unpack_archive('/var/backup/mydata.zip')  # recover the data

>>> pprint.pprint(shutil.get_archive_formats())  # display known formats
[('bztar', "bzip2'ed tar-file"),
 ('gztar', "gzip'ed tar-file"),
 ('tar', 'uncompressed tar file'),
 ('zip', 'ZIP file')]

>>> shutil.register_archive_format(     # register a new archive format
...     name='xz',
...     function=xz.compress,           # callable archiving function
...     extra_args=[('level', 8)],      # arguments to the function
...     description='xz compression'
... )

(Bidrag från Tarek Ziadé.)

sqlite3

Modulen sqlite3 har uppdaterats till pysqlite version 2.6.0. Den har två nya funktioner.

(Bidrag från R. David Murray och Shashwat Anand; bpo-8845.)

html

En ny html-modul introducerades med endast en enda funktion, escape(), som används för att undkomma reserverade tecken från HTML-markup:

>>> import html
>>> html.escape('x > 2 && x < 7')
'x &gt; 2 &amp;&amp; x &lt; 7'

kortplats

Modulen socket har fått två nya förbättringar.

  • Socket-objekt har nu en detach()-metod som sätter sockeln i stängt tillstånd utan att faktiskt stänga den underliggande filbeskrivaren. Den senare kan sedan återanvändas för andra ändamål. (Tillagd av Antoine Pitrou; bpo-8524.)

  • socket.create_connection() stöder nu kontexthanteringsprotokollet för att ovillkorligen konsumera socket.error undantag och för att stänga uttaget när det är klart. (Bidrag från Giampaolo Rodolà; bpo-9794.)

ssl

Modulen ssl lade till ett antal funktioner för att uppfylla vanliga krav på säkra (krypterade, autentiserade) Internetanslutningar:

  • En ny klass, SSLContext, fungerar som en behållare för beständig SSL-data, t.ex. protokollinställningar, certifikat, privata nycklar och olika andra alternativ. Den innehåller en wrap_socket() för att skapa ett SSL-uttag från en SSL-kontext.

  • En ny funktion, ssl.match_hostname(), stöder verifiering av serveridentitet för protokoll på högre nivå genom att implementera reglerna för HTTPS (från RFC 2818) som också är lämpliga för andra protokoll.

  • Konstruktorfunktionen ssl.wrap_socket() tar nu ett ciphers-argument. Strängen ciphers listar de tillåtna krypteringsalgoritmerna i det format som beskrivs i OpenSSL-dokumentationen.

  • När modulen ssl länkas mot de senaste versionerna av OpenSSL stöder den nu tillägget Server Name Indication till TLS-protokollet, vilket möjliggör flera ”virtuella värdar” som använder olika certifikat på en enda IP-port. Detta tillägg stöds endast i klientläge och aktiveras genom att skicka argumentet server_hostname till ssl.SSLContext.wrap_socket().

  • Olika alternativ har lagts till i modulen ssl, t.ex. OP_NO_SSLv2 som inaktiverar det osäkra och föråldrade SSLv2-protokollet.

  • Tillägget laddar nu alla OpenSSL-chiffer och digest-algoritmer. Om vissa SSL-certifikat inte kan verifieras rapporteras de som ett ”okänd algoritm”-fel.

  • Den version av OpenSSL som används är nu tillgänglig med hjälp av modulattributen ssl.OPENSSL_VERSION (en sträng), ssl.OPENSSL_VERSION_INFO (en 5-tupel) och ssl.OPENSSL_VERSION_NUMBER (ett heltal).

(Bidrag från Antoine Pitrou i bpo-8850, bpo-1589, bpo-8322, bpo-5639, bpo-4870, bpo-8484 och bpo-8321.)

nntp

Modulen nntplib har en omarbetad implementation med bättre bytes- och textsemantik samt mer praktiska API:er. Dessa förbättringar bryter kompatibiliteten med nntplib-versionen i Python 3.1, som i sig själv var delvis dysfunktionell.

Stöd för säkra anslutningar genom både implicit (med nntplib.NNTP_SSL) och explicit (med nntplib.NNTP.starttls()) TLS har också lagts till.

(Bidrag från Antoine Pitrou i bpo-9360 och Andrew Vant i bpo-1926.)

certifikat

http.client.HTTPSConnection, urllib.request.HTTPSHandler och urllib.request.urlopen() tar nu valfria argument för att möjliggöra kontroll av servercertifikat mot en uppsättning certifikatutfärdare, vilket rekommenderas i offentliga användningar av HTTPS.

(Tillagd av Antoine Pitrou, bpo-9003.)

imaplib

Stöd för explicit TLS på standard IMAP4-anslutningar har lagts till genom den nya metoden imaplib.IMAP4.starttls.

(Bidrag från Lorenzo M. Catucci och Antoine Pitrou, bpo-4471.)

http.klient

Det har gjorts ett antal små API-förbättringar i modulen http.client. De gamla enkla HTTP 0.9-svaren stöds inte längre och parametern strict är avskriven i alla klasser.

Klasserna HTTPConnection och HTTPSConnection har nu en source_address-parameter för en (host, port)-tupel som anger varifrån HTTP-anslutningen görs.

Stöd för certifikatkontroll och virtuella HTTPS-värdar har lagts till i HTTPSConnection.

Metoden request() på anslutningsobjekt tillät ett valfritt body-argument så att ett file object kunde användas för att tillhandahålla innehållet i begäran. Lämpligt nog accepterar body-argumentet nu också ett iterable-objekt så länge det innehåller en explicit Content-Length-rubrik. Detta utökade gränssnitt är mycket mer flexibelt än tidigare.

För att upprätta en HTTPS-anslutning via en proxyserver finns det en ny metod set_tunnel() som anger värd och port för HTTP Connect-tunnel.

För att matcha beteendet hos http.server kodar HTTP-klientbiblioteket nu även headers med ISO-8859-1 (Latin-1)-kodning. Det gjorde det redan för inkommande rubriker, så nu är beteendet konsekvent för både inkommande och utgående trafik. (Se arbete av Armin Ronacher i bpo-10980.)

unittest

Modulen unittest har ett antal förbättringar som stöder testupptäckt för paket, enklare experimentering vid den interaktiva prompten, nya testfallsmetoder, förbättrade diagnosmeddelanden för testfel och bättre metodnamn.

  • Kommandoradsanropet python -m unittest kan nu acceptera filvägar istället för modulnamn för att köra specifika tester (bpo-10620). Den nya testupptäckten kan hitta tester inom paket och lokalisera alla tester som kan importeras från toppnivåkatalogen. Toppnivåkatalogen kan anges med alternativet -t, ett mönster för att matcha filer med -p och en katalog för att starta upptäckten med -s:

    $ python -m unittest discover -s min_proj_dir -p _test.py
    

    (Bidrag från Michael Foord.)

  • Det är nu enklare att experimentera i den interaktiva prompten eftersom klassen unittest.TestCase nu kan instansieras utan argument:

    >>> from unittest import TestCase
    >>> TestCase().assertEqual(pow(2, 3), 8)
    

    (Bidrag från Michael Foord.)

  • Modulen unittest har två nya metoder, assertWarns() och assertWarnsRegex() för att verifiera att en viss typ av varning utlöses av den kod som testas:

    med self.assertWarns(DeprecationWarning):
        legacy_function('XYZ')
    

    (Bidrag från Antoine Pitrou, bpo-9754.)

    En annan ny metod, assertCountEqual() används för att jämföra två iterabler för att avgöra om deras elementantal är lika (om samma element finns med samma antal förekomster oavsett ordning):

    def test_anagram(self):
        self.assertCountEqual('algoritm', 'logaritm')
    

    (Bidrag från Raymond Hettinger.)

  • En av de viktigaste funktionerna i modulen unittest är att skapa meningsfull diagnostik när ett test misslyckas. När det är möjligt registreras misslyckandet tillsammans med en diff av utdata. Detta är särskilt användbart vid analys av loggfiler för misslyckade testkörningar. Men eftersom diffar ibland kan vara omfattande finns det ett nytt attribut maxDiff som anger maximal längd på de diffar som visas.

  • Dessutom har metodnamnen i modulen genomgått ett antal upprensningar.

    Till exempel är assertRegex() det nya namnet för assertRegexpMatches() som var felaktigt namngivet eftersom testet använder re.search(), inte re.match(). Andra metoder som använder reguljära uttryck namnges nu med kortformen ”Regex” istället för ”Regexp” – detta matchar namnen som används i andra unittest-implementationer, matchar Pythons gamla namn för re-modulen och har entydig camel-casing.

    (Bidrag från Raymond Hettinger och implementerat av Ezio Melotti.)

  • För att förbättra konsekvensen kommer vissa gamla metodalias att tas bort till förmån för de föredragna namnen:

    Gammalt namn

    Önskat namn

    assert_`()

    assertTrue()

    assertEquals()

    assertEqual()

    assertNotEquals()

    assertNotEqual()

    assertAlmostEquals()

    assertAlmostEqual()

    assertNotAlmostEquals()

    assertNotAlmostEqual()

    På samma sätt förväntas metoderna TestCase.fail* som är föråldrade i Python 3.1 att tas bort i Python 3.3.

    (Bidrag från Ezio Melotti; bpo-9424.)

  • Metoden assertDictContainsSubset() utrangerades eftersom den var felimplementerad med argumenten i fel ordning. Detta skapade svårdebuggerade optiska illusioner där tester som TestCase().assertDictContainsSubset({'a':1, 'b':2}, {'a':1}) skulle misslyckas.

    (Bidrag från Raymond Hettinger.)

slumpvis

Heltalsmetoderna i modulen random gör nu ett bättre jobb med att producera enhetliga fördelningar. Tidigare beräknade de urval med int(n*random()) som hade en liten bias när n inte var en tvåpotens. Nu görs flera val från ett intervall upp till nästa tvåpotens och ett val behålls endast när det faller inom intervallet 0 <= x < n. De funktioner och metoder som påverkas är randrange(), randint(), choice(), shuffle() och sample().

(Bidrag från Raymond Hettinger; bpo-9025.)

poplib

klassen POP3_SSL accepterar nu en context-parameter, som är ett ssl.SSLContext-objekt som gör det möjligt att samla SSL-konfigurationsalternativ, certifikat och privata nycklar i en enda (potentiellt långlivad) struktur.

(Bidrag från Giampaolo Rodolà; bpo-8807.)

asynkron

asyncore.dispatcher tillhandahåller nu en handle_accepted()-metod som returnerar ett (sock, addr)-par som anropas när en anslutning faktiskt har upprättats med en ny fjärrslutpunkt. Detta är tänkt att användas som en ersättning för gamla handle_accept() och undviker att användaren anropar accept() direkt.

(Bidrag från Giampaolo Rodolà; bpo-6706.)

tempfil

Modulen tempfile har en ny kontexthanterare, TemporaryDirectory som ger enkel deterministisk rensning av temporära kataloger:

with tempfile.TemporaryDirectory() as tmpdirname:
    print('skapade temporär dir:', tmpdirname)

(Bidrag från Neil Schemenauer och Nick Coghlan; bpo-5178.)

inspektera

  • Modulen inspect har fått en ny funktion getgeneratorstate() för att enkelt identifiera det aktuella tillståndet för en generator-iterator:

    >>> from inspect import getgeneratorstate
    >>> def gen():
    ...     yield 'demo'
    ...
    >>> g = gen()
    >>> getgeneratorstate(g)
    'GEN_CREATED'
    >>> next(g)
    'demo'
    >>> getgeneratorstate(g)
    'GEN_SUSPENDED'
    >>> next(g, None)
    >>> getgeneratorstate(g)
    'GEN_CLOSED'
    

    (Bidrag från Rodolpho Eckhardt och Nick Coghlan, bpo-10220.)

  • För att stödja uppslagningar utan möjlighet att aktivera ett dynamiskt attribut har modulen inspect en ny funktion, getattr_static(). Till skillnad från hasattr() är detta en äkta skrivskyddad sökning, som garanterat inte ändrar tillstånd under sökningen:

    >>> class A:
    ...     @property
    ...     def f(self):
    ...         print('Running')
    ...         return 10
    ...
    >>> a = A()
    >>> getattr(a, 'f')
    Running
    10
    >>> inspect.getattr_static(a, 'f')
    <property object at 0x1022bd788>
    

(Bidrag från Michael Foord.)

pydoc

Modulen pydoc tillhandahåller nu ett mycket förbättrat webbservergränssnitt samt ett nytt kommandoradsalternativ -b för att automatiskt öppna ett webbläsarfönster för att visa den servern:

$ pydoc3.2 -b

(Bidrag från Ron Adam; bpo-2001.)

dis

Modulen dis har fått två nya funktioner för att inspektera kod, code_info() och show_code(). Båda ger detaljerad information om kodobjekt för den angivna funktionen, metoden, källkodsträngen eller kodobjektet. Den förstnämnda returnerar en sträng och den sistnämnda skriver ut den:

>>> import dis, random
>>> dis.show_code(random.choice)
Name:              choice
Filename:          /Library/Frameworks/Python.framework/Versions/3.2/lib/python3.2/random.py
Argument count:    2
Kw-only arguments: 0
Number of locals:  3
Stack size:        11
Flags:             OPTIMIZED, NEWLOCALS, NOFREE
Constants:
   0: 'Choose a random element from a non-empty sequence.'
   1: 'Cannot choose from an empty sequence'
Names:
   0: _randbelow
   1: len
   2: ValueError
   3: IndexError
Variable names:
   0: self
   1: seq
   2: i

Dessutom accepterar funktionen dis() nu strängargument så att det vanliga idiomet dis(compile(s, '', 'eval')) kan förkortas till dis(s):

>>> dis('3*x+1 if x%2==1 else x//2')
  1           0 LOAD_NAME                0 (x)
              3 LOAD_CONST               0 (2)
              6 BINARY_MODULO
              7 LOAD_CONST               1 (1)
             10 COMPARE_OP               2 (==)
             13 POP_JUMP_IF_FALSE       28
             16 LOAD_CONST               2 (3)
             19 LOAD_NAME                0 (x)
             22 BINARY_MULTIPLY
             23 LOAD_CONST               1 (1)
             26 BINARY_ADD
             27 RETURN_VALUE
        >>   28 LOAD_NAME                0 (x)
             31 LOAD_CONST               0 (2)
             34 BINARY_FLOOR_DIVIDE
             35 RETURN_VALUE

Sammantaget gör dessa förbättringar det lättare att utforska hur CPython implementeras och att själv se vad språksyntaxen gör under huven.

(Bidrag från Nick Coghlan i bpo-9147.)

dbm

Alla databasmoduler stöder nu metoderna get() och setdefault().

(Föreslagen av Ray Allen i bpo-9523.)

ctyper

En ny typ, ctypes.c_ssize_t representerar datatypen C ssize_t.

plats

Modulen site har tre nya funktioner som är användbara för att rapportera om detaljerna i en viss Python-installation.

>>> import site
>>> site.getsitepackages()
['/Library/Frameworks/Python.framework/Versions/3.2/lib/python3.2/site-packages',
 '/Library/Frameworks/Python.framework/Versions/3.2/lib/site-python',
 '/Library/Python/3.2/site-packages']
>>> site.getuserbase()
'/Users/raymondhettinger/Library/Python/3.2'
>>> site.getusersitepackages()
'/Users/raymondhettinger/Library/Python/3.2/lib/python/site-packages'

En del av webbplatsens funktioner kan enkelt nås direkt från kommandoraden:

$ python -m webbplats --användarbas
/Användare/raymondhettinger/.local
$ python -m webbplats --användarwebbplats
/Users/raymondhettinger/.local/lib/python3.2/site-paket

(Bidrag från Tarek Ziadé i bpo-6693.)

sysconfig

Den nya modulen sysconfig gör det enkelt att hitta installationssökvägar och konfigurationsvariabler som varierar mellan olika plattformar och installationer.

Modulen ger tillgång till enkla åtkomstfunktioner för plattforms- och versionsinformation:

Den ger också tillgång till sökvägar och variabler som motsvarar ett av sju namngivna system som används av distutils. Dessa inkluderar posix_prefix, posix_home, posix_user, nt, nt_user, os2, os2_home:

  • get_paths() skapar en ordbok som innehåller installationssökvägar för det aktuella installationsschemat.

  • get_config_vars() returnerar en ordbok med plattformsspecifika variabler.

Det finns också ett bekvämt kommandoradsgränssnitt:

C:\Python32>python -m sysconfig
Platform: "win32"
Python version: "3.2"
Current installation scheme: "nt"

Paths:
        data = "C:\Python32"
        include = "C:\Python32\Include"
        platinclude = "C:\Python32\Include"
        platlib = "C:\Python32\Lib\site-packages"
        platstdlib = "C:\Python32\Lib"
        purelib = "C:\Python32\Lib\site-packages"
        scripts = "C:\Python32\Scripts"
        stdlib = "C:\Python32\Lib"

Variables:
        BINDIR = "C:\Python32"
        BINLIBDEST = "C:\Python32\Lib"
        EXE = ".exe"
        INCLUDEPY = "C:\Python32\Include"
        LIBDEST = "C:\Python32\Lib"
        SO = ".pyd"
        VERSION = "32"
        abiflags = ""
        base = "C:\Python32"
        exec_prefix = "C:\Python32"
        platbase = "C:\Python32"
        prefix = "C:\Python32"
        projectbase = "C:\Python32"
        py_version = "3.2"
        py_version_nodot = "32"
        py_version_short = "3.2"
        srcdir = "C:\Python32"
        userbase = "C:\Documents and Settings\Raymond\Application Data\Python"

(Flyttad från Distutils av Tarek Ziadé.)

pdb

Felsökningsmodulen pdb har fått ett antal förbättringar av användbarheten:

  • pdb.py har nu ett -c alternativ som exekverar kommandon som ges i en .pdbrc scriptfil.

  • En skriptfil av typen .pdbrc kan innehålla kommandona continue och next som fortsätter felsökningen.

  • Klasskonstruktören Pdb accepterar nu ett nosigint-argument.

  • Nya kommandon: l(list), ll(long list) och source för listning av källkod.

  • Nya kommandon: display och undisplay för att visa eller dölja värdet på ett uttryck om det har ändrats.

  • Nytt kommando: interact för att starta en interaktiv tolk som innehåller de globala och lokala namn som finns i det aktuella omfånget.

  • Brytpunkter kan rensas med hjälp av brytpunktsnummer.

(Bidrag från Georg Brandl, Antonio Cuni och Ilya Sandler.)

konfigurationsanalysator

Modulen configparser har modifierats för att förbättra användbarheten och förutsägbarheten för standardparsern och dess stödda INI-syntax. Den gamla klassen ConfigParser togs bort till förmån för SafeConfigParser som i sin tur har bytt namn till ConfigParser. Stöd för inline-kommentarer är nu avstängt som standard och dubbletter av avsnitt eller alternativ tillåts inte i en enda konfigurationskälla.

Config-parsers fick ett nytt API baserat på mappningsprotokollet:

>>> parser = ConfigParser()
>>> parser.read_string("""
... [DEFAULT]
... location = upper left
... visible = yes
... editable = no
... color = blue
...
... [main]
... title = Main Menu
... color = green
...
... [options]
... title = Options
... """)
>>> parser['main']['color']
'green'
>>> parser['main']['editable']
'no'
>>> section = parser['options']
>>> section['title']
'Options'
>>> section['title'] = 'Options (editable: %(editable)s)'
>>> section['title']
'Options (editable: no)'

Det nya API:et implementeras ovanpå det klassiska API:et, så anpassade parserunderklasser bör kunna använda det utan ändringar.

INI-filstrukturen som accepteras av konfigurationsanalysatorer kan nu anpassas. Användare kan ange alternativa avgränsare för alternativ/värden och kommentarsprefix, ändra namnet på avsnittet DEFAULT eller byta syntax för interpolering.

Det finns stöd för pluggbar interpolering inklusive en extra interpolationshanterare ExtendedInterpolation:

>>> parser = ConfigParser(interpolation=ExtendedInterpolation())
>>> parser.read_dict({'buildout': {'directory': '/home/ambv/zope9'},
...                   'custom': {'prefix': '/usr/local'}})
>>> parser.read_string("""
... [buildout]
... parts =
...   zope9
...   instance
... find-links =
...   ${buildout:directory}/downloads/dist
...
... [zope9]
... recipe = plone.recipe.zope9install
... location = /opt/zope
...
... [instance]
... recipe = plone.recipe.zope9instance
... zope9-location = ${zope9:location}
... zope-conf = ${custom:prefix}/etc/zope.conf
... """)
>>> parser['buildout']['find-links']
'\n/home/ambv/zope9/downloads/dist'
>>> parser['instance']['zope-conf']
'/usr/local/etc/zope.conf'
>>> instance = parser['instance']
>>> instance['zope-conf']
'/usr/local/etc/zope.conf'
>>> instance['zope9-location']
'/opt/zope'

Ett antal mindre funktioner introducerades också, som stöd för att ange kodning i läsoperationer, ange reservvärden för get-funktioner eller läsa direkt från ordböcker och strängar.

(Alla ändringar har gjorts av Łukasz Langa.)

urllib.parse

Ett antal förbättringar av användbarheten har gjorts för modulen urllib.parse.

Funktionen urlparse() stöder nu IPv6-adresser enligt beskrivningen i RFC 2732:

>>> import urllib.parse
>>> urllib.parse.urlparse('http://[dead:beef:cafe:5417:affe:8FA3:deaf:feed]/foo/')
ParseResult(scheme='http',
            netloc='[dead:beef:cafe:5417:affe:8FA3:deaf:feed]',
            path='/foo/',
            params='',
            query='',
            fragment='')

Funktionen urldefrag() returnerar nu en named tuple:

>>> r = urllib.parse.urldefrag('http://python.org/about/#target')
>>> r
DefragResult(url='http://python.org/about/', fragment='target')
>>> r[0]
'http://python.org/about/'
>>> r.fragment
'target'

Och funktionen urlencode() är nu mycket mer flexibel och accepterar antingen en sträng eller en bytes-typ för argumentet query. Om det är en sträng skickas parametrarna safe, encoding och error till quote_plus() för kodning:

>>> urllib.parse.urlencode([
...      ('type', 'telenovela'),
...      ('name', '¿Dónde Está Elisa?')],
...      encoding='latin-1')
'type=telenovela&name=%BFD%F3nde+Est%E1+Elisa%3F'

Som beskrivs i Parsning av ASCII-kodade byte, accepterar nu alla urllib.parse-funktioner ASCII-kodade bytesträngar som indata, så länge de inte blandas med vanliga strängar. Om ASCII-kodade bytesträngar anges som parametrar kommer även returtyperna att vara ASCII-kodade bytesträngar:

>>> urllib.parse.urlparse(b'http://www.python.org:80/about/')
ParseResultBytes(scheme=b'http', netloc=b'www.python.org:80',
                 path=b'/about/', params=b'', query=b'', fragment=b'')

(Arbete av Nick Coghlan, Dan Mahn, och Senthil Kumaran i bpo-2987, bpo-5468, och bpo-9873)

brevlåda

Tack vare en samlad insats av R. David Murray har modulen mailbox åtgärdats för Python 3.2. Utmaningen var att mailbox ursprungligen hade utformats med ett textgränssnitt, men e-postmeddelanden representeras bäst med bytes eftersom olika delar av ett meddelande kan ha olika kodningar.

Lösningen utnyttjade email-paketets binära stöd för att tolka godtyckliga e-postmeddelanden. Dessutom krävde lösningen ett antal API-ändringar.

Som väntat accepterar nu metoden add() för mailbox.Mailbox-objekt binär indata.

StringIO och inmatning av textfiler är föråldrade. Dessutom kommer stränginmatning att misslyckas tidigt om icke-ASCII-tecken används. Tidigare misslyckades det när e-postmeddelandet bearbetades i ett senare steg.

Det finns också stöd för binär utdata. Metoden get_file() returnerar nu en fil i binärt läge (där den tidigare felaktigt satte filen i textläge). Det finns också en ny metod get_bytes() som returnerar en bytes-representation av ett meddelande som motsvarar en given key.

Det är fortfarande möjligt att få icke-binär utdata med hjälp av det gamla API:ets get_string()-metod, men det tillvägagångssättet är inte särskilt användbart. Istället är det bäst att extrahera meddelanden från ett Message-objekt eller att ladda dem från binär indata.

(Bidrag från R. David Murray, med insatser från Steffen Daode Nurpmeso och en första patch av Victor Stinner i bpo-9124.)

sköldpaddsemo

Demonstrationskoden för modulen turtle har flyttats från katalogen Demo till huvudbiblioteket. Den innehåller över ett dussin exempelskript med livliga skärmar. Eftersom den finns på sys.path kan den nu köras direkt från kommandoraden:

$ python -m turtledemo

(Flyttad från Demo-katalogen av Alexander Belopolsky i bpo-10199.)

Multi-threading

  • Mekanismen för serialisering av exekvering av Python-trådar som körs samtidigt (allmänt känd som GIL eller Global Interpreter Lock) har skrivits om. Bland målen fanns mer förutsägbara växlingsintervall och minskad overhead på grund av låskonflikter och antalet efterföljande systemanrop. Begreppet ”kontrollintervall” för att tillåta trådbyten har övergivits och ersatts av en absolut varaktighet uttryckt i sekunder. Denna parameter kan ställas in genom sys.setswitchinterval(). Standardvärdet är för närvarande 5 millisekunder.

    Ytterligare detaljer om implementeringen kan läsas i ett meddelande från python-dev mailing-list (dock har ”priority requests” som anges i detta meddelande inte tagits med för inkludering).

    (Bidrag från Antoine Pitrou.)

  • Vanliga och rekursiva lås accepterar nu ett valfritt timeout-argument till sin acquire()-metod. (Bidrag från Antoine Pitrou; bpo-7316.)

  • På samma sätt har threading.Semaphore.acquire() också fått ett timeout-argument. (Bidrag från Torsten Landschoff; bpo-850728.)

  • Vanliga och rekursiva låsförvärv kan nu avbrytas av signaler på plattformar som använder Pthreads. Detta innebär att Python-program som låser sig medan de förvärvar lås kan dödas genom att upprepade gånger skicka SIGINT till processen (genom att trycka på Ctrl+C i de flesta skal). (Bidrag från Reid Kleckner; bpo-8844.)

Optimeringar

Ett antal små prestandaförbättringar har lagts till:

  • Pythons peephole-optimerare känner nu igen mönster som x i {1, 2, 3} som ett test för medlemskap i en uppsättning konstanter. Optimeraren omformar set till frozenset och lagrar den förbyggda konstanten.

    Nu när hastighetsstraffet är borta är det praktiskt att börja skriva medlemskapstest med set-notation. Denna stil är både semantiskt tydlig och operationellt snabb:

    extension = namn.rpartition('.')[2]
    if extension in {'xml', 'html', 'xhtml', 'css'}:
        handle(namn)
    

    (Patch och ytterligare tester bidragna av Dave Malcolm; bpo-6690).

  • Serialisering och unsialisering av data med modulen pickle är nu flera gånger snabbare.

    (Bidrag från Alexandre Vassalotti, Antoine Pitrou och Unladen Swallow-teamet i bpo-9410 och bpo-3873.)

  • Timsort-algoritmen som används i list.sort() och sorted() körs nu snabbare och använder mindre minne när den anropas med en key function. Tidigare omslöts varje element i en lista med ett temporärt objekt som kom ihåg nyckelvärdet som associerades med varje element. Nu sorteras två arrayer med nycklar och värden parallellt. Detta sparar det minne som används av sorteringsomslagen och sparar tid som går förlorad på att delegera jämförelser.

    (Patch av Daniel Stutzbach i bpo-9915.)

  • JSON-avkodningens prestanda har förbättrats och minnesförbrukningen har minskat när samma sträng upprepas för flera nycklar. Dessutom använder JSON-kodningen nu C-hastighetsökningarna när argumentet sort_keys är sant.

    (Bidrag från Antoine Pitrou i bpo-7451 och från Raymond Hettinger och Antoine Pitrou i bpo-10314.)

  • Rekursiva lås (skapade med API:et threading.RLock()) har nu en C-implementering som gör dem lika snabba som vanliga lås och mellan 10 och 15 gånger snabbare än den tidigare rena Python-implementeringen.

    (Bidrag från Antoine Pitrou; bpo-3001.)

  • Fast-search-algoritmen i stringlib används nu av metoderna split(), rsplit(), splitlines() och replace() för objekten bytes, bytearray och str. På samma sätt används algoritmen också av rfind(), rindex(), rsplit() och rpartition().

    (Patch av Florent Xicluna i bpo-7622 och bpo-7462.)

  • Konvertering av heltal till strängar fungerar nu med två ”siffror” i taget, vilket minskar antalet divisions- och moduloperationer.

    (bpo-6713 av Gawain Bolton, Mark Dickinson och Victor Stinner.)

Det fanns flera andra mindre optimeringar. Set differencing går nu snabbare när den ena operanden är mycket större än den andra (patch av Andress Bennetts i bpo-8685). Metoden array.repeat() har en snabbare implementation (bpo-1569291 by Alexander Belopolsky). Klassen BaseHTTPRequestHandler har effektivare buffring (bpo-3709 by Andrew Schaaf). Funktionen operator.attrgetter() har blivit snabbare (bpo-10160 by Christos Georgiou). Och ConfigParser läser in argument på flera rader lite snabbare (bpo-7113 by Łukasz Langa).

Unicode

Python har uppdaterats till Unicode 6.0.0. Uppdateringen av standarden lägger till över 2.000 nya tecken inklusive emoji-symboler som är viktiga för mobiltelefoner.

Dessutom har den uppdaterade standarden ändrat teckenegenskaperna för två Kannada-tecken (U+0CF1, U+0CF2) och ett numeriskt New Tai Lue-tecken (U+19DA), vilket gör de förra kvalificerade för användning i identifierare medan de senare diskvalificeras. För mer information, se Unicode Character Database Changes.

Codecs

Stöd har lagts till för cp720 arabisk DOS-kodning (bpo-1616979).

MBCS-kodning ignorerar inte längre felhanteringsargumentet. I standardläget strict ger den upphov till ett UnicodeDecodeError när den stöter på en oavkodbar byte-sekvens och ett UnicodeEncodeError för ett oavkodbart tecken.

MBCS codec stöder felhanterarna 'strict' och 'ignore' för avkodning och 'strict' och 'replace' för kodning.

För att emulera Python3.1 MBCS-kodning, välj 'ignore' hanteraren för avkodning och 'replace' hanteraren för kodning.

På Mac OS X avkodar Python kommandoradsargument med 'utf-8' snarare än med lokal kodning.

Som standard använder tarfile kodningen 'utf-8 i Windows (i stället för 'mbcs) och felhanteraren 'surrogateescape i alla operativsystem.

Dokumentation

Dokumentationen fortsätter att förbättras.

  • En tabell med snabblänkar har lagts till längst upp i långa avsnitt som Inbyggda funktioner. När det gäller itertools åtföljs länkarna av tabeller med sammanfattningar i fusklappsstil för att ge en översikt och en minneshjälp utan att behöva läsa hela dokumentationen.

  • I vissa fall kan den rena Python-källkoden vara ett bra komplement till dokumentationen, så nu har många moduler snabblänkar till den senaste versionen av källkoden. Till exempel har dokumentationen för modulen functools en snabblänk högst upp med texten:

    Källkod Lib/functools.py.

    (Bidrag från Raymond Hettinger; se rationale.)

  • Dokumentationen innehåller nu fler exempel och recept. I synnerhet har modulen re ett omfattande avsnitt, Exempel på reguljära uttryck. På samma sätt fortsätter modulen itertools att uppdateras med nya Itertools Recept.

  • Modulen datetime har nu en hjälpartimplementering i ren Python. Ingen funktionalitet har ändrats. Detta ger bara en mer lättläst alternativ implementering.

    (Bidrag från Alexander Belopolsky i bpo-9528.)

  • Den ounderhållna Demo-katalogen har tagits bort. Vissa demos integrerades i dokumentationen, andra flyttades till katalogen Tools/demo och andra togs bort helt och hållet.

    (Bidrag från Georg Brandl i bpo-7962.)

IDLE

  • Formatmenyn har nu ett alternativ för att rensa källfiler genom att ta bort efterföljande blanksteg.

    (Bidrag från Raymond Hettinger; bpo-5150.)

  • IDLE på Mac OS X fungerar nu med både Carbon AquaTk och Cocoa AquaTk.

    (Bidrag från Kevin Walzer, Ned Deily och Ronald Oussoren; bpo-6075.)

Kodförvar

Förutom det befintliga Subversion-kodarkivet på https://svn.python.org finns det nu ett Mercurial-arkiv på https://hg.python.org/.

Efter lanseringen av 3.2 finns det planer på att byta till Mercurial som primärt arkiv. Detta distribuerade versionskontrollsystem bör göra det enklare för medlemmar i gemenskapen att skapa och dela externa ändringsuppsättningar. Se PEP 385 för mer information.

Om du vill lära dig att använda det nya versionshanteringssystemet kan du läsa Snabbstart eller Guide till Mercurial-arbetsflöden.

Ändringar i Build och C API

Ändringar i Pythons byggprocess och i C API inkluderar:

  • Skripten idle, pydoc och 2to3 installeras nu med ett versionsspecifikt suffix på make altinstall (bpo-10679).

  • C-funktionerna som använder Unicode-databasen accepterar och returnerar nu tecken från hela Unicode-intervallet, även på smala Unicode-byggnader (Py_UNICODE_TOLOWER, Py_UNICODE_ISDECIMAL och andra). En synlig skillnad i Python är att unicodedata.numeric() nu returnerar rätt värde för stora kodpunkter, och repr() kan betrakta fler tecken som skrivbara.

    (Rapporterades av Bupjoe Lee och åtgärdades av Amaury Forgeot D’Arc; bpo-5127.)

  • Beräknade gotos är nu aktiverade som standard på kompilatorer som stöds (vilket upptäcks av configure-skriptet). De kan fortfarande inaktiveras selektivt genom att ange --without-computed-gotos.

    (Bidrag från Antoine Pitrou; bpo-9203.)

  • Alternativet --with-wctype-functions togs bort. Den inbyggda unicode-databasen används nu för alla funktioner.

    (Bidrag från Amaury Forgeot D’Arc; bpo-9210.)

  • Hash-värden är nu värden av en ny typ, Py_hash_t, som är definierad att vara lika stor som en pekare. Tidigare var de av typen long, som på vissa 64-bitars operativsystem fortfarande bara är 32 bitar långa. Som ett resultat av den här korrigeringen kan set och dict nu innehålla mer än 2**32 poster på byggen med 64-bitars pekare (tidigare kunde de växa till den storleken men deras prestanda försämrades katastrofalt).

    (Föreslagen av Raymond Hettinger och implementerad av Benjamin Peterson; bpo-9778.)

  • Ett nytt makro Py_VA_COPY kopierar tillståndet för variabelns argumentlista. Det motsvarar C99 va_copy men är tillgängligt på alla Python-plattformar (bpo-2443).

  • En ny C API-funktion PySys_SetArgvEx() tillåter en inbäddad tolk att ställa in sys.argv utan att också ändra sys.path (bpo-5753).

  • PyEval_CallObject() är nu endast tillgänglig i makroform. Funktionsdeklarationen, som behölls av bakåtkompatibilitetsskäl, är nu borttagen – makrot introducerades 1997 (bpo-8276).

  • Det finns en ny funktion PyLong_AsLongLongAndOverflow() som är analog med PyLong_AsLongAndOverflow(). De tjänar båda till att konvertera Python int till en inbyggd typ med fast bredd samtidigt som de ger möjlighet att upptäcka fall där konverteringen inte passar (bpo-7767).

  • Funktionen PyUnicode_CompareWithASCIIString() returnerar nu not equal om Python-strängen är NUL-terminerad.

  • Det finns en ny funktion PyErr_NewExceptionWithDoc() som är som PyErr_NewException() men tillåter att en docstring anges. Detta gör att C-undantag har samma självdokumenterande funktioner som deras rena Python-motsvarigheter (bpo-7033).

  • Vid kompilering med alternativet --with-valgrind kommer allokeringsverktyget pymalloc automatiskt att inaktiveras vid körning under Valgrind. Detta ger förbättrad detektering av minnesläckor när man kör under Valgrind, samtidigt som man kan dra nytta av pymalloc vid andra tillfällen (bpo-2422).

  • Tog bort O?-formatet från PyArg_Parse-funktionerna. Formatet används inte längre och det har aldrig dokumenterats (bpo-8837).

Det gjordes ett antal andra små ändringar i C-API. Se filen Misc/NEWS för en fullständig lista.

Det har också gjorts ett antal uppdateringar av Mac OS X-versionen, se Mac/BuildScript/README.txt för detaljer. För användare som kör en 32/64-bitars version finns det ett känt problem med standard Tcl/Tk på Mac OS X 10.6. Följaktligen rekommenderar vi att du installerar ett uppdaterat alternativ som ActiveState Tcl/Tk 8.5.9. Se https://www.python.org/download/mac/tcltk/ för ytterligare information.

Portning till Python 3.2

I det här avsnittet listas tidigare beskrivna ändringar och andra buggfixar som kan kräva ändringar i din kod:

  • Modulen configparser har ett antal upprensningar. Den största förändringen är att ersätta den gamla ConfigParser-klassen med det sedan länge föredragna alternativet SafeConfigParser. Dessutom finns det ett antal mindre inkompatibiliteter:

    • Syntaxen för interpolering valideras nu för operationerna get() och set(). I standardinterpolationsschemat är endast två tokens med procenttecken giltiga: %(name)s och %%, där det senare är ett undangömt procenttecken.

    • Metoderna set() och add_section() kontrollerar nu att värdena är faktiska strängar. Tidigare kunde typer som inte stöddes införas oavsiktligt.

    • Duplicerade avsnitt eller alternativ från en enda källa ger nu upphov till antingen DuplicateSectionError eller DuplicateOptionError. Tidigare skulle dubbletter tyst skriva över en tidigare post.

    • Inline-kommentarer är nu inaktiverade som standard, så nu kan tecknet ; användas på ett säkert sätt i värden.

    • Kommentarer kan nu vara indragna. För att ; eller # ska visas i början av en rad i värden med flera rader måste de därför interpoleras. Detta förhindrar att prefixtecken för kommentarer i värden misstas för kommentarer.

    • "" är nu ett giltigt värde och konverteras inte längre automatiskt till en tom sträng. För tomma strängar, använd "option =" i en rad.

  • Modulen nntplib har genomgått en omfattande omarbetning, vilket innebär att dess API:er ofta är inkompatibla med 3.1 API:erna.

  • bytearray-objekt kan inte längre användas som filnamn; istället bör de konverteras till bytes.

  • array.tostring() och array.fromstring() har bytt namn till array.tobytes() och array.frombytes() för tydlighetens skull. De gamla namnen har utgått. (Se bpo-8990.)

  • PyArg_Parse*() funktioner:

    • formatet ”t#” har tagits bort: använd ”s#” eller ”s*” istället

    • formaten ”w” och ”w#” har tagits bort: använd ”w*” istället

  • Typen PyCObject, som var föråldrad i 3.1, har tagits bort. För att paketera opaka C-pekare i Python-objekt bör PyCapsule API användas istället; den nya typen har ett väldefinierat gränssnitt för att skicka information om typningssäkerhet och en mindre komplicerad signatur för att anropa en destruktor.

  • Funktionen sys.setfilesystemencoding() togs bort eftersom den hade en felaktig design.

  • Funktionen och metoden random.seed() saltar nu strängfrön med en sha512-hashfunktion. För att komma åt den tidigare versionen av seed för att reproducera Python 3.1-sekvenser, sätt version-argumentet till 1, random.seed(s, version=1).

  • Den tidigare föråldrade funktionen string.maketrans() har tagits bort till förmån för de statiska metoderna bytes.maketrans() och bytearray.maketrans(). Denna ändring löser förvirringen kring vilka typer som stöds av modulen string. Nu har str, bytes och bytearray var och en sina egna maketrans- och translate-metoder med mellanliggande översättningstabeller av lämplig typ.

    (Bidrag från Georg Brandl; bpo-5675.)

  • Den tidigare föråldrade contextlib.nested()-funktionen har tagits bort till förmån för en vanlig with-sats som kan acceptera flera kontexthanterare. Den senare tekniken är snabbare (eftersom den är inbyggd), och den gör ett bättre jobb med att avsluta flera kontexthanterare när en av dem ger upphov till ett undantag:

    med open('mylog.txt') som infile, open('a.out', 'w') som outfile:
        för rad i infile:
            if '<critical>' i rad:
                outfile.write(rad)
    

    (Bidrag från Georg Brandl och Mattias Brändström; appspot issue 53094.)

  • struct.pack() tillåter nu endast byte för s strängpaketkoden. Tidigare accepterade den textargument och kodade dem implicit till byte med UTF-8. Detta var problematiskt eftersom det gjorde antaganden om den korrekta kodningen och eftersom en kodning med variabel längd kan misslyckas när man skriver till ett segment med fast längd i en struktur.

    Kod som struct.pack('<6sHHBBB', 'GIF87a', x, y) bör skrivas om för att använda bytes istället för text, struct.pack('<6sHHBBB', b'GIF87a', x, y).

    (Upptäckt av David Beazley och åtgärdad av Victor Stinner; bpo-10783.)

  • Klassen xml.etree.ElementTree ger nu upphov till ett xml.etree.ElementTree.ParseError när en parsning misslyckas. Tidigare gav den upphov till ett xml.parsers.expat.ExpatError.

  • Det nya, längre str()-värdet på floats kan bryta doctests som förlitar sig på det gamla utdataformatet.

  • I subprocess.Popen är standardvärdet för close_fds nu True under Unix; under Windows är det True om de tre standardströmmarna är inställda på None, annars False. Tidigare var close_fds alltid False som standard, vilket gjorde det svårt att lösa buggar eller tävlingsförhållanden när öppna filbeskrivare skulle läcka in i barnprocessen.

  • Stöd för äldre HTTP 0.9 har tagits bort från urllib.request och http.client. Sådant stöd finns fortfarande på serversidan (i http.server).

    (Bidrag från Antoine Pitrou, bpo-10711.)

  • SSL-uttag i timeout-läge ger nu upphov till socket.timeout när en timeout inträffar, i stället för ett generiskt SSLError.

    (Bidrag från Antoine Pitrou, bpo-10272.)

  • De vilseledande funktionerna PyEval_AcquireLock() och PyEval_ReleaseLock() har officiellt utgått. De trådstatusmedvetna API:erna (t.ex. PyEval_SaveThread() och PyEval_RestoreThread()) bör användas istället.

  • På grund av säkerhetsrisker har asyncore.handle_accept() utgått och en ny funktion, asyncore.handle_accepted(), har lagts till för att ersätta den.

    (Bidrag från Giampaolo Rodola i bpo-6706.)

  • På grund av den nya GIL-implementationen kan PyEval_InitThreads() inte längre anropas före Py_Initialize().