Vad är nytt i Python 2.6

Författare:

A.M. Kuchling (amk at amk.ca)

Den här artikeln förklarar de nya funktionerna i Python 2.6, som släpptes den 1 oktober 2008. Utgivningsschemat beskrivs i PEP 361.

Huvudtemat i Python 2.6 är att förbereda migreringsvägen till Python 3.0, en stor omdesign av språket. När det är möjligt införlivar Python 2.6 nya funktioner och syntax från 3.0 samtidigt som den förblir kompatibel med befintlig kod genom att inte ta bort äldre funktioner eller syntax. När det inte är möjligt att göra det försöker Python 2.6 göra vad det kan, genom att lägga till kompatibilitetsfunktioner i en future_builtins-modul och en -3-switch för att varna för användningar som inte längre stöds i 3.0.

Några viktiga nya paket har lagts till i standardbiblioteket, till exempel modulerna multiprocessing och json, men det finns inte många nya funktioner som inte är relaterade till Python 3.0 på något sätt.

Python 2.6 innehåller också ett antal förbättringar och buggfixar i hela källan. En sökning genom ändringsloggarna visar att det fanns 259 korrigeringar som tillämpades och 612 buggar fixade mellan Python 2.5 och 2.6. Båda siffrorna är sannolikt underskattningar.

Den här artikeln försöker inte ge en fullständig specifikation av de nya funktionerna, utan ger istället en praktisk översikt. För fullständiga detaljer bör du hänvisa till dokumentationen för Python 2.6. Om du vill förstå bakgrunden till utformningen och implementeringen bör du läsa PEP:n för en viss ny funktion. När det är möjligt länkar ”What’s New in Python” till buggen/patch-objektet för varje ändring.

Python 3.0

Utvecklingscykeln för Python-versionerna 2.6 och 3.0 var synkroniserad, och alfa- och beta-versionerna för båda versionerna släpptes samma dagar. Utvecklingen av 3.0 har påverkat många funktioner i 2.6.

Python 3.0 är en omfattande omarbetning av Python som bryter kompatibiliteten med 2.x-serien. Detta innebär att befintlig Python-kod kommer att behöva en viss konvertering för att kunna köras på Python 3.0. Men inte alla förändringar i 3.0 bryter nödvändigtvis kompatibiliteten. I de fall där nya funktioner inte kommer att orsaka att befintlig kod bryts, har de backporterats till 2.6 och beskrivs i detta dokument på lämplig plats. Några av de 3.0-härledda funktionerna är:

• En __complex__()-metod för att konvertera objekt till ett komplext tal.

• Alternativ syntax för att fånga upp undantag: except TypeError as exc.

• Tillägget av functools.reduce() som en synonym till den inbyggda funktionen reduce().

Python 3.0 lägger till flera nya inbyggda funktioner och ändrar semantiken för vissa befintliga builtins. Funktioner som är nya i 3.0 som bin() har helt enkelt lagts till i Python 2.6, men befintliga inbyggda funktioner har inte ändrats; istället har modulen future_builtins versioner med den nya 3.0-semantiken. Kod skriven för att vara kompatibel med 3.0 kan göra from future_builtins import hex, map vid behov.

En ny kommandoradsväxel, -3, aktiverar varningar om funktioner som kommer att tas bort i Python 3.0. Du kan köra kod med denna switch för att se hur mycket arbete som kommer att krävas för att porta kod till 3.0. Värdet på denna switch är tillgänglig för Python-kod som den booleska variabeln sys.py3kwarning, och för C-tilläggskod som Py_Py3kWarningFlag.

Se även

3xxx-serien av PEPs, som innehåller förslag för Python 3.0. PEP 3000 beskriver utvecklingsprocessen för Python 3.0. Börja med PEP 3100 som beskriver de allmänna målen för Python 3.0, och utforska sedan de högre numrerade PEP:erna som föreslår specifika funktioner.

Förändringar i utvecklingsprocessen

Medan 2.6 utvecklades genomgick Pythons utvecklingsprocess två betydande förändringar: vi bytte från SourceForges issue tracker till en anpassad Roundup-installation och dokumentationen konverterades från LaTeX till reStructuredText.

Spårare av nya nummer: Sammanställning

Python-utvecklarna hade under en längre tid blivit alltmer irriterade på SourceForges buggtracker. SourceForges värdbaserade lösning tillåter inte mycket anpassning; till exempel var det inte möjligt att anpassa livscykeln för frågor.

Infrastrukturkommittén i Python Software Foundation publicerade därför en efterlysning av problemspårare och bad frivilliga att sätta upp olika produkter och importera några av buggarna och korrigeringarna från SourceForge. Fyra olika trackers undersöktes: Jira, Launchpad, Roundup och Trac. Kommittén enades till slut om Jira och Roundup som de två kandidaterna. Jira är en kommersiell produkt som erbjuder kostnadsfria hostade instanser till projekt med fri programvara; Roundup är ett projekt med öppen källkod som kräver frivilliga för att administrera det och en server för att hosta det.

Efter att ha publicerat ett upprop för frivilliga, sattes en ny Roundup-installation upp på https://bugs.python.org. En installation av Roundup kan vara värd för flera spårare, och denna server är nu också värd för problemspårare för Jython och för Python-webbplatsen. Den kommer säkert att hitta andra användningsområden i framtiden. Där det är möjligt länkar denna utgåva av ”What’s New in Python” till buggen/patchen för varje ändring.

Värd för Python-buggspåraren är tillhandahållen av Upfront Systems i Stellenbosch, Sydafrika. Martin von Löwis har lagt ner mycket arbete på att importera befintliga buggar och korrigeringar från SourceForge; hans skript för denna import finns på https://svn.python.org/view/tracker/importer/ och kan vara användbara för andra projekt som vill flytta från SourceForge till Roundup.

Se även

https://bugs.python.org

Pythons buggspårare.

https://bugs.jython.org:

Buggspåraren för Jython.

https://roundup.sourceforge.io/

Nedladdningar och dokumentation av Roundup.

https://svn.python.org/view/tracker/importer/

Martin von Löwis konverteringsskript.

Nytt dokumentationsformat: reStructuredText med hjälp av Sphinx

Python-dokumentationen skrevs med hjälp av LaTeX sedan projektet startade omkring 1989. Under 1980-talet och början av 1990-talet skrevs den mesta dokumentationen ut för senare studier och visades inte online. LaTeX användes i stor utsträckning eftersom det gav attraktiva utskrifter samtidigt som det var enkelt att skriva när man väl lärt sig de grundläggande reglerna för markeringen.

Idag används LaTeX fortfarande för att skriva publikationer som ska tryckas, men landskapet för programmeringsverktyg har förändrats. Vi skriver inte längre ut mängder av dokumentation, utan bläddrar igenom den online och HTML har blivit det viktigaste formatet att stödja. Tyvärr är det ganska komplicerat att konvertera LaTeX till HTML och Fred L. Drake Jr, Pythons mångårige dokumentationsredaktör, ägnade mycket tid åt att underhålla konverteringsprocessen. Ibland föreslog folk att dokumentationen skulle konverteras till SGML och senare XML, men att göra en bra konvertering är en stor uppgift och ingen avsatte någonsin den tid som krävdes för att slutföra jobbet.

Under utvecklingscykeln för 2.6 lade Georg Brandl ner mycket arbete på att bygga en ny verktygskedja för bearbetning av dokumentationen. Det resulterande paketet kallas Sphinx och finns tillgängligt från https://www.sphinx-doc.org/.

Sphinx koncentrerar sig på HTML-utdata och producerar attraktivt utformad och modern HTML; tryckt utdata stöds fortfarande genom konvertering till LaTeX. Inmatningsformatet är reStructuredText, en markeringssyntax som stöder anpassade tillägg och direktiv och som ofta används i Python-gemenskapen.

Sphinx är ett fristående paket som kan användas för att skriva, och nästan två dussin andra projekt (listade på Sphinx webbplats) har antagit Sphinx som sitt dokumentationsverktyg.

Se även

Dokumentation av Python

Beskriver hur man skriver för Pythons dokumentation.

Sphinx

Dokumentation och kod för verktygskedjan Sphinx.

Docutils

Den underliggande reStructuredText-parsern och verktygssatsen.

PEP 343: Uttalandet ”med

Den tidigare versionen, Python 2.5, lade till ’with’-uttalandet som en valfri funktion, som skulle aktiveras med ett from __future__ import with_statement-direktiv. I 2.6 behöver uttalandet inte längre aktiveras särskilt; detta innebär att with nu alltid är ett nyckelord. Resten av detta avsnitt är en kopia av motsvarande avsnitt från dokumentet ”What’s New in Python 2.5”; om du är bekant med ’with’-uttalandet från Python 2.5 kan du hoppa över detta avsnitt.

Satsen ’with’ förtydligar kod som tidigare skulle använda try...finally-block för att säkerställa att uppstädningskoden körs. I det här avsnittet diskuterar jag uttalandet som det vanligtvis kommer att användas. I nästa avsnitt undersöker jag implementeringsdetaljerna och visar hur man skriver objekt som kan användas med den här satsen.

Satsen ’with’ är en kontrollflödesstruktur vars grundstruktur är:

med uttryck [som variabel]:
    med-blockera

Uttrycket utvärderas och bör resultera i ett objekt som stöder protokollet för kontexthantering (dvs. har metoderna __enter__() och __exit__()).

Objektets __enter__() anropas innan with-block exekveras och kan därför köra installationskod. Den kan också returnera ett värde som är bundet till namnet variable, om det anges. (Observera noga att variable inte tilldelas resultatet av expression)

Efter att with-blocket har exekverats anropas objektets metod __exit__(), även om blocket gav upphov till ett undantag, och kan därför köra uppstädningskod.

Vissa standard Python-objekt har nu stöd för kontexthanteringsprotokollet och kan användas med ’with’. Filobjekt är ett exempel:

med open('/etc/passwd', 'r') som f:
    för rad i f:
        skriv ut rad
        ... mer bearbetningskod ...

Efter att denna sats har exekverats kommer filobjektet i f att ha stängts automatiskt, även om for -loopen gjorde ett undantag halvvägs genom blocket.

Anteckning

I det här fallet är f samma objekt som skapades av open(), eftersom __enter__() returnerar self.

Modulen threading:s lås och villkorvariabler stöder också ’with’-satsen:

lock = threading.Lock()
med lock:
    # Kritisk del av koden
    ...

Låset förvärvas innan blocket exekveras och släpps alltid när blocket är klart.

Funktionen localcontext() i modulen decimal gör det enkelt att spara och återställa den aktuella decimalkontexten, som innehåller önskad precision och avrundningsegenskaper för beräkningar:

från decimal importera Decimal, Context, localcontext

# Visar med standardprecision på 28 siffror
v = Decimal('578')
print v.sqrt()

med localcontext(Context(prec=16)):
    # All kod i detta block använder en precision på 16 siffror.
    # Den ursprungliga kontexten återställs när blocket avslutas.
    skriv ut v.sqrt()

Skriva för kontextansvariga

Under huven är ’with’-satsen ganska komplicerad. De flesta människor kommer bara att använda ’with’ i samband med befintliga objekt och behöver inte känna till dessa detaljer, så du kan hoppa över resten av det här avsnittet om du vill. Författare till nya objekt kommer att behöva förstå detaljerna i den underliggande implementationen och bör fortsätta läsa.

En förklaring på hög nivå av protokollet för kontexthantering är:

• Uttrycket utvärderas och bör resultera i ett objekt som kallas ”context manager”. Kontexthanteraren måste ha metoderna __enter__() och __exit__().

• Kontexthanterarens metod __enter__() anropas. Det värde som returneras tilldelas VAR. Om ingen as VAR-klausul finns, kasseras värdet helt enkelt.

• Koden i BLOCK utförs.

• Om BLOCK ger upphov till ett undantag anropas kontexthanterarens metod __exit__() med tre argument, undantagsdetaljerna (typ, värde, traceback, samma värden som returneras av sys.exc_info(), som också kan vara None om inget undantag inträffade). Metodens returvärde kontrollerar om ett undantag ska tas upp igen: alla falska värden tar upp undantaget igen, och True resulterar i att det undertrycks. Du kommer bara sällan att vilja undertrycka undantaget, för om du gör det kommer författaren till koden som innehåller ’with’-uttalandet aldrig att inse att något gick fel.

• Om BLOCK inte gav upphov till ett undantag anropas fortfarande metoden __exit__(), men type, value och traceback är alla None.

Låt oss tänka igenom ett exempel. Jag kommer inte att presentera detaljerad kod utan bara skissa på de metoder som krävs för en databas som stöder transaktioner.

(För den som inte är bekant med databasterminologi: en uppsättning ändringar i databasen grupperas i en transaktion. Transaktioner kan antingen bekräftas, vilket innebär att alla ändringar skrivs in i databasen, eller rullas tillbaka, vilket innebär att alla ändringar tas bort och att databasen är oförändrad. Se en databasbok för mer information)

Låt oss anta att det finns ett objekt som representerar en databasanslutning. Vårt mål kommer att vara att låta användaren skriva kod som denna:

db_connection = Databasanslutning()
med db_connection som cursor:
    cursor.execute('insert into ...')
    cursor.execute('ta bort från ...')
    # ... fler operationer ...

Transaktionen bör genomföras om koden i blocket körs felfritt eller rullas tillbaka om det finns ett undantag. Här är det grundläggande gränssnittet för DatabaseConnection som jag kommer att anta:

klass DatabaseConnection:
    # Databasgränssnitt
    def cursor(self):
        "Returnerar ett cursor-objekt och startar en ny transaktion"
    def commit(self):
        "Commitar aktuell transaktion"
    def rollback(self):
        "Rullar tillbaka aktuell transaktion"

Metoden __enter__() är ganska enkel, det räcker med att starta en ny transaktion. För den här applikationen skulle det resulterande markörobjektet vara ett användbart resultat, så metoden returnerar det. Användaren kan sedan lägga till as cursor i sin ’with’-sats för att binda markören till ett variabelnamn.

klass DatabaseConnection:
    ...
    def __enter__(self):
        # Kod för att starta en ny transaktion
        cursor = self.cursor()
        returnera cursor

Metoden __exit__() är den mest komplicerade eftersom det är där det mesta av arbetet måste göras. Metoden måste kontrollera om ett undantag inträffade. Om det inte inträffade något undantag genomförs transaktionen. Transaktionen rullas tillbaka om det inträffade ett undantag.

I koden nedan kommer exekveringen bara att falla av i slutet av funktionen och returnera standardvärdet None. None är falskt, så undantaget kommer att återkallas automatiskt. Om du vill kan du vara mer explicit och lägga till en return-sats på den markerade platsen.

klass DatabaseConnection:
    ...
    def __exit__(self, type, value, tb):
        om tb är None:
            # Inget undantag, så commit
            self.commit()
        else:
            # Undantag inträffade, så rollback.
            self.rollback()
            # return False

Modulen contextlib

Modulen contextlib innehåller några funktioner och en dekorator som är användbara när du skriver objekt som ska användas med ’with’.

Dekoratorn heter contextmanager() och gör att du kan skriva en enda generatorfunktion istället för att definiera en ny klass. Generatorn ska ge exakt ett värde. Koden fram till yield kommer att exekveras som __enter__()-metoden, och det värde som genereras kommer att vara metodens returvärde som kommer att bindas till variabeln i ’with’-satsens as-klausul, om någon. Koden efter yield kommer att exekveras i metoden __exit__(). Alla undantag som uppstår i blocket kommer att uppstå i yield-satsen.

Med hjälp av denna dekorator kan vårt databasexempel från föregående avsnitt skrivas som:

från contextlib import contextmanager

@kontexthanterare
def db_transaction(anslutning):
    cursor = anslutning.cursor()
    försök:
        avkastning cursor
    except:
        connection.rollback()
        höja
    else:
        anslutning.commit()

db = Databasanslutning()
med db_transaction(db) som cursor:
    ...

Modulen contextlib har också en funktion nested(mgr1, mgr2, ...) som kombinerar ett antal kontexthanterare så att du inte behöver skriva nästlade ’with’-satser. I det här exemplet startar en enda ’with’-sats både en databastransaktion och förvärvar ett trådlås:

lock = threading.Lock()
med nested (db_transaction(db), lock) som (cursor, locked):
    ...

Slutligen returnerar funktionen closing() sitt argument så att det kan bindas till en variabel, och anropar argumentets metod .close() i slutet av blocket.

import urllib, sys
from contextlib import closing

with closing(urllib.urlopen('http://www.yahoo.com')) as f:
    for line in f:
        sys.stdout.write(line)

Se även

PEP 343 - Uttalandet ”med”

PEP skriven av Guido van Rossum och Nick Coghlan; implementerad av Mike Bland, Guido van Rossum och Neal Norwitz. PEP:n visar koden som genereras för en ’with’-sats, vilket kan vara till hjälp för att lära sig hur satsen fungerar.

Dokumentationen för modulen contextlib.

PEP 366: Explicit relativistisk import från en huvudmodul

Pythons -m gör det möjligt att köra en modul som ett skript. När du körde en modul som låg i ett paket fungerade inte relativ import korrekt.

Fixen för Python 2.6 lägger till ett module.__package__-attribut. När detta attribut är närvarande kommer relativ import att vara relativ till värdet på detta attribut istället för attributet __name__.

PEP 302-stil importörer kan sedan ställa in __package__ vid behov. Modulen runpy som implementerar bytet -m gör nu detta, så relativ import kommer nu att fungera korrekt i skript som körs inifrån ett paket.

PEP 370: site-packages-katalog per användare

När du kör Python innehåller sökvägen för modulen sys.path vanligtvis en katalog vars sökväg slutar på "site-packages". Den här katalogen är avsedd att innehålla lokalt installerade paket som är tillgängliga för alla användare som använder en maskin eller en viss webbplatsinstallation.

Python 2.6 introducerar en konvention för användarspecifika webbplatskataloger. Katalogen varierar beroende på plattform:

• Unix och Mac OS X: ~/.local/

• Windows: %APPDATA%/Python

I den här katalogen finns det versionsspecifika underkataloger, t.ex. lib/python2.6/site-packages på Unix/Mac OS och Python26/site-packages på Windows.

Om du inte gillar standardkatalogen kan den åsidosättas med en miljövariabel. PYTHONUSERBASE anger den rotkatalog som används för alla Python-versioner som stöder denna funktion. I Windows kan katalogen för applikationsspecifika data ändras genom att ställa in miljövariabeln APPDATA. Du kan också ändra filen site.py för din Python-installation.

Funktionen kan avaktiveras helt genom att köra Python med alternativet -s eller genom att ställa in miljövariabeln PYTHONNOUSERSITE.

Se även

PEP 370 - Katalog för site-paket per användare

PEP skrivet och implementerat av Christian Heimes.

PEP 371: Paketet ”Multiprocessing

Det nya multiprocessing-paketet låter Python-program skapa nya processer som utför en beräkning och returnerar ett resultat till föräldern. Föräldra- och barnprocesserna kan kommunicera med hjälp av köer och pipes, synkronisera sina operationer med hjälp av lås och semaforer och kan dela enkla matriser med data.

Modulen multiprocessing började som en exakt emulering av modulen threading som använder processer istället för trådar. Det målet förkastades på vägen till Python 2.6, men det allmänna tillvägagångssättet för modulen är fortfarande liknande. Den grundläggande klassen är Process, som får ett anropsbart objekt och en samling argument. Metoden start() sätter igång det anropbara objektet i en subprocess, varefter du kan anropa metoden is_alive() för att kontrollera om subprocessen fortfarande körs och metoden join() för att vänta på att processen ska avslutas.

Här är ett enkelt exempel där subprocessen ska beräkna en faktoriell. Funktionen som gör beräkningen är konstigt skriven så att den tar betydligt längre tid när indata är en multipel av 4.

import time
from multiprocessing import Process, Queue


def factorial(queue, N):
    "Compute a factorial."
    # If N is a multiple of 4, this function will take much longer.
    if (N % 4) == 0:
        time.sleep(.05 * N/4)

    # Calculate the result
    fact = 1L
    for i in range(1, N+1):
        fact = fact * i

    # Put the result on the queue
    queue.put(fact)

if __name__ == '__main__':
    queue = Queue()

    N = 5

    p = Process(target=factorial, args=(queue, N))
    p.start()
    p.join()

    result = queue.get()
    print 'Factorial', N, '=', result

En Queue används för att kommunicera resultatet av faktorialtalet. Objektet Queue lagras i en global variabel. Barnprocessen kommer att använda variabelns värde när barnet skapades; eftersom det är en Queue kan förälder och barn använda objektet för att kommunicera. (Om föräldern skulle ändra värdet på den globala variabeln skulle barnets värde inte påverkas, och vice versa)

Två andra klasser, Pool och Manager, tillhandahåller gränssnitt på högre nivå. Pool skapar ett fast antal arbetsprocesser, och förfrågningar kan sedan distribueras till arbetsprocesserna genom att anropa apply() eller apply_async() för att lägga till en enda förfrågan, och map() eller map_async() för att lägga till ett antal förfrågningar. Följande kod använder en Pool för att sprida ut förfrågningar över 5 arbetsprocesser och hämta en lista med resultat:

från multiprocessing import Pool

def faktoriell(N, ordbok):
    "Beräkna en faktoriell."
    ...
p = Pool(5)
resultat = p.map(faktoriell, intervall(1, 1000, 10))
för v i resultat:
    print v

Detta ger följande utdata:

1
39916800
51090942171709440000
8222838654177922817725562880000000
33452526613163807108170062053440751665152000000000
...

Det andra högnivågränssnittet, klassen Manager, skapar en separat serverprocess som kan hålla masterkopior av Python-datastrukturer. Andra processer kan sedan komma åt och modifiera dessa datastrukturer med hjälp av proxyobjekt. Följande exempel skapar en delad ordbok genom att anropa metoden dict(); arbetsprocesserna infogar sedan värden i ordboken. (Låsning görs inte automatiskt, vilket inte spelar någon roll i det här exemplet. Manager:s metoder inkluderar även Lock(), RLock() och Semaphore() för att skapa delade lås)

import time
from multiprocessing import Pool, Manager

def factorial(N, dictionary):
    "Compute a factorial."
    # Calculate the result
    fact = 1L
    for i in range(1, N+1):
        fact = fact * i

    # Store result in dictionary
    dictionary[N] = fact

if __name__ == '__main__':
    p = Pool(5)
    mgr = Manager()
    d = mgr.dict()         # Create shared dictionary

    # Run tasks using the pool
    for N in range(1, 1000, 10):
        p.apply_async(factorial, (N, d))

    # Mark pool as closed -- no more tasks can be added.
    p.close()

    # Wait for tasks to exit
    p.join()

    # Output results
    for k, v in sorted(d.items()):
        print k, v

Detta kommer att ge utdata:

1 1
11 39916800
21 51090942171709440000
31 8222838654177922817725562880000000
41 33452526613163807108170062053440751665152000000000
51 15511187532873822802242430164693032110632597200169861120000...

Se även

Dokumentationen för modulen multiprocessing.

PEP 371 - Tillägg av multiprocessing-paketet

PEP skriven av Jesse Noller och Richard Oudkerk; implementerad av Richard Oudkerk och Jesse Noller.

PEP 3101: Avancerad strängformatering

I Python 3.0 kompletteras operatorn % med en mer kraftfull strängformateringsmetod, format(). Stöd för metoden str.format() har backporterats till Python 2.6.

I 2.6 har både 8-bitars och Unicode-strängar en .format()-metod som behandlar strängen som en mall och tar argumenten som ska formateras. Formateringsmallen använder hakparenteser ({, }) som specialtecken:

>>> # Substitute positional argument 0 into the string.
>>> "User ID: {0}".format("root")
'User ID: root'
>>> # Use the named keyword arguments
>>> "User ID: {uid}   Last seen: {last_login}".format(
...    uid="root",
...    last_login = "5 Mar 2008 07:20")
'User ID: root   Last seen: 5 Mar 2008 07:20'

Lockiga parenteser kan undkommas genom att dubblera dem:

>>> "Empty dict: {{}}".format()
"Empty dict: {}"

Fältnamn kan vara heltal som anger positionella argument, t.ex. {0}, {1} etc. eller namn på nyckelordsargument. Du kan också ange sammansatta fältnamn som läser attribut eller ger tillgång till nycklar i en ordbok:

>>> import sys
>>> print 'Platform: {0.platform}\nPython version: {0.version}'.format(sys)
Platform: darwin
Python version: 2.6a1+ (trunk:61261M, Mar  5 2008, 20:29:41)
[GCC 4.0.1 (Apple Computer, Inc. build 5367)]'

>>> import mimetypes
>>> 'Content-type: {0[.mp4]}'.format(mimetypes.types_map)
'Content-type: video/mp4'

Observera att när du använder ordboksliknande notation som [.mp4] behöver du inte sätta några citattecken runt strängen; den kommer att leta upp värdet med .mp4 som nyckel. Strängar som börjar med ett tal konverteras till ett heltal. Du kan inte skriva mer komplicerade uttryck inuti en formatsträng.

Hittills har vi visat hur man anger vilket fält som ska ersättas i den resulterande strängen. Den exakta formatering som används kan också kontrolleras genom att lägga till ett kolon följt av en formatspecifikator. Till exempel:

>>> # Field 0: left justify, pad to 15 characters
>>> # Field 1: right justify, pad to 6 characters
>>> fmt = '{0:15} ${1:>6}'
>>> fmt.format('Registration', 35)
'Registration    $    35'
>>> fmt.format('Tutorial', 50)
'Tutorial        $    50'
>>> fmt.format('Banquet', 125)
'Banquet         $   125'

Formatangivelser kan referera till andra fält genom nesting:

>>> fmt = '{0:{1}}'
>>> width = 15
>>> fmt.format('Invoice #1234', width)
'Invoice #1234  '
>>> width = 35
>>> fmt.format('Invoice #1234', width)
'Invoice #1234                      '

Inriktningen av ett fält inom den önskade bredden kan specificeras:

Tecken	Effekt
< (standard)	Vänsterjusterad
>	Högerjusterad
^	Centrera
=	(Endast för numeriska typer) Fyll i efter tecknet.

Formatspecifikationer kan också innehålla en presentationstyp, som styr hur värdet formateras. Flyttal kan t.ex. formateras som ett allmänt tal eller i exponentiell notation:

>>> '{0:g}'.format(3.75)
'3.75'
>>> '{0:e}'.format(3.75)
'3.750000e+00'

En mängd olika presentationstyper finns tillgängliga. Se dokumentationen för 2.6 för en fullständig lista; här är ett exempel:

b	Binär. Utmatning av talet i bas 2.
c	Tecken. Konverterar heltalet till motsvarande Unicode-tecken före utskrift.
d	Decimalt heltal. Utmatning av talet i bas 10.
o	Oktalformat. Utmatning av talet i bas 8.
x	Hex-format. Utmatar talet i bas 16, med små bokstäver för siffrorna över 9.
e	Exponentnotation. Skriver ut talet i vetenskaplig notation med bokstaven ”e” för att ange exponenten.
g	Allmänt format. Detta skriver ut talet som ett fastpunktstal, såvida inte talet är för stort, i vilket fall det växlar till ”e”-exponentnotation.
n	Siffra. Detta är samma sak som ’g’ (för flyttal) eller ’d’ (för heltal), förutom att den använder den aktuella lokalinställningen för att infoga lämpligt antal separatortecken.
%	Procent. Multiplicerar talet med 100 och visas i fast (’f’) format, följt av ett procenttecken.

Klasser och typer kan definiera en __format__()-metod för att styra hur de formateras. Den tar emot ett enda argument, formatspecificeraren:

def __format__(self, format_spec):
    if isinstance(format_spec, unicode):
        return unicode(str(self))
    annat:
        returnera str(self)

Det finns också en inbyggd format() som formaterar ett enskilt värde. Den anropar typens __format__()-metod med den angivna specifikatorn:

>>> format(75.6564, '.2f')
'75.66'

Se även

Format String Syntax

Referensdokumentation för formatfält.

PEP 3101 - Avancerad strängformatering

PEP skriven av Talin. Implementerad av Eric Smith.

PEP 3105: print som funktion

Satsen print blir funktionen print() i Python 3.0. Att göra print() till en funktion gör det möjligt att ersätta funktionen genom att göra def print(...) eller importera en ny funktion från någon annanstans.

Python 2.6 har en __future__ import som tar bort print som språksyntax, så att du kan använda den funktionella formen istället. Till exempel:

>>> from __future__ import print_function
>>> print('# of entries', len(dictionary), file=sys.stderr)

Signaturen för den nya funktionen är:

def print(*args, sep=' ', end='\n', file=None)

Parametrarna är:

• args: positionella argument vars värden kommer att skrivas ut.

• sep: separatorn, som skrivs ut mellan argumenten.

• end: sluttexten, som skrivs ut efter att alla argument har matats ut.

• file: det filobjekt som utdata ska skickas till.

Se även

PEP 3105 - Gör print till en funktion

PEP skriven av Georg Brandl.

PEP 3110: Ändringar i undantagshantering

Ett fel som Python-programmerare ibland gör är att skriva följande kod:

försök:
    ...
except TypeError, ValueError:  # Fel!
    ...

Författaren försöker förmodligen fånga både TypeError- och ValueError-undantagen, men den här koden gör faktiskt något annat: den fångar TypeError och binder det resulterande undantagsobjektet till det lokala namnet "ValueError". Undantaget ValueError kommer inte att fångas alls. Den korrekta koden specificerar en tupel av undantag:

försök:
    ...
except (TypFel, VärdeFel):
    ...

Det här felet uppstår eftersom användningen av kommatecken här är tvetydig: anger det två olika noder i parseträdet eller en enda nod som är en tupel?

Python 3.0 gör detta otvetydigt genom att ersätta kommatecknet med ordet ”som”. För att fånga ett undantag och lagra undantagsobjektet i variabeln exc måste du skriva:

försök:
    ...
except TypeError as exc:
    ...

Python 3.0 stöder endast användningen av ”as”, och tolkar därför det första exemplet som att två olika undantag fångas upp. Python 2.6 stöder både kommatecken och ”as”, så befintlig kod kommer att fortsätta att fungera. Vi föreslår därför att du använder ”as” när du skriver ny Python-kod som bara kommer att köras med 2.6.

Se även

PEP 3110 - Att fånga upp undantag i Python 3000

PEP skrivet och genomfört av Collin Winter.

PEP 3112: Bytebokstäver

Python 3.0 antar Unicode som språkets grundläggande strängtyp och betecknar 8-bitars literaler på olika sätt, antingen som b'string' eller med hjälp av en bytes-konstruktor. För framtida kompatibilitet lägger Python 2.6 till bytes som en synonym för typen str och stöder även notationen b''.

Typen 2.6 str skiljer sig från 3.0:s bytes på flera sätt; framför allt är konstruktören helt annorlunda. I 3.0 är bytes([65, 66, 67]) 3 element lång och innehåller de byte som representerar ABC; i 2.6 returnerar bytes([65, 66, 67]) den 12-byte långa sträng som representerar listans str().

Den primära användningen av bytes i 2.6 kommer att vara att skriva tester av objekttyp som isinstance(x, bytes). Detta kommer att hjälpa 2to3-omvandlaren, som inte kan avgöra om 2.x-koden avser att strängar ska innehålla antingen tecken eller 8-bitars bytes; du kan nu använda antingen bytes eller str för att representera din avsikt exakt, och den resulterande koden kommer också att vara korrekt i Python 3.0.

Det finns också en import __future__ som gör att alla strängkonstanta blir Unicode-strängar. Detta innebär att escape-sekvenser \u kan användas för att inkludera Unicode-tecken:

from __future__ import unicode_literals

s = ('\u751f\u3080\u304e\u3000\u751f\u3054'
     '\u3081\u3000\u751f\u305f\u307e\u3054')

print len(s)               # 12 Unicode characters

På C-nivå kommer Python 3.0 att byta namn på den befintliga 8-bitars strängtypen, kallad PyStringObject i Python 2.x, till PyBytesObject. Python 2.6 använder #define för att stödja användning av namnen PyBytesObject(), PyBytes_Check(), PyBytes_FromStringAndSize(), och alla andra funktioner och makron som används med strängar.

Instanser av typen bytes är oföränderliga precis som strängar är. En ny typ av bytearray lagrar en föränderlig sekvens av bytes:

>>> bytearray([65, 66, 67])
bytearray(b'ABC')
>>> b = bytearray(u'\u21ef\u3244', 'utf-8')
>>> b
bytearray(b'\xe2\x87\xaf\xe3\x89\x84')
>>> b[0] = '\xe3'
>>> b
bytearray(b'\xe3\x87\xaf\xe3\x89\x84')
>>> unicode(str(b), 'utf-8')
u'\u31ef \u3244'

Bytearrayer stöder de flesta av metoderna för strängtyper, t.ex. startswith()/endswith(), find()/rfind(), och några av metoderna för listor, t.ex. append(), pop() och reverse().

>>> b = bytearray('ABC')
>>> b.append('d')
>>> b.append(ord('e'))
>>> b
bytearray(b'ABCde')

Det finns också ett motsvarande C API, med PyByteArray_FromObject(), PyByteArray_FromStringAndSize(), och diverse andra funktioner.

Se även

PEP 3112 - Byteslitteraler i Python 3000

PEP skriven av Jason Orendorff; bakåtporterad till 2.6 av Christian Heimes.

PEP 3116: Nytt I/O-bibliotek

Pythons inbyggda filobjekt har stöd för ett antal metoder, men filliknande objekt har inte nödvändigtvis stöd för alla. Objekt som imiterar filer stöder vanligtvis read() och write(), men de kanske inte stöder readline(), till exempel. Python 3.0 introducerar ett skiktat I/O-bibliotek i modulen io som separerar buffrings- och texthanteringsfunktioner från de grundläggande läs- och skrivoperationerna.

Det finns tre nivåer av abstrakta basklasser som tillhandahålls av modulen io:

• RawIOBase definierar råa I/O-operationer: read(), readinto(), write(), seek(), tell(), truncate() och close(). De flesta metoderna i denna klass kommer ofta att motsvara ett enda systemanrop. Det finns också metoderna readable(), writable() och seekable() för att avgöra vilka operationer ett visst objekt tillåter.

  Python 3.0 har konkreta implementeringar av den här klassen för filer och sockets, men Python 2.6 har inte omstrukturerat sina fil- och socketobjekt på det här sättet.

• BufferedIOBase är en abstrakt basklass som buffrar data i minnet för att minska antalet systemanrop som används, vilket gör I/O-bearbetning mer effektiv. Den stöder alla metoder i RawIOBase och lägger till ett raw-attribut som innehåller det underliggande råobjektet.

  Det finns fem konkreta klasser som implementerar denna ABC. BufferedWriter och BufferedReader är för objekt som stöder skrivskyddad eller skrivskyddad användning som har en seek()-metod för slumpmässig åtkomst. BufferedRandom-objekt stöder läs- och skrivåtkomst på samma underliggande ström, och BufferedRWPair är för objekt som TTYs som har både läs- och skrivoperationer som verkar på oanslutna dataströmmar. Klassen BytesIO stöder läsning, skrivning och sökning över en buffert i minnet.

• TextIOBase: Innehåller funktioner för att läsa och skriva strängar (kom ihåg att strängar kommer att vara Unicode i Python 3.0), och stödjer universal newlines. TextIOBase definierar metoden readline() och stödjer iteration på objekt.

  Det finns två konkreta implementeringar. TextIOWrapper omsluter ett buffrat I/O-objekt, stöder alla metoder för text-I/O och lägger till ett buffer-attribut för åtkomst till det underliggande objektet. StringIO buffrar helt enkelt allt i minnet utan att någonsin skriva något till disk.

  (I Python 2.6 är io.StringIO implementerad i ren Python, så den är ganska långsam. Du bör därför hålla dig till den befintliga StringIO-modulen eller cStringIO för tillfället. Vid någon tidpunkt kommer Python 3.0:s io-modul att skrivas om till C för att bli snabbare, och kanske kommer C-implementeringen att backporteras till 2.x-utgåvorna)

I Python 2.6 har de underliggande implementationerna inte omstrukturerats för att bygga vidare på io-modulens klasser. Modulen tillhandahålls för att göra det enklare att skriva kod som är framåtkompatibel med 3.0 och för att bespara utvecklare ansträngningen att skriva sina egna implementationer av buffring och text-I/O.

Se även

PEP 3116 - Ny I/O

PEP skrivet av Daniel Stutzbach, Mike Verdone och Guido van Rossum. Kod av Guido van Rossum, Georg Brandl, Walter Doerwald, Jeremy Hylton, Martin von Löwis, Tony Lownds och andra.

PEP 3118: Reviderat buffertprotokoll

Buffertprotokollet är ett API på C-nivå som låter Python-typer utbyta pekare till sina interna representationer. En minnesmappad fil kan till exempel ses som en buffert med tecken, och detta gör att en annan modul som re kan behandla minnesmappade filer som en sträng med tecken som ska sökas.

De primära användarna av buffertprotokollet är numeriska bearbetningspaket som NumPy, som exponerar den interna representationen av matriser så att anropare kan skriva data direkt till en matris istället för att gå igenom ett långsammare API. Denna PEP uppdaterar buffertprotokollet mot bakgrund av erfarenheterna från NumPy-utvecklingen och lägger till ett antal nya funktioner som att ange formen på en array eller låsa en minnesregion.

Den viktigaste nya C API-funktionen är PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags), som tar ett objekt och en uppsättning flaggor och fyller i Py_buffer-strukturen med information om objektets minnesrepresentation. Objekt kan använda denna operation för att låsa minnet på plats medan en extern anropare kan ändra innehållet, så det finns en motsvarande PyBuffer_Release(Py_buffer *view) för att indikera att den externa anroparen är klar.

Argumentet flags till PyObject_GetBuffer() anger begränsningar för det minne som returneras. Några exempel är:

• PyBUF_WRITABLE anger att minnet måste vara skrivbart.

• PyBUF_LOCK begär ett skrivskyddat eller exklusivt lås på minnet.

• PyBUF_C_CONTIGUOUS och PyBUF_F_CONTIGUOUS begär en C-sluten (sista dimensionen varierar snabbast) eller Fortran-sluten (första dimensionen varierar snabbast) array-layout.

Två nya argumentkoder för PyArg_ParseTuple(), s* och z*, returnerar låsta buffertobjekt för en parameter.

Se även

PEP 3118 - Revidering av buffertprotokollet

PEP skriven av Travis Oliphant och Carl Banks; implementerad av Travis Oliphant.

PEP 3119: Abstrakta basklasser

Vissa objektorienterade språk som Java stöder gränssnitt, som deklarerar att en klass har en viss uppsättning metoder eller stöder ett visst åtkomstprotokoll. Abstract Base Classes (eller ABC) är en motsvarande funktion för Python. ABC-stödet består av en abc-modul som innehåller en metaklass som heter ABCMeta, specialhantering av denna metaklass av isinstance() och issubclass() builtins, och en samling grundläggande ABC som Python-utvecklarna tror kommer att vara allmänt användbara. Framtida versioner av Python kommer förmodligen att lägga till fler ABC.

Låt oss säga att du har en viss klass och vill veta om den stöder åtkomst i ordboksstil. Uttrycket ”dictionary-style” är dock vagt. Det betyder förmodligen att åtkomst till objekt med obj[1] fungerar. Innebär det att det fungerar att ställa in objekt med obj[2] = value? Eller att objektet kommer att ha metoderna keys(), values() och items()? Hur är det med de iterativa varianterna som iterkeys()? copy() och update()? Iteration över objektet med iter()?

Python 2.6 collections-modulen innehåller ett antal olika ABC som representerar dessa distinktioner. Iterable indikerar att en klass definierar __iter__(), och Container betyder att klassen definierar en __contains__()-metod och därför stöder x i y-uttryck. Det grundläggande ordboksgränssnittet för att hämta objekt, ställa in objekt och keys(), values() och items() definieras av MutableMapping ABC.

Du kan härleda dina egna klasser från en viss ABC för att ange att de stöder den ABC:s gränssnitt:

import collections

class Storage(collections.MutableMapping):
    ...

Alternativt kan man skriva klassen utan att härleda från önskad ABC och istället registrera klassen genom att anropa ABC:s register()-metod:

import collections

class Storage:
    ...

collections.MutableMapping.register(Storage)

För klasser som du skriver är det förmodligen tydligare att härleda från ABC. Metoden register() är användbar när du har skrivit en ny ABC som kan beskriva en befintlig typ eller klass, eller om du vill deklarera att en klass från tredje part implementerar en ABC. Om du till exempel har definierat en PrintableType ABC, är det lagligt att göra:

# Registrera Pythons typer
PrintableType.register(int)
PrintableType.register(float)
PrintableType.register(str)

Klasser bör följa den semantik som anges av en ABC, men Python kan inte kontrollera detta; det är upp till klassens författare att förstå ABC:s krav och att implementera koden i enlighet därmed.

För att kontrollera om ett objekt stöder ett visst gränssnitt kan du nu skriva:

def func(d):
    if not isinstance(d, collections.MutableMapping):
        raise ValueError("Mapping-objekt förväntat, inte %r" % d)

Känn inte att du nu måste börja skriva massor av kontroller som i exemplet ovan. Python har en stark tradition av duck-typing, där explicit typkontroll aldrig görs och koden helt enkelt anropar metoder på ett objekt, litar på att dessa metoder kommer att finnas där och gör ett undantag om de inte gör det. Var försiktig med att kontrollera ABC och gör det bara där det är absolut nödvändigt.

Du kan skriva din egen ABC genom att använda abc.ABCMeta som metaklass i en klassdefinition:

from abc import ABCMeta, abstractmethod

class Drawable():
    __metaclass__ = ABCMeta

    @abstractmethod
    def draw(self, x, y, scale=1.0):
        pass

    def draw_doubled(self, x, y):
        self.draw(x, y, scale=2.0)


class Square(Drawable):
    def draw(self, x, y, scale):
        ...

I Drawable ABC ovan renderar draw_doubled() metoden objektet i dubbel storlek och kan implementeras i termer av andra metoder som beskrivs i Drawable. Klasser som implementerar denna ABC behöver därför inte tillhandahålla sin egen implementation av draw_doubled(), även om de kan göra det. En implementation av draw() är dock nödvändig; ABC kan inte tillhandahålla en användbar generisk implementation.

Du kan använda dekoratorn @abstractmethod på metoder som draw() som måste implementeras; Python kommer då att göra ett undantag för klasser som inte definierar metoden. Observera att undantaget bara uppstår när du faktiskt försöker skapa en instans av en underklass som saknar metoden:

>>> class Circle(Drawable):
...     pass
...
>>> c = Circle()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Circle with abstract methods draw
>>>

Abstrakta dataattribut kan deklareras med hjälp av dekoratorn @abstractproperty:

från abc import abstractproperty
...

@abstraktegenskap
def readonly(self):
   returnera self._x

Subklasser måste sedan definiera en readonly()-egenskap.

Se även

PEP 3119 - Introduktion av abstrakta basklasser

PEP skriven av Guido van Rossum och Talin. Implementerad av Guido van Rossum. Backporterad till 2.6 av Benjamin Aranguren, med Alex Martelli.

PEP 3127: Stöd för heltalsbokstäver och syntax

Python 3.0 ändrar syntaxen för oktala (bas-8) heltalslitteraler, som prefixas med ”0o” eller ”0O” istället för en ledande nolla, och lägger till stöd för binära (bas-2) heltalslitteraler, som signaleras med prefixet ”0b” eller ”0B”.

Python 2.6 släpper inte stödet för ett ledande 0 som signalerar ett oktalt tal, men det lägger till stöd för ”0o” och ”0b”:

>>> 0o21, 2*8 + 1
(17, 17)
>>> 0b101111
47

Inbyggnadsrutinen oct() returnerar fortfarande tal med en inledande nolla och den nya inbyggnadsrutinen bin() returnerar den binära representationen för ett tal:

>>> oct(42)
'052'
>>> future_builtins.oct(42)
'0o52'
>>> bin(173)
'0b10101101'

Inbyggnaderna int() och long() accepterar nu prefixen ”0o” och ”0b” när bas-8 eller bas-2 begärs, eller när argumentet base är noll (vilket signalerar att den bas som används ska bestämmas från strängen):

>>> int ('0o52', 0)
42
>>> int('1101', 2)
13
>>> int('0b1101', 2)
13
>>> int('0b1101', 0)
13

Se även

PEP 3127 - Stöd för heltalsbokstäver och syntax

PEP skriven av Patrick Maupin; bakåtporterad till 2.6 av Eric Smith.

PEP 3129: Klassdekoratörer

Decorators har utökats från funktioner till klasser. Det är nu lagligt att skriva:

@foo
@bar
klass A:
  pass

Detta är likvärdigt med:

klass A:
  pass

A = foo(bar(A))

Se även

PEP 3129 - Klassdekoratorer

PEP skriven av Collin Winter.

PEP 3141: En typhierarki för siffror

Python 3.0 lägger till flera abstrakta basklasser för numeriska typer inspirerade av Scheme’s numeriska torn. Dessa klasser bakåtporterades till 2.6 som modulen numbers.

Den mest generella ABC:en är Number. Den definierar inga operationer alls och existerar bara för att man ska kunna kontrollera om ett objekt är ett tal genom att göra isinstance(obj, Number).

Complex är en underklass till Number. Komplexa tal kan genomgå de grundläggande operationerna addition, subtraktion, multiplikation, division och exponentiering, och du kan hämta de reella och imaginära delarna och få ett tals konjugat. Pythons inbyggda komplexa typ är en implementation av Complex.

Real härstammar vidare från Complex och lägger till operationer som bara fungerar på reella tal: floor(), trunc(), avrundning, ta resten mod N, division med golv och jämförelser.

Rational numbers härstammar från Real, har egenskaperna numerator och denominator och kan konverteras till floats. Python 2.6 lägger till en enkel klass för rationella tal, Fraction, i modulen fractions. (Den kallas Fraction istället för Rational för att undvika en namnkrock med numbers.Rational)

Integral numbers härstammar från Rational, och kan flyttas åt vänster och höger med << och >>, kombineras med bitvisa operationer som & och |, och kan användas som array-index och slice-gränser.

I Python 3.0 omdefinierar PEP något de befintliga builtins round(), math.floor(), math.ceil(), och lägger till en ny, math.trunc(), som har backporterats till Python 2.6. math.trunc() rundar mot noll och returnerar den närmaste Integral som ligger mellan funktionens argument och noll.

Se även

PEP 3141 - En typhierarki för siffror

PEP skriven av Jeffrey Yasskin.

Schemets numeriska torn, från Guile-manualen.

Schemes datatyper för tal från R5RS Scheme-specifikationen.

Modulen fractions

För att fylla ut hierarkin av numeriska typer tillhandahåller modulen fractions en klass för rationella tal. Rationella tal lagrar sina värden som en täljare och nämnare som bildar ett bråk, och kan exakt representera tal som 2/3 som flyttal bara kan approximera.

Konstruktören Fraction tar två Integral-värden som blir täljare och nämnare i den resulterande fraktionen.

>>> from fractions import Fraction
>>> a = Fraction(2, 3)
>>> b = Fraction(2, 5)
>>> float(a), float(b)
(0.66666666666666663, 0.40000000000000002)
>>> a+b
Fraction(16, 15)
>>> a/b
Fraction(5, 3)

För konvertering av flyttal till rationella tal har float-typen nu en metod as_integer_ratio() som returnerar täljaren och nämnaren för ett bråk som utvärderas till samma flyttalsvärde:

>>> (2.5) .as_integer_ratio()
(5, 2)
>>> (3.1415) .as_integer_ratio()
(7074029114692207L, 2251799813685248L)
>>> (1./3) .as_integer_ratio()
(6004799503160661L, 18014398509481984L)

Observera att värden som bara kan approximeras med flyttal, t.ex. 1./3, inte förenklas till det tal som approximeras; bråket försöker matcha flyttalsvärdet exakt.

Modulen fractions är baserad på en implementation av Sjoerd Mullender som länge fanns i Pythons Demo/classes/-katalog. Denna implementation har uppdaterats avsevärt av Jeffrey Yasskin.

Andra språkliga förändringar

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

• Kataloger och zip-arkiv som innehåller en __main__.py-fil kan nu exekveras direkt genom att deras namn anges till tolken. Katalogen eller zip-arkivet infogas automatiskt som den första posten i sys.path. (Förslag och inledande patch av Andy Chu, därefter reviderad av Phillip J. Eby och Nick Coghlan; bpo-1739468.)

• Funktionen hasattr() fångade upp och ignorerade alla fel, under antagandet att de betydde att en __getattr__()-metod misslyckades på något sätt och att returvärdet för hasattr() därför skulle vara False. Denna logik bör dock inte tillämpas på KeyboardInterrupt och SystemExit; Python 2.6 kommer inte längre att kassera sådana undantag när hasattr() stöter på dem. (Rättad av Benjamin Peterson; bpo-2196.)

• När du anropar en funktion som använder **-syntaxen för att ange nyckelordsargument behöver du inte längre använda en Python-ordbok; vilken mappning som helst fungerar nu:

  >>> def f(**kw):
  ...    print sorted(kw)
  ...
  >>> ud=UserDict.UserDict()
  >>> ud['a'] = 1
  >>> ud['b'] = 'string'
  >>> f(**ud)
  ['a', 'b']
  

  (Bidrag från Alexander Belopolsky; bpo-1686487.)

  Det har också blivit lagligt att ange nyckelordsargument efter ett *args-argument i ett funktionsanrop:

  >>> def f(*args, **kw):
  ...     print args, kw
  ...
  >>> f(1,2,3, *(4,5,6), keyword=13)
  (1, 2, 3, 4, 5, 6) {'keyword': 13}
  

  Tidigare skulle detta ha varit ett syntaxfel. (Bidrag från Amaury Forgeot d’Arc; bpo-3473.)

• En ny inbyggd funktion, next(iterator, [default]) returnerar nästa objekt från den angivna iteratorn. Om argumentet default anges, kommer det att returneras om iterator har uttömts; annars kommer StopIteration undantaget att uppstå. (Återinförd i bpo-2719.)

• Tuples har nu metoderna index() och count() som matchar listtypens metoder index() och count():

  >>> t = (0,1,2,3,4,0,1,2)
  >>> t.index(3)
  3
  >>> t.count(0)
  2
  

  (Bidrag från Raymond Hettinger)

• De inbyggda typerna har nu förbättrat stöd för utökad slicing-syntax och accepterar olika kombinationer av (start, stop, step). Tidigare var stödet partiellt och vissa hörnfall fungerade inte. (Implementerat av Thomas Wouters.)

• Egenskaper har nu tre attribut, getter, setter och deleter, som är dekoratorer som ger användbara genvägar för att lägga till en getter-, setter- eller deleter-funktion till en befintlig egenskap. Du kan använda dem så här:

  klass C(objekt):
      @egenskap
      def x(self):
          return self._x
  
      @x.inställare
      def x(self, värde):
          self._x = värde
  
      @x.borttagare
      def x(self):
          del self._x
  
  klass D(C):
      @C.x.getter
      def x(self):
          returnerar self._x * 2
  
      @x.inställare
      def x(self, värde):
          self._x = värde / 2
  

• Flera metoder för de inbyggda set-typerna accepterar nu flera iterabler: intersection(), intersection_update(), union(), update(), difference() och difference_update().

  >>> s=set('1234567890')
  >>> s.intersection('abc123', 'cdf246')  # Intersection between all inputs
  set(['2'])
  >>> s.difference('246', '789')
  set(['1', '0', '3', '5'])
  

  (Bidrag från Raymond Hettinger.)

• Många funktioner för flyttal har lagts till. Funktionen float() förvandlar nu strängen nan till ett IEEE 754 Not A Number-värde, och +inf och -inf till positiv eller negativ oändlighet. Detta fungerar på alla plattformar med IEEE 754-semantik. (Bidrag från Christian Heimes; bpo-1635.)

  Andra funktioner i modulen math, isinf() och isnan(), returnerar true om deras flyttalsargument är oändligt eller Not A Number. (bpo-1640)

  Konverteringsfunktioner har lagts till för att konvertera flyttal till hexadecimala strängar (bpo-3008). Dessa funktioner konverterar flyttal till och från en strängrepresentation utan att införa avrundningsfel från konverteringen mellan decimal och binär. Floats har en hex()-metod som returnerar en strängrepresentation, och metoden float.fromhex() konverterar en sträng tillbaka till ett tal:

  >>> a = 3.75
  >>> a.hex()
  '0x1.e000000000000p+1'
  >>> float.fromhex('0x1.e000000000000p+1')
  3.75
  >>> b=1./3
  >>> b.hex()
  '0x1.5555555555555p-2'
  

• En numerisk finess: när man skapar ett komplext tal från två flyttal på system som stöder signerade nollor (-0 och +0), kommer complex()-konstruktören nu att bevara tecknet på nollan. (Rättad av Mark T. Dickinson; bpo-1507.)

• Klasser som ärver en __hash__()-metod från en överordnad klass kan sätta __hash__ = None för att ange att klassen inte är hashbar. Detta kommer att göra att hash(obj) ger upphov till ett TypeError och klassen kommer inte att anges som implementerande av Hashable ABC.

  Du bör göra detta när du har definierat en __cmp__()- eller __eq__()-metod som jämför objekt med deras värde snarare än med identitet. Alla objekt har en standardhashmetod som använder id(obj) som hashvärde. Det finns inget snyggt sätt att ta bort __hash__()-metoden som ärvts från en överordnad klass, så att tilldela None implementerades som en åsidosättning. På C-nivå kan tillägg ställa in tp_hash till PyObject_HashNotImplemented(). (Rättad av Nick Coghlan och Amaury Forgeot d’Arc; bpo-2235.)

• Undantaget GeneratorExit subklassar nu BaseException istället för Exception. Detta innebär att en undantagshanterare som gör except Exception: inte oavsiktligt kommer att fånga GeneratorExit. (Bidrag från Chad Austin; bpo-1537.)

• Generatorobjekt har nu ett gi_code-attribut som hänvisar till det ursprungliga kodobjektet som backar upp generatorn. (Bidrag från Collin Winter; bpo-1473257.)

• Den inbyggda funktionen compile() accepterar nu nyckelordsargument såväl som positionella parametrar. (Bidrag från Thomas Wouters; bpo-1444529.)

• Konstruktorn complex() accepterar nu strängar som innehåller komplexa tal inom parentes, vilket innebär att complex(repr(cplx)) nu avrundar värden. Till exempel, complex('(3+4j)') returnerar nu värdet (3+4j). (bpo-1491866)

• Metoden string translate() accepterar nu None som parameter för översättningstabellen, som behandlas som en identitetstransformation. Detta gör det enklare att utföra operationer som bara tar bort tecken. (Bidrag från Bengt Richter och implementerat av Raymond Hettinger; bpo-1193128.)

• Den inbyggda funktionen dir() kontrollerar nu om det finns en metod __dir__() i de objekt som den tar emot. Denna metod måste returnera en lista med strängar som innehåller namnen på giltiga attribut för objektet, och låter objektet styra det värde som dir() producerar. Objekt som har __getattr__() eller __getattribute__() metoder kan använda detta för att annonsera pseudoattribut som de kommer att respektera. (bpo-1591665)

• Instansmetodobjekt har nya attribut för det objekt och den funktion som utgör metoden; den nya synonymen för im_self är __self__, och im_func finns också som __func__. De gamla namnen stöds fortfarande i Python 2.6, men är borta i 3.0.

• En obskyr förändring: när du använder funktionen locals() i en class-sats returnerar den resulterande ordlistan inte längre fria variabler. (Fria variabler är i det här fallet variabler som refereras till i class-satsen och som inte är attribut till klassen)

Optimeringar

• Modulen warnings har skrivits om till C. Detta gör det möjligt att anropa varningar från parsern, och kan också göra tolkens uppstart snabbare. (Bidrag från Neal Norwitz och Brett Cannon; bpo-1631171.)

• Typobjekt har nu en cache av metoder som kan minska det arbete som krävs för att hitta rätt metodimplementering för en viss klass; när den väl är cachad behöver tolken inte korsa basklasser för att ta reda på rätt metod att anropa. Cachen rensas om en basklass eller klassen i sig ändras, så cachen bör förbli korrekt även med tanke på Pythons dynamiska natur. (Originaloptimering implementerad av Armin Rigo, uppdaterad för Python 2.6 av Kevin Jacobs; bpo-1700288.)

  Som standard tillämpas denna ändring endast på typer som ingår i Python-kärnan. Tilläggsmoduler är inte nödvändigtvis kompatibla med denna cache, så de måste uttryckligen lägga till Py_TPFLAGS_HAVE_VERSION_TAG i modulens tp_flags-fält för att aktivera metodcachen. (För att vara kompatibel med metodcachen får tilläggsmodulens kod inte direkt komma åt och modifiera tp_dict-medlemmen i någon av de typer som den implementerar. De flesta moduler gör inte detta, men det är omöjligt för Python-tolken att avgöra det. Se bpo-1878 för en diskussion)

• Funktionsanrop som använder nyckelordsargument är betydligt snabbare genom att göra en snabb pekarjämförelse, vilket vanligtvis sparar tid jämfört med en fullständig strängjämförelse. (Bidrag från Raymond Hettinger, efter en första implementering av Antoine Pitrou; bpo-1819.)

• Alla funktioner i modulen struct har skrivits om till C, tack vare arbetet med Need For Speed-sprinten. (Bidrag från Raymond Hettinger.)

• Vissa av de inbyggda standardtyperna anger nu en bit i sina typobjekt. Detta påskyndar kontrollen av om ett objekt är en underklass av en av dessa typer. (Bidrag från Neal Norwitz.)

• Unicode-strängar använder nu snabbare kod för att upptäcka blanksteg och radbrytningar; detta snabbar upp split()-metoden med cirka 25% aoch splitlines() med 35%. (Bidrag från Antoine Pitrou.) Minnesanvändningen minskas genom att pymalloc används för Unicode-strängens data.

• with-satsen lagrar nu __exit__()-metoden på stacken, vilket ger en liten hastighetsökning. (Implementerat av Jeffrey Yasskin.)

• För att minska minnesanvändningen rensar skräpsamlaren nu interna lediga listor när den högsta generationen av objekt samlas in. Detta kan göra att minnet återlämnas till operativsystemet tidigare.

Förändringar av tolk

Två kommandoradsalternativ har reserverats för användning av andra Python-implementationer. Växeln -J har reserverats för användning av Jython för Jython-specifika alternativ, till exempel växlar som skickas till den underliggande JVM:n. -X har reserverats för alternativ som är specifika för en viss implementering av Python, till exempel CPython, Jython eller IronPython. Om något av alternativen används med Python 2.6 kommer tolken att rapportera att alternativet inte används för närvarande.

Python kan nu förhindras från att skriva .pyc eller .pyo-filer genom att ange -B till Python-tolken, eller genom att ställa in miljövariabeln PYTHONDONTONTWRITEBYTECODE innan tolken körs. Denna inställning är tillgänglig för Python-program som variabeln sys.dont_write_bytecode, och Python-kod kan ändra värdet för att modifiera tolkens beteende. (Bidrag från Neal Norwitz och Georg Brandl.)

Kodningen som används för standardinmatning, -utmatning och standardfel kan specificeras genom att ställa in miljövariabeln PYTHONIOENCODING innan tolken körs. Värdet bör vara en sträng i formen <encoding> eller <encoding>:<errorhandler>. Delen encoding anger kodningens namn, t.ex. utf-8 eller latin-1; den valfria delen errorhandler anger vad som ska göras med tecken som inte kan hanteras av kodningen, och bör vara en av ”error”, ”ignore” eller ”replace”. (Bidrag från Martin von Löwis.)

Nya och förbättrade moduler

Som i varje release fick Pythons standardbibliotek ett antal förbättringar och buggfixar. Här är en partiell lista över de mest anmärkningsvärda ändringarna, sorterade alfabetiskt efter modulnamn. Se filen Misc/NEWS i källträdet för en mer komplett lista över ändringar, eller titta igenom Subversion-loggarna för alla detaljer.

• Modulerna asyncore och asynchat underhålls aktivt igen, och ett antal korrigeringar och buggfixar har införts. (Underhålls av Josiah Carlson; se bpo-1736190 för en patch)

• Modulen bsddb har också fått en ny underhållare, Jesús Cea Avión, och paketet finns nu tillgängligt som ett fristående paket. Webbsidan för paketet är www.jcea.es/programacion/pybsddb.htm. Planen är att ta bort paketet från standardbiblioteket i Python 3.0, eftersom Python 3.0 har en mycket tätare utgivningstakt än Python.

  Modulen bsddb.dbshelve använder nu det högsta tillgängliga betningsprotokollet, istället för att begränsa sig till protokoll 1. (Bidrag från W. Barnes.)

• Modulen cgi kan nu läsa variabler från frågesträngen i en HTTP POST-begäran. Detta gör det möjligt att använda formuläråtgärder med webbadresser som innehåller frågesträngar som ”/cgi-bin/add.py?category=1”. (Bidrag från Alexandre Fiori och Nubis; bpo-1817.)

  Funktionerna parse_qs() och parse_qsl() har flyttats från modulen cgi till modulen urlparse. De versioner som fortfarande finns tillgängliga i cgi-modulen kommer att utlösa PendingDeprecationWarning-meddelanden i 2.6 (bpo-600362).

• Modulen cmath har genomgått en omfattande revidering, med bidrag från Mark Dickinson och Christian Heimes. Fem nya funktioner har lagts till:

  • polar() konverterar ett komplext tal till polarform och returnerar modulus och argument för det komplexa talet.

  • rect() gör tvärtom och förvandlar ett modulus-argumentpar tillbaka till motsvarande komplexa tal.

  • phase() returnerar argumentet (även kallat vinkeln) för ett komplext tal.

  • isnan() returnerar True om antingen den verkliga eller den imaginära delen av argumentet är ett NaN.

  • isinf() returnerar True om antingen den reella eller imaginära delen av dess argument är oändlig.

  Revideringarna har också förbättrat den numeriska tillförlitligheten hos modulen cmath. För alla funktioner är de reella och imaginära delarna av resultaten korrekta inom några få enheter av minsta precision (ulps) när så är möjligt. Se bpo-1381 för detaljer. Grenavsnitten för asinh(), atanh(): och atan() har också korrigerats.

  Testerna för modulen har utökats kraftigt; nästan 2000 nya testfall tränar de algebraiska funktionerna.

  På IEEE 754-plattformar hanterar modulen cmath nu IEEE 754-specialvärden och undantag för flyttal på ett sätt som överensstämmer med Annex ’G’ i C99-standarden.

• En ny datatyp i modulen collections: namedtuple(typename, fieldnames) är en fabriksfunktion som skapar underklasser av standardtupeln vars fält är tillgängliga via namn såväl som index. Till exempel:

  >>> var_type = collections.namedtuple('variable',
  ...             'id name type size')
  >>> # Names are separated by spaces or commas.
  >>> # 'id, name, type, size' would also work.
  >>> var_type._fields
  ('id', 'name', 'type', 'size')
  
  >>> var = var_type(1, 'frequency', 'int', 4)
  >>> print var[0], var.id    # Equivalent
  1 1
  >>> print var[2], var.type  # Equivalent
  int int
  >>> var._asdict()
  {'size': 4, 'type': 'int', 'id': 1, 'name': 'frequency'}
  >>> v2 = var._replace(name='amplitude')
  >>> v2
  variable(id=1, name='amplitude', type='int', size=4)
  

  Flera ställen i standardbiblioteket som returnerade tuplar har ändrats till att returnera namedtuple()-instanser. Till exempel returnerar metoden Decimal.as_tuple() nu en namngiven tupel med fälten sign, digits och exponent.

  (Bidrag från Raymond Hettinger.)

• En annan förändring i modulen collections är att typen deque nu har stöd för en valfri parameter maxlen; om den anges kommer deques storlek att begränsas till högst maxlen objekt. Om du lägger till fler objekt i en full deque kommer gamla objekt att kasseras.

  >>> from collections import deque
  >>> dq=deque(maxlen=3)
  >>> dq
  deque([], maxlen=3)
  >>> dq.append(1); dq.append(2); dq.append(3)
  >>> dq
  deque([1, 2, 3], maxlen=3)
  >>> dq.append(4)
  >>> dq
  deque([2, 3, 4], maxlen=3)
  

  (Bidrag från Raymond Hettinger.)

• Modulen Cookie Morsel-objekt har nu stöd för attributet httponly. I vissa webbläsare kan cookies med detta attribut inte nås eller manipuleras av JavaScript-kod. (Bidrag från Arvin Schnell; bpo-1638033.)

• En ny fönstermetod i modulen curses, chgat(), ändrar visningsattributen för ett visst antal tecken på en rad. (Bidrag från Fabian Kreutz.)

  # Text i fetstil som börjar vid y=0,x=21
  # och påverkar resten av raden.
  stdscr.chgat(0, 21, curses.A_BOLD)
  

  Klassen Textbox i modulen curses.textpad stöder nu redigering i både infogningsläge och överskrivningsläge. Insert-läget aktiveras genom att ange ett true-värde för parametern insert_mode när Textbox-instansen skapas.

• datetime-modulens strftime()-metoder stöder nu en %f-formatkod som expanderar till antalet mikrosekunder i objektet, nolladderad till vänster till sex platser. (Bidrag från Skip Montanaro; bpo-1158.)

• Modulen decimal uppdaterades till version 1.66 av the General Decimal Specification. Nya funktioner inkluderar några metoder för några grundläggande matematiska funktioner som exp() och log10():

  >>> Decimal(1).exp()
  Decimal("2.718281828459045235360287471")
  >>> Decimal("2.7182818").ln()
  Decimal("0.9999999895305022877376682436")
  >>> Decimal(1000).log10()
  Decimal("3")
  

  Metoden as_tuple() för Decimal-objekt returnerar nu en namngiven tuple med fälten sign, digits och exponent.

  (Implementerad av Facundo Batista och Mark Dickinson. Stöd för namngivna tuplar tillagt av Raymond Hettinger.)

• Klassen SequenceMatcher i modulen difflib returnerar nu namngivna tuples som representerar matchningar, med attributen a, b och size. (Bidrag från Raymond Hettinger.)

• En valfri parameter timeout, som anger en timeout mätt i sekunder, har lagts till i ftplib.FTP-klassens konstruktor samt i metoden connect(). (Tillagt av Facundo Batista.) Dessutom tar FTP-klassens storbinary() och storlines() nu en valfri callback-parameter som kommer att anropas med varje datablock efter att data har skickats. (Bidrag från Phil Schwartz; bpo-1221598.)

• Den inbyggda funktionen reduce() finns också i modulen functools. I Python 3.0 har den inbyggda funktionen tagits bort och reduce() är endast tillgänglig från functools; för närvarande finns det inga planer på att ta bort den inbyggda funktionen i 2.x-serien. (Patchad av Christian Heimes; bpo-1739906.)

• När det är möjligt kommer modulen getpass nu att använda /dev/tty för att skriva ut ett promptmeddelande och läsa lösenordet, med återkoppling till standardfel och standardinmatning. Om lösenordet kan ekas till terminalen skrivs en varning ut innan prompten visas. (Bidrag från Gregory P. Smith.)

• Funktionen glob.glob() kan nu returnera Unicode-filnamn om en Unicode-sökväg användes och Unicode-filnamn matchas inom katalogen. (bpo-1001604)

• En ny funktion i modulen heapq, merge(iter1, iter2, ...), tar ett valfritt antal iteratorer som returnerar data i sorterad ordning och returnerar en ny generator som returnerar innehållet i alla iteratorer, också i sorterad ordning. Till exempel:

  >>> list(heapq.merge([1, 3, 5, 9], [2, 8, 16]))
  [1, 2, 3, 5, 8, 9, 16]
  

  En annan ny funktion, heappushpop(heap, item), skjuter item till heap, sedan popar den upp och returnerar det minsta objektet. Detta är mer effektivt än att göra ett anrop till heappush() och sedan heappop().

  heapq är nu implementerad för att endast använda mindre-än jämförelse, istället för mindre-än-eller-lika jämförelse som den tidigare använde. Detta gör att heapq användning av en typ matchar metoden list.sort(). (Bidrag från Raymond Hettinger.)

• En valfri parameter timeout, som anger en timeout mätt i sekunder, lades till i klasskonstruktörerna httplib.HTTPConnection och HTTPSConnection. (Tillagd av Facundo Batista.)

• De flesta av inspect-modulens funktioner, till exempel getmoduleinfo() och getargs(), returnerar nu namngivna tupler. Förutom att de beter sig som tupler kan elementen i returvärdet också nås som attribut. (Bidrag från Raymond Hettinger.)

  Några nya funktioner i modulen är isgenerator(), isgeneratorfunction() och isabstract().

• Modulen itertools har fått flera nya funktioner.

  izip_longest(iter1, iter2, ...[, fillvalue]) skapar tupler av varje element; om några av iterablerna är kortare än andra sätts de saknade värdena till fillvalue. Till exempel:

  >>> tuple(itertools.izip_longest([1,2,3], [1,2,3,4,5]))
  ((1, 1), (2, 2), (3, 3), (None, 4), (None, 5))
  

  product(iter1, iter2, ..., [repeat=N]) returnerar den kartesiska produkten av de angivna iterablerna, en uppsättning tuples som innehåller alla möjliga kombinationer av de element som returneras från varje iterabel.

  >>> list(itertools.product([1,2,3], [4,5,6]))
  [(1, 4), (1, 5), (1, 6),
   (2, 4), (2, 5), (2, 6),
   (3, 4), (3, 5), (3, 6)]
  

  Det valfria nyckelordsargumentet repeat används för att ta produkten av en iterabel eller en uppsättning iterabler med sig själva, upprepade N gånger. Med ett enda iterabelargument returneras N-tuples:

  >>> list(itertools.product([1,2], repeat=3))
  [(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2),
   (2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]
  

  Med två iterabler returneras 2N-tuples.

  >>> list(itertools.product([1,2], [3,4], repeat=2))
  [(1, 3, 1, 3), (1, 3, 1, 4), (1, 3, 2, 3), (1, 3, 2, 4),
   (1, 4, 1, 3), (1, 4, 1, 4), (1, 4, 2, 3), (1, 4, 2, 4),
   (2, 3, 1, 3), (2, 3, 1, 4), (2, 3, 2, 3), (2, 3, 2, 4),
   (2, 4, 1, 3), (2, 4, 1, 4), (2, 4, 2, 3), (2, 4, 2, 4)]
  

  combinations(iterable, r) returnerar undersekvenser med längden r från elementen i iterable.

  >>> list(itertools.combinations('123', 2))
  [('1', '2'), ('1', '3'), ('2', '3')]
  >>> list(itertools.combinations('123', 3))
  [('1', '2', '3')]
  >>> list(itertools.combinations('1234', 3))
  [('1', '2', '3'), ('1', '2', '4'),
   ('1', '3', '4'), ('2', '3', '4')]
  

  permutations(iter[, r]) returnerar alla permutationer av längden r av iterabelns element. Om r inte anges, kommer det att vara standardvärdet för antalet element som produceras av iterabeln.

  >>> list(itertools.permutations([1,2,3,4], 2))
  [(1, 2), (1, 3), (1, 4),
   (2, 1), (2, 3), (2, 4),
   (3, 1), (3, 2), (3, 4),
   (4, 1), (4, 2), (4, 3)]
  

  itertools.chain(*iterables) är en befintlig funktion i itertools som fick en ny konstruktör i Python 2.6. itertools.chain.from_iterable(iterable) tar en enda iterable som ska returnera andra iterables. chain() kommer då att returnera alla element i den första iterable, sedan alla element i den andra, och så vidare:

  >>> list(itertools.chain.from_iterable([[1,2,3], [4,5,6]]))
  [1, 2, 3, 4, 5, 6]
  

  (Alla bidrag från Raymond Hettinger.)

• Modulen logging:s klass FileHandler och dess underklasser WatchedFileHandler, RotatingFileHandler och TimedRotatingFileHandler har nu en valfri delay-parameter i sina konstruktörer. Om delay är true, skjuts öppningen av loggfilen upp tills det första emit()-anropet görs. (Bidrag från Vinay Sajip.)

  TimedRotatingFileHandler har också en utc-konstruktorparameter. Om argumentet är sant kommer UTC-tid att användas för att bestämma när midnatt inträffar och för att generera filnamn; annars kommer lokal tid att användas.

• Flera nya funktioner har lagts till i modulen math:

  • isinf() och isnan() avgör om ett givet flyttal är en (positiv eller negativ) oändlighet respektive ett NaN (Not a Number).

  • copysign() kopierar teckenbiten i ett IEEE 754-tal och returnerar det absoluta värdet av x kombinerat med teckenbiten i y. Till exempel, math.copysign(1, -0.0) returnerar -1.0. (Bidrag från Christian Heimes.)

  • factorial() beräknar faktorn av ett tal. (Bidrag från Raymond Hettinger; bpo-2138.)

  • fsum() adderar talflödet från en iterabel och är noga med att undvika precisionsförlust genom att använda partiella summor. (Bidrag från Jean Brouwers, Raymond Hettinger och Mark Dickinson; bpo-2819.)

  • acosh(), asinh() och atanh() beräknar de inversa hyperboliska funktionerna.

  • log1p() returnerar den naturliga logaritmen av 1+x (bas e).

  • trunc() avrundar ett tal mot noll och returnerar den närmaste Integral som ligger mellan funktionens argument och noll. Tillagd som en del av bakporten av PEP 3141:s typhierarki för tal.

• Modulen math har förbättrats för att ge ett mer konsekvent beteende på olika plattformar, särskilt när det gäller hantering av undantag för flyttal och specialvärden enligt IEEE 754.

  När så är möjligt följer modulen rekommendationerna i C99-standarden om 754:s specialvärden. Till exempel bör sqrt(-1.) nu ge ett ValueError på nästan alla plattformar, medan sqrt(float('NaN')) bör returnera ett NaN på alla IEEE 754-plattformar. Där bilaga ’F’ i C99-standarden rekommenderar att signalera ’divide-by-zero’ eller ’invalid’, kommer Python att ge ValueError. Där bilaga ’F’ i C99-standarden rekommenderar att signalera ’overflow’, kommer Python att ge OverflowError. (Se bpo-711019 och bpo-1640.)

  (Bidrag från Christian Heimes och Mark Dickinson.)

• mmap-objekt har nu en rfind()-metod som söker efter en delsträng med början i slutet av strängen och bakåt. Metoden find() har också fått en end-parameter som anger ett index vid vilket sökningen ska avslutas. (Bidrag från John Lenton.)

• Modulen operator fick en methodcaller()-funktion som tar ett namn och en valfri uppsättning argument och returnerar en anropbar funktion som anropar den namngivna funktionen med alla argument som skickas till den. Till exempel:

  >>> # Equivalent to lambda s: s.replace('old', 'new')
  >>> replacer = operator.methodcaller('replace', 'old', 'new')
  >>> replacer('old wine in old bottles')
  'new wine in new bottles'
  

  (Bidrag från Georg Brandl, efter ett förslag från Gregory Petrosyan.)

  Funktionen attrgetter() accepterar nu prickade namn och utför motsvarande attributuppslagningar:

  >>> inst_name = operator.attrgetter(
  ...        '__class__.__name__')
  >>> inst_name('')
  'str'
  >>> inst_name(help)
  '_Helper'
  

  (Bidrag från Georg Brandl, efter ett förslag från Barry Warsaw.)

• Modulen os omsluter nu flera nya systemanrop. fchmod(fd, mode) och fchown(fd, uid, gid) ändrar läge och ägandeskap för en öppnad fil, och lchmod(path, mode) ändrar läget för en symlänk. (Bidrag från Georg Brandl och Christian Heimes.)

  chflags() och lchflags() är omslag för motsvarande systemanrop (där de är tillgängliga), som ändrar flaggvärdena för en fil. Konstanter för flaggvärdena definieras i modulen stat; några möjliga värden inkluderar UF_IMMUTABLE för att signalera att filen inte får ändras och UF_APPEND för att indikera att data endast kan läggas till i filen. (Bidrag från M. Levinson.)

  os.closerange(low, high) stänger effektivt alla filbeskrivare från low till high, ignorerar eventuella fel och inkluderar inte high själv. Den här funktionen används nu av modulen subprocess för att göra det snabbare att starta processer. (Bidrag från Georg Brandl; bpo-1663329.)

• Objektet os.environ:s clear()-metod kommer nu att återställa miljövariablerna med os.unsetenv() förutom att rensa objektets nycklar. (Bidrag från Martin Horcicka; bpo-1181.)

• Funktionen os.walk() har nu en parameter för followlinks. Om den är satt till True kommer den att följa symlinks som pekar på kataloger och besöka katalogens innehåll. För bakåtkompatibilitet är parameterns standardvärde false. Observera att funktionen kan hamna i en oändlig rekursion om det finns en symbollänk som pekar på en överordnad katalog. (bpo-1273829)

• I modulen os.path har funktionen splitext() ändrats så att den inte delar upp inledande punkttecken. Detta ger bättre resultat vid användning av Unix punktfiler. Till exempel returnerar os.path.splitext('.ipython') nu ('.ipython', '') istället för ('', '.ipython'). (bpo-1115886)

  En ny funktion, os.path.relpath(path, start='.'), returnerar en relativ sökväg från start-sökvägen, om den anges, eller från den aktuella arbetskatalogen till målet path. (Bidrag från Richard Barran; bpo-1339796.)

  I Windows kommer os.path.expandvars() nu att expandera miljövariabler som anges i formen ”%var%”, och ”~user” kommer att expanderas till användarens sökväg till hemkatalogen. (Bidrag från Josiah Carlson; bpo-957650.)

• Python-felsökaren som tillhandahålls av modulen pdb har fått ett nytt kommando: ”run” startar om Python-programmet som felsöks och kan eventuellt ta emot nya kommandoradsargument för programmet. (Bidrag från Rocky Bernstein; bpo-1393667.)

• Funktionen pdb.post_mortem(), som används för att påbörja felsökning av en spårning, kommer nu att använda den spårning som returneras av sys.exc_info() om ingen spårning anges. (Bidrag från Facundo Batista; bpo-1106316.)

• Modulen pickletools har nu en optimize()-funktion som tar en sträng som innehåller en pickle och tar bort några oanvända opkoder, vilket returnerar en kortare pickle som innehåller samma datastruktur. (Bidrag från Raymond Hettinger.)

• En get_data()-funktion har lagts till i pkgutil-modulen som returnerar innehållet i resursfiler som ingår i ett installerat Python-paket. Till exempel:

  >>> import pkgutil
  >>> print pkgutil.get_data('test', 'exception_hierarchy.txt')
  BaseException
   +-- SystemExit
   +-- KeyboardInterrupt
   +-- GeneratorExit
   +-- Exception
        +-- StopIteration
        +-- StandardError
   ...
  

  (Bidrag från Paul Moore; bpo-2439.)

• pyexpat-modulens Parser-objekt tillåter nu att man ställer in deras buffer_size-attribut för att ändra storleken på den buffert som används för att hålla teckendata. (Bidrag från Achim Gaedke; bpo-1137.)

• Modulen Queue tillhandahåller nu kövarianter som hämtar poster i olika ordning. Klassen PriorityQueue lagrar köade objekt i en hög och hämtar dem i prioritetsordning, och LifoQueue hämtar de senast tillagda objekten först, vilket innebär att den beter sig som en stack. (Bidrag från Raymond Hettinger.)

• Modulen random:s Random-objekt kan nu picklas på ett 32-bitars system och unpicklas på ett 64-bitars system, och vice versa. Tyvärr innebär denna förändring också att Python 2.6:s Random-objekt inte kan avpicklas korrekt på tidigare versioner av Python. (Bidrag från Shawn Ligocki; bpo-1727780.)

  Den nya funktionen triangular(low, high, mode) returnerar slumpmässiga tal som följer en triangulär fördelning. De returnerade värdena ligger mellan låg och hög, exklusive hög själv, och med mode som det mest frekvent förekommande värdet i fördelningen. (Bidrag från Wladmir van der Laan och Raymond Hettinger; bpo-1681432.)

• Långa sökningar med reguljära uttryck som utförs av modulen re kommer att kontrollera om signaler levereras, så tidskrävande sökningar kan nu avbrytas. (Bidrag från Josh Hoyt och Ralf Schmitt; bpo-846388.)

  Modulen för reguljära uttryck implementeras genom att kompilera bytekoder för en liten regex-specifik virtuell maskin. Otillförlitlig kod kan skapa skadliga strängar av bytecode direkt och orsaka kraschar, så Python 2.6 innehåller en verifierare för regex-bytecode. (Bidrag från Guido van Rossum från arbetet för Google App Engine; bpo-3487.)

• Modulen rlcompleter:s metod Completer.complete() ignorerar nu undantag som utlöses när ett namn utvärderas. (Rättad av Lorenz Quack; bpo-2250.)

• sched-modulens scheduler-instanser har nu ett skrivskyddat queue-attribut som returnerar innehållet i schemaläggarens kö, representerad som en lista av namngivna tuples med fälten (tid, prioritet, åtgärd, argument). (Bidrag från Raymond Hettinger; bpo-1861.)

• Modulen select har nu omslagsfunktioner för systemanropen Linux epoll() och BSD kqueue(). Metoden modify() lades till i de befintliga objekten poll; pollobj.modify(fd, eventmask) tar en filbeskrivning eller ett filobjekt och en händelsemask och ändrar den inspelade händelsemasken för filen. (Bidrag från Christian Heimes; bpo-1657.)

• Funktionen shutil.copytree() har nu ett valfritt ignore-argument som tar ett anropbart objekt. Detta anropsbara objekt tar emot varje katalogsökväg och en lista över katalogens innehåll och returnerar en lista med namn som ignoreras och inte kopieras.

  Modulen shutil innehåller också en funktion ignore_patterns() som kan användas med den här nya parametern. ignore_patterns() tar ett godtyckligt antal glob-mönster och returnerar en anropbar funktion som ignorerar alla filer och kataloger som matchar något av dessa mönster. Följande exempel kopierar ett katalogträd, men hoppar över både .svn-kataloger och Emacs backup-filer, som har namn som slutar med ’~’:

  shutil.copytree('Doc/library', '/tmp/library',
                  ignore=shutil.ignore_patterns('*~', '.svn'))
  

  (Bidrag från Tarek Ziadé; bpo-2663.)

• Att integrera signalhantering med händelseslingor för GUI-hantering som de som används av Tkinter eller GTk+ har länge varit ett problem; de flesta programvaror slutar med polling, att vakna upp varje bråkdel av en sekund för att kontrollera om några GUI-händelser har inträffat. Modulen signal kan nu göra detta mer effektivt. Genom att anropa signal.set_wakeup_fd(fd) anges en filbeskrivare som ska användas; när en signal tas emot skrivs en byte till den filbeskrivaren. Det finns också en funktion på C-nivå, PySignal_SetWakeupFd(), för att ställa in descriptorn.

  Händelseslingor använder detta genom att öppna en pipe för att skapa två deskriptorer, en för läsning och en för skrivning. Den skrivbara deskriptorn skickas till set_wakeup_fd(), och den läsbara deskriptorn läggs till i listan över deskriptorer som övervakas av händelseslingan via select() eller poll(). När en signal tas emot skrivs en byte och huvudhändelseslingan väcks, vilket gör att pollning inte behövs.

  (Bidrag från Adam Olsen; bpo-1583.)

  Funktionen siginterrupt() är nu tillgänglig från Python-kod och gör det möjligt att ändra om signaler kan avbryta systemanrop eller inte. (Bidrag från Ralf Schmitt.)

  Funktionerna setitimer() och getitimer() har också lagts till (där de är tillgängliga). setitimer() gör det möjligt att ställa in intervalltidtagare som gör att en signal levereras till processen efter en angiven tid, mätt i väggklocktid, förbrukad processtid eller kombinerad process+systemtid. (Bidrag från Guilherme Polo; bpo-2240.)

• Modulen smtplib har nu stöd för SMTP över SSL tack vare tillägget av klassen SMTP_SSL. Denna klass stöder ett gränssnitt som är identiskt med den befintliga SMTP-klassen. (Bidrag från Monty Taylor.) Båda klasskonstruktörerna har också en valfri timeout-parameter som anger en timeout för det första anslutningsförsöket, mätt i sekunder. (Bidrag från Facundo Batista.)

  En implementering av LMTP-protokollet (RFC 2033) har också lagts till i modulen. LMTP används i stället för SMTP vid överföring av e-post mellan agenter som inte hanterar en e-postkö. (LMTP implementerat av Leif Hedström; bpo-957003.)

  SMTP.starttls() följer nu RFC 3207 och glömmer all kunskap som erhålls från servern som inte erhålls från själva TLS-förhandlingen. (Patch bidragit av Bill Fenner; bpo-829951.)

• Modulen socket har nu stöd för TIPC (https://tipc.sourceforge.net/), ett högpresterande icke-IP-baserat protokoll som är utformat för användning i klustermiljöer. TIPC-adresser är 4- eller 5-tupler. (Bidrag från Alberto Bertogli; bpo-1646.)

  En ny funktion, create_connection(), tar en adress och ansluter till den med hjälp av ett valfritt timeoutvärde och returnerar det anslutna socketobjektet. Den här funktionen söker också upp adressens typ och ansluter till den med IPv4 eller IPv6 beroende på vad som är lämpligt. Att ändra din kod så att den använder create_connection() istället för socket(socket.AF_INET, ...) kan vara allt som krävs för att få din kod att fungera med IPv6.

• Basklasserna i modulen SocketServer stöder nu anrop av metoden handle_timeout() efter en tid av inaktivitet som anges av serverns attribut timeout. (Bidrag från Michael Pomraning.) Metoden serve_forever() tar nu ett valfritt pollintervall mätt i sekunder, vilket styr hur ofta servern ska kontrollera om det finns en begäran om avstängning. (Bidrag från Pedro Werneck och Jeffrey Yasskin; bpo-742598, bpo-1193577.)

• Modulen sqlite3, som underhålls av Gerhard Häring, har uppdaterats från version 2.3.2 i Python 2.5 till version 2.4.1.

• Modulen struct har nu stöd för C99-typen _Bool, som använder formattecknet '?'. (Bidrag från David Remahl.)

• Objekten Popen som tillhandahålls av modulen subprocess har nu metoderna terminate(), kill() och send_signal(). På Windows stöder send_signal() endast signalen SIGTERM, och alla dessa metoder är alias för Win32 API-funktionen TerminateProcess(). (Bidrag från Christian Heimes.)

• En ny variabel i modulen sys, float_info, är ett objekt som innehåller information från filen float.h om plattformens stöd för flyttal. Attribut för detta objekt inkluderar mant_dig (antal siffror i mantissan), epsilon (minsta skillnaden mellan 1,0 och nästa största representerbara värde), och flera andra. (Bidrag från Christian Heimes; bpo-1534.)

  En annan ny variabel, dont_write_bytecode, styr om Python skriver några .pyc- eller .pyo-filer vid import av en modul. Om variabeln är true skrivs inte de kompilerade filerna. Variabeln ställs in initialt vid start genom att ange -B till Python-tolken, eller genom att ställa in miljövariabeln PYTHONDONTWRITEBYTECODE innan tolken körs. Python-kod kan därefter ändra värdet på denna variabel för att kontrollera om bytecode-filer skrivs eller inte. (Bidrag från Neal Norwitz och Georg Brandl.)

  Information om kommandoradsargumenten som levereras till Python-tolken är tillgänglig genom att läsa attribut för en namngiven tupel som finns tillgänglig som sys.flags. Exempelvis är attributet verbose sant om Python kördes i verbose-läge, debug är sant i debugging-läge, etc. Alla dessa attribut är skrivskyddade. (Bidrag från Christian Heimes.)

  En ny funktion, getsizeof(), tar ett Python-objekt och returnerar den mängd minne som används av objektet, mätt i byte. Inbyggda objekt returnerar korrekta resultat; tredjepartstillägg kanske inte gör det, men kan definiera en __sizeof__()-metod för att returnera objektets storlek. (Bidrag från Robert Schuppenies; bpo-2898.)

  Det är nu möjligt att bestämma de aktuella profilerings- och spårningsfunktionerna genom att anropa sys.getprofile() och sys.gettrace(). (Bidrag från Georg Brandl; bpo-1648.)

• Modulen tarfile stöder nu POSIX.1-2001 (pax)-tarfiler utöver POSIX.1-1988 (ustar)- och GNU tar-formaten som redan tidigare stöddes. Standardformatet är GNU tar; ange parametern format för att öppna en fil med ett annat format:

  tar = tarfile.open("output.tar", "w",
                     format=tarfile.PAX_FORMAT)
  

  De nya parametrarna encoding och errors anger en kodning och ett felhanteringsschema för teckenkonverteringar. 'strict', 'ignore' och 'replace' är de tre standardsätten som Python kan hantera fel på; 'utf-8' är ett specialvärde som ersätter dåliga tecken med deras UTF-8-representation. (Teckenkonvertering sker eftersom PAX-formatet stöder Unicode-filnamn och som standard använder UTF-8-kodning)

  Metoden TarFile.add() accepterar nu ett exclude-argument som är en funktion som kan användas för att utesluta vissa filnamn från ett arkiv. Funktionen måste ta ett filnamn och returnera true om filen ska uteslutas eller false om den ska arkiveras. Funktionen tillämpas både på det namn som ursprungligen skickades till add() och på namnen på filer i rekursivt tillagda kataloger.

  (Alla ändringar har gjorts av Lars Gustäbel).

• En valfri timeout-parameter lades till i telnetlib.Telnet-klassens konstruktör, som anger en timeout mätt i sekunder. (Tillagd av Facundo Batista.)

• Klassen tempfile.NamedTemporaryFile raderar vanligtvis den temporära fil som den skapade när filen stängs. Detta beteende kan nu ändras genom att skicka delete=False till konstruktören. (Bidrag från Damien Miller; bpo-1537850.)

  En ny klass, SpooledTemporaryFile, beter sig som en temporär fil men lagrar sina data i minnet tills en maximal storlek överskrids. När denna gräns nås skrivs innehållet till en temporär fil på disken. (Bidrag från Dustin J. Mitchell.)

  Klasserna NamedTemporaryFile och SpooledTemporaryFile fungerar båda som kontexthanterare, så att du kan skriva with tempfile.NamedTemporaryFile() as tmp: .... (Bidrag från Alexander Belopolsky; bpo-2021.)

• Modulen test.test_support innehåller ett antal kontexthanterare som är användbara för att skriva tester. EnvironmentVarGuard() är en kontexthanterare som tillfälligt ändrar miljövariabler och automatiskt återställer dem till deras gamla värden.

  En annan kontexthanterare, TransientResource, kan omge anrop till resurser som kan vara tillgängliga eller inte; den fångar upp och ignorerar en specificerad lista med undantag. Ett nätverkstest kan t.ex. ignorera vissa fel vid anslutning till en extern webbplats:

  med test_support.TransientResource(IOError,
                                  errno=errno.ETIMEDOUT):
      f = urllib.urlopen('https://sf.net')
      ...
  

  Slutligen återställer check_warnings() warning-modulens varningsfilter och returnerar ett objekt som registrerar alla varningsmeddelanden som utlösts (bpo-3781):

  med test_support.check_warnings() som wrec:
      warnings.simplefilter("alltid")
      # ... kod som utlöser en varning ...
      assert str(wrec.message) == "funktionen är föråldrad"
      assert len(wrec.warnings) == 1, "Flera varningar utlöses"
  

  (Bidrag från Brett Cannon.)

• Modulen textwrap kan nu bevara befintliga blanksteg i början och slutet av de nyskapade raderna genom att ange drop_whitespace=False som argument:

  >>> S = """This  sentence  has a bunch   of
  ...   extra   whitespace."""
  >>> print textwrap.fill(S, width=15)
  This  sentence
  has a bunch
  of    extra
  whitespace.
  >>> print textwrap.fill(S, drop_whitespace=False, width=15)
  This  sentence
    has a bunch
     of    extra
     whitespace.
  >>>
  

  (Bidrag från Dwayne Bailey; bpo-1581073.)

• API:et för modulen threading har ändrats så att egenskaper som daemon används i stället för metoderna setDaemon() och isDaemon(), och vissa metoder har bytt namn så att de använder understreck i stället för versaler, t.ex. har metoden activeCount() bytt namn till active_count(). Både 2.6- och 3.0-versionerna av modulen stöder samma egenskaper och omdöpta metoder, men tar inte bort de gamla metoderna. Inget datum har fastställts för utfasningen av de gamla API: erna i Python 3.x; de gamla API: erna kommer inte att tas bort i någon 2.x-version. (Genomfört av flera personer, särskilt Benjamin Peterson.)

  threading-modulens Thread-objekt fick en ident-egenskap som returnerar trådens identifierare, ett heltal som inte är noll. (Bidrag från Gregory P. Smith; bpo-2871.)

• Modulen timeit accepterar nu anropsbara objekt samt strängar för det uttalande som tidsbestäms och för inställningskoden. Två bekvämlighetsfunktioner har lagts till för att skapa Timer-instanser: repeat(stmt, setup, time, repeat, number) och timeit(stmt, setup, time, number) skapar en instans och anropar motsvarande metod. (Bidrag från Erik Demaine; bpo-1533909.)

• Modulen Tkinter accepterar nu listor och tupler som alternativ och separerar elementen med mellanslag innan det resulterande värdet skickas till Tcl/Tk. (Bidrag från Guilherme Polo; bpo-2906.)

• Modulen turtle för sköldpaddsgrafik har förbättrats avsevärt av Gregor Lingl. Nya funktioner i modulen inkluderar:

  • Bättre animering av sköldpaddans rörelse och rotation.

  • Kontroll över sköldpaddans rörelser med hjälp av de nya metoderna delay(), tracer() och speed().

  • Möjligheten att ställa in nya former för sköldpaddan och att definiera ett nytt koordinatsystem.

  • Sköldpaddor har nu en undo()-metod som kan rulla tillbaka åtgärder.

  • Enkelt stöd för att reagera på indatahändelser som mus- och tangentbordsaktivitet, vilket gör det möjligt att skriva enkla spel.

  • En turtle.cfg-fil kan användas för att anpassa startutseendet på sköldpaddans skärm.

  • Modulens dokumentationssträngar kan ersättas av nya dokumentationssträngar som har översatts till ett annat språk.

  (bpo-1513695)

• En valfri parameter timeout har lagts till i funktionen urllib.urlopen och klasskonstruktören urllib.ftpwrapper, samt i funktionen urllib2.urlopen. Parametern anger en timeout som mäts i sekunder. Till exempel:

  >>> u = urllib2.urlopen("http://slow.example.com",
                          timeout=3)
  Traceback (most recent call last):
    ...
  urllib2.URLError: <urlopen error timed out>
  >>>
  

  (Tillagd av Facundo Batista.)

• Unicode-databasen som tillhandahålls av modulen unicodedata har uppdaterats till version 5.1.0. (Uppdaterad av Martin von Löwis; bpo-3811.)

• Modulerna warnings formatwarning() och showwarning() har fått ett valfritt line-argument som kan användas för att ange en rad i källkoden. (Tillagd som en del av bpo-1631171, som återimplementerade en del av modulen warnings i C-kod)

  En ny funktion, catch_warnings(), är en kontexthanterare avsedd för teständamål som gör att du tillfälligt kan ändra varningsfiltren och sedan återställa deras ursprungliga värden (bpo-3781).

• XML-RPC-klasserna SimpleXMLRPCServer och DocXMLRPCServer kan nu förhindras från att omedelbart öppna och binda till sin socket genom att ange False som bind_and_activate-konstruktörsparameter. Detta kan användas för att modifiera instansens attribut allow_reuse_address innan metoderna server_bind() och server_activate() anropas för att öppna sockeln och börja lyssna på anslutningar. (Bidrag från Peter Parente; bpo-1599845.)

  SimpleXMLRPCServer har också ett _send_traceback_header-attribut; om true returneras undantaget och den formaterade tracebacken som HTTP-rubriker ”X-Exception” och ”X-Traceback”. Denna funktion är endast avsedd för felsökning och bör inte användas på produktionsservrar eftersom spårningarna kan avslöja lösenord eller annan känslig information. (Bidrag från Alan McIntyre som en del av hans projekt för Googles Summer of Code 2007)

• Modulen xmlrpclib konverterar inte längre automatiskt datetime.date och datetime.time till typen xmlrpclib.DateTime; konverteringssemantiken var inte nödvändigtvis korrekt för alla applikationer. Kod som använder xmlrpclib bör konvertera date och time instanser. (bpo-1330538) Koden kan även hantera datum före 1900 (bidrag från Ralf Schmitt; bpo-2014) och 64-bitars heltal som representeras genom att använda <i8> i XML-RPC-svar (bidrag från Riku Lindblad; bpo-2985).

• Modulen zipfile’s klass ZipFile har nu metoderna extract() och extractall() som packar upp en enskild fil eller alla filer i arkivet till den aktuella katalogen eller till en angiven katalog:

  z = zipfile.ZipFile('python-251.zip')
  
  # Packa upp en enda fil och skriv den relativt
  # till katalogen /tmp.
  z.extract('Python/sysmodule.c', '/tmp')
  
  # Packa upp alla filer i arkivet.
  z.extraheraall()
  

  (Bidrag från Alan McIntyre; bpo-467924.)

  Metoderna open(), read() och extract() kan nu ta emot antingen ett filnamn eller ett ZipInfo-objekt. Detta är användbart när ett arkiv av misstag innehåller ett duplicerat filnamn. (Bidrag från Graham Horler; bpo-1775025.)

  Slutligen stöder zipfile nu användning av Unicode-filnamn för arkiverade filer. (Bidrag från Alexey Borzenkov; bpo-1734346.)

Modulen ast

Modulen ast ger en representation av Python-kod i form av ett abstrakt syntaxträd, och Armin Ronacher har bidragit med en uppsättning hjälpfunktioner som utför en mängd vanliga uppgifter. Dessa kommer att vara användbara för HTML-templating-paket, kodanalysatorer och liknande verktyg som bearbetar Python-kod.

Funktionen parse() tar ett uttryck och returnerar en AST. Funktionen dump() ger en representation av ett träd, lämplig för felsökning:

import ast

t = ast.parse("""
d = {}
for i in 'abcdefghijklm':
    d[i + i] = ord(i) - ord('a') + 1
print d
""")
print ast.dump(t)

Detta ger ett djupt nästlat träd:

Modul(kropp=[
  Tilldela(mål=[
    Namn(id='d', ctx=Store())
   ], value=Dict(keys=[], values=[]))
  For(target=Name(id='i', ctx=Store()),
      iter=Str(s='abcdefghijklm'), body=[
    Tilldela(mål=[
      Subscript(värde=
        Name(id='d', ctx=Load()),
          slice=
          Index(värde=
            BinOp(left=Namn(id='i', ctx=Load()), op=Add(),
             right=Name(id='i', ctx=Load()))), ctx=Store())
     ], värde=
     BinOp(vänster=
      BinOp(vänster=
       Anrop(func=
        Name(id='ord', ctx=Load()), args=[
          Namn(id='i', ctx=Load())
         ], nyckelord=[], starargs=None, kwargs=None),
       op=Sub(), right=Anrop(func=
        Name(id='ord', ctx=Load()), args=[
          Str(s='a')
         ], nyckelord=[], starargs=None, kwargs=None)),
       op=Add(), right=Num(n=1)))
    ], orelse=[])
   Print(dest=One, värden=[
     Namn(id='d', ctx=Load())
   ], nl=True)
 ])

Metoden literal_eval() tar en sträng eller en AST som representerar ett bokstavligt uttryck, analyserar och utvärderar det och returnerar det resulterande värdet. Ett bokstavligt uttryck är ett Python-uttryck som bara innehåller strängar, tal, lexikon etc. men inga satser eller funktionsanrop. Om du behöver utvärdera ett uttryck men inte kan acceptera säkerhetsrisken med att använda ett eval()-anrop, kommer literal_eval() att hantera det på ett säkert sätt:

>>> literal = '("a", "b", {2:4, 3:8, 1:2})'
>>> print ast.literal_eval(literal)
('a', 'b', {1: 2, 2: 4, 3: 8})
>>> print ast.literal_eval('"a" + "b"')
Traceback (most recent call last):
  ...
ValueError: malformed string

Modulen innehåller också klasserna NodeVisitor och NodeTransformer för genomgång och modifiering av en AST, samt funktioner för vanliga transformationer, t.ex. ändring av radnummer.

Modulen future_builtins

Python 3.0 gör många ändringar i repertoaren av inbyggda funktioner, och de flesta av ändringarna kan inte införas i Python 2.x-serien eftersom de skulle bryta kompatibiliteten. Modulen future_builtins tillhandahåller versioner av dessa inbyggda funktioner som kan importeras när du skriver 3.0-kompatibel kod.

Funktionerna i denna modul omfattar för närvarande:

• ascii(obj): likvärdig med repr(). I Python 3.0 kommer repr() att returnera en Unicode-sträng, medan ascii() kommer att returnera en ren ASCII-bytestring.

• filter(predikat, iterabel), map(func, iterabel1, ...): 3.0-versionerna returnerar iteratorer, till skillnad från 2.x-inbyggnaderna som returnerar listor.

• hex(värde), oct(värde): istället för att anropa metoderna __hex__() eller __oct__() anropar dessa versioner metoden __index__() och konverterar resultatet till hexadecimal eller oktal. oct() använder den nya notationen 0o för sitt resultat.

Modulen json: JavaScript-objektnotation

Den nya modulen json stöder kodning och avkodning av Python-typer i JSON (Javascript Object Notation). JSON är ett lättviktigt utbytesformat som ofta används i webbapplikationer. För mer information om JSON, se http://www.json.org.

json har stöd för avkodning och kodning av de flesta inbyggda Python-typer. Följande exempel kodar och avkodar en ordbok:

>>> import json
>>> data = {"spam": "foo", "parrot": 42}
>>> in_json = json.dumps(data) # Encode the data
>>> in_json
'{"parrot": 42, "spam": "foo"}'
>>> json.loads(in_json) # Decode into a Python object
{"spam": "foo", "parrot": 42}

Det är också möjligt att skriva egna avkodare och kodare för att stödja fler typer. Pretty-printing av JSON-strängarna stöds också.

json (ursprungligen kallad simplejson) skrevs av Bob Ippolito.

Modulen plistlib: En parser för egenskapslistor

Formatet .plist används ofta på Mac OS X för att lagra grundläggande datatyper (siffror, strängar, listor och ordböcker) genom att serialisera dem till ett XML-baserat format. Det liknar XML-RPC-serialisering av datatyper.

Trots att formatet främst används på Mac OS X är det inte Mac-specifikt och Python-implementationen fungerar på alla plattformar som Python stöder, så modulen plistlib har flyttats till standardbiblioteket.

Det är enkelt att använda modulen:

import sys
import plistlib
import datetime

# Create data structure
data_struct = dict(lastAccessed=datetime.datetime.now(),
                   version=1,
                   categories=('Personal','Shared','Private'))

# Create string containing XML.
plist_str = plistlib.writePlistToString(data_struct)
new_struct = plistlib.readPlistFromString(plist_str)
print data_struct
print new_struct

# Write data structure to a file and read it back.
plistlib.writePlist(data_struct, '/tmp/customizations.plist')
new_struct = plistlib.readPlist('/tmp/customizations.plist')

# read/writePlist accepts file-like objects as well as paths.
plistlib.writePlist(data_struct, sys.stdout)

förbättringar av ctypes

Thomas Heller fortsatte att underhålla och förbättra modulen ctypes.

ctypes stöder nu en c_bool-datatyp som representerar C99-typen bool. (Bidrag från David Remahl; bpo-1649190.)

Typerna ctypes string, buffer och array har förbättrat stöd för utökad slicing-syntax, där olika kombinationer av (start, stop, step) anges. (Implementerat av Thomas Wouters.)

Alla ctypes datatyper stöder nu from_buffer() och from_buffer_copy() metoder som skapar en ctypes-instans baserat på ett tillhandahållet buffertobjekt. from_buffer_copy() kopierar innehållet i objektet, medan from_buffer() delar samma minnesområde.

En ny anropskonvention säger till ctypes att rensa variablerna errno eller Win32 LastError i början av varje inkapslat anrop. (Implementerat av Thomas Heller; bpo-1798.)

Du kan nu hämta Unix-variabeln errno efter ett funktionsanrop. När du skapar en omsluten funktion kan du ange use_errno=True som en nyckelordsparameter till DLL()-funktionen och sedan anropa modulnivåmetoderna set_errno() och get_errno() för att ställa in och hämta felvärdet.

Win32-variabeln LastError stöds på liknande sätt av funktionerna DLL(), OleDLL() och WinDLL(). Du anger use_last_error=True som en nyckelordsparameter och anropar sedan modulnivåmetoderna set_last_error() och get_last_error().

Funktionen byref(), som används för att hämta en pekare till en ctypes-instans, har nu en valfri parameter offset som är ett byteantal som läggs till den returnerade pekaren.

Förbättrat SSL-stöd

Bill Janssen har gjort omfattande förbättringar av Python 2.6:s stöd för Secure Sockets Layer genom att lägga till en ny modul, ssl, som är byggd ovanpå biblioteket OpenSSL. Denna nya modul ger mer kontroll över det protokoll som förhandlas, de X.509-certifikat som används och har bättre stöd för att skriva SSL-servrar (i motsats till klienter) i Python. Det befintliga SSL-stödet i modulen socket har inte tagits bort och fortsätter att fungera, även om det kommer att tas bort i Python 3.0.

För att använda den nya modulen måste du först skapa en TCP-anslutning på vanligt sätt och sedan skicka den till funktionen ssl.wrap_socket(). Det är möjligt att ange om ett certifikat krävs och att få certifikatinformation genom att anropa metoden getpeercert().

Se även

Dokumentationen för modulen ssl.

Utfasningar och borttagningar

• Strängundantag har tagits bort. Försök att använda dem ger upphov till ett TypeError.

• Ändringar i Exception-gränssnittet enligt PEP 352 fortsätter att göras. För 2.6 kommer attributet message att tas bort till förmån för attributet args.

• (3.0-varningsläge) Python 3.0 kommer att innehålla ett omorganiserat standardbibliotek som kommer att ta bort många föråldrade moduler och byta namn på andra. Python 2.6 som körs i 3.0-varningsläge kommer att varna för dessa moduler när de importeras.

  Listan över utfasade moduler är: audiodev, bgenlocations, buildtools, bundlebuilder, Canvas, compiler, dircache, dl, fpformat, gensuitemodule, ihooks, imageop, imgfile, linuxaudiodev, mhlib, mimetools, multifile, new, pure, statvfs, sunaudiodev, test.testall, och toaiff.

• Modulen gopherlib har tagits bort.

• Modulerna MimeWriter och mimify har utgått; använd paketet email istället.

• Modulen md5 har utgått; använd istället modulen hashlib.

• Modulen posixfile har utgått; fcntl.lockf() ger bättre låsning.

• Modulen popen2 har utgått; använd modulen subprocess.

• Modulen rgbimg har tagits bort.

• Modulen sets har utgått; det är bättre att använda de inbyggda typerna set och frozenset.

• Modulen sha har utgått; använd istället modulen hashlib.

Ändringar i Build och C API

Ändringar i Pythons byggprocess och i C API inkluderar:

• Python måste nu kompileras med C89-kompilatorer (efter 19 år!). Detta innebär att Pythons källträd har släppt sina egna implementationer av memmove() och strerror(), som finns i C89:s standardbibliotek.

• Python 2.6 kan byggas med Microsoft Visual Studio 2008 (version 9.0), och detta är den nya standardkompilatorn. Se katalogen PCbuild för byggfilerna. (Implementerat av Christian Heimes.)

• På Mac OS X kan Python 2.6 kompileras som en 4-vägs universalbyggnad. Skriptet configure kan innehålla ett --with-universal-archs=[32-bit|64-bit|all] som styr om binärerna ska byggas för 32-bitarsarkitekturer (x86, PowerPC), 64-bitarsarkitekturer (x86-64 och PPC-64) eller båda. (Bidrag från Ronald Oussoren.)

• En ny funktion tillagd i Python 2.6.6, PySys_SetArgvEx(), anger värdet på sys.argv och kan eventuellt uppdatera sys.path till att inkludera katalogen som innehåller skriptet som heter sys.argv[0] beroende på värdet på en updatepath-parameter.

  Denna funktion lades till för att täppa till ett säkerhetshål för program som bäddar in Python. Den gamla funktionen, PySys_SetArgv(), uppdaterade alltid sys.path, och ibland lade den till den aktuella katalogen. Detta innebar att om du körde ett program som bäddade in Python i en katalog som kontrollerades av någon annan, kunde angripare lägga in en trojansk modul i katalogen (till exempel en fil med namnet os.py) som ditt program sedan importerade och körde.

  Om du underhåller ett C/C++-program som bäddar in Python, kontrollera om du anropar PySys_SetArgv() och överväg noga om programmet bör använda PySys_SetArgvEx() med updatepath satt till false. Observera att användningen av denna funktion kommer att bryta kompatibiliteten med Python-versioner 2.6.5 och tidigare; om du måste fortsätta att arbeta med tidigare versioner kan du låta bli att anropa PySys_SetArgv() och anropa PyRun_SimpleString("sys.path.pop(0)\n") efteråt för att kassera den första sys.path-komponenten.

  Säkerhetsproblem rapporterat som CVE 2008-5983; diskuterat i gh-50003, och åtgärdat av Antoine Pitrou.

• BerkeleyDB-modulen har nu ett C API-objekt, tillgängligt som bsddb.db.api. Detta objekt kan användas av andra C-tillägg som vill använda bsddb-modulen för sina egna syften. (Bidrag från Duncan Grisby.)

• Det nya buffertgränssnittet, som tidigare beskrevs i PEP 3118-avsnittet, lägger till PyObject_GetBuffer() och PyBuffer_Release(), samt några andra funktioner.

• Pythons användning av C stdio-biblioteket är nu trådsäkert, eller åtminstone lika trådsäkert som det underliggande biblioteket är. En potentiell bugg som funnits länge uppstod om en tråd stängde ett filobjekt medan en annan tråd läste från eller skrev till objektet. I 2.6 har filobjekt ett referensantal som manipuleras av funktionerna PyFile_IncUseCount() och PyFile_DecUseCount(). Filobjekt kan inte stängas om inte referensantalet är noll. PyFile_IncUseCount() bör anropas medan GIL fortfarande hålls, innan en I/O-operation utförs med hjälp av pekaren FILE *, och PyFile_DecUseCount() bör anropas omedelbart efter att GIL återfåtts. (Bidrag från Antoine Pitrou och Gregory P. Smith.)

• Att importera moduler samtidigt i två olika trådar leder inte längre till dödlägen; det kommer nu att ge upphov till ett ImportError. En ny API-funktion, PyImport_ImportModuleNoBlock(), letar först efter en modul i sys.modules och försöker sedan importera den efter att ha fått ett importlås. Om importlåset hålls av en annan tråd, kommer ett ImportError att uppstå. (Bidrag från Christian Heimes.)

• Flera funktioner returnerar information om plattformens stöd för flyttal. PyFloat_GetMax() returnerar det högsta representerbara flyttalsvärdet och PyFloat_GetMin() returnerar det lägsta positiva värdet. PyFloat_GetInfo() returnerar ett objekt som innehåller mer information från filen float.h, till exempel "mant_dig" (antal siffror i mantissan), "epsilon" (minsta skillnaden mellan 1,0 och det näst största representerbara värdet) och flera andra. (Bidrag från Christian Heimes; bpo-1534.)

• C-funktioner och metoder som använder PyComplex_AsCComplex() kommer nu att acceptera argument som har en __complex__()-metod. I synnerhet kommer funktionerna i modulen cmath nu att acceptera objekt med den här metoden. Detta är en backport av en ändring i Python 3.0. (Bidrag från Mark Dickinson; bpo-1675423.)

• Pythons C API innehåller nu två funktioner för skiftlägesokänsliga strängjämförelser, PyOS_stricmp(char*, char*) och PyOS_strnicmp(char*, char*, Py_ssize_t). (Bidrag från Christian Heimes; bpo-1635.)

• Många C-tillägg definierar sina egna små makron för att lägga till heltal och strängar till modulens ordbok i funktionen init*. Python 2.6 definierar äntligen standardmakron för att lägga till värden i en modul, PyModule_AddStringMacro och PyModule_AddIntMacro(). (Bidrag från Christian Heimes.)

• Vissa makron döptes om i både 3.0 och 2.6 för att göra det tydligare att de är makron, inte funktioner. Py_Size() blev Py_SIZE(), Py_Type() blev Py_TYPE(), och Py_Refcnt() blev Py_REFCNT(). Makron med blandade versaler är fortfarande tillgängliga i Python 2.6 för bakåtkompatibilitet. (bpo-1629)

• Distutils placerar nu C-tillägg som den bygger i en annan katalog när den körs på en debug-version av Python. (Bidrag från Collin Winter; bpo-1530959.)

• Flera grundläggande datatyper, t.ex. heltal och strängar, har interna fria listor med objekt som kan återanvändas. Datastrukturerna för dessa fria listor följer nu en namngivningskonvention: variabeln heter alltid free_list, räknaren heter alltid numfree och ett makro Py<typename>_MAXFREELIST definieras alltid.

• Ett nytt Makefile-mål, ”make patchcheck”, förbereder Python-källträdet för att göra en patch: det fixar efterföljande blanksteg i alla modifierade .py-filer, kontrollerar om dokumentationen har ändrats och rapporterar om filerna Misc/ACKS och Misc/NEWS har uppdaterats. (Bidrag från Brett Cannon.)

  Ett annat nytt mål, ”make profile-opt”, kompilerar en Python-binärfil med hjälp av GCC:s profilstyrda optimering. Det kompilerar Python med profilering aktiverad, kör testsviten för att få en uppsättning profileringsresultat och kompilerar sedan med hjälp av dessa resultat för optimering. (Bidrag från Gregory P. Smith.)

Portspecifika ändringar: Fönster

• Stödet för Windows 95, 98, ME och NT4 har tagits bort. Python 2.6 kräver minst Windows 2000 SP4.

• Den nya standardkompilatorn i Windows är Visual Studio 2008 (version 9.0). Byggkatalogerna för Visual Studio 2003 (version 7.1) och 2005 (version 8.0) har flyttats till katalogen PC/. Den nya PCbuild-katalogen stöder korskompilering för X64, debug-byggnader och Profile Guided Optimization (PGO). PGO-byggnationer är ungefär 10% faster än normala byggnationer. (Bidrag från Christian Heimes med hjälp av Amaury Forgeot d’Arc och Martin von Löwis)

• Modulen msvcrt har nu stöd för både normal- och wide char-varianterna av konsolens I/O API. Funktionen getwch() läser en tangenttryckning och returnerar ett Unicode-värde, vilket även gäller för funktionen getwche(). Funktionen putwch() tar ett Unicode-tecken och skriver det till konsolen. (Bidrag från Christian Heimes.)

• os.path.expandvars() kommer nu att expandera miljövariabler i formen ”%var%”, och ”~user” kommer att expanderas till användarens sökväg till hemkatalogen. (Bidrag från Josiah Carlson; bpo-957650.)

• Socketobjekten i modulen socket har nu en metod ioctl() som ger ett begränsat gränssnitt till systemgränssnittet WSAIoctl().

• Modulen _winreg har nu en funktion, ExpandEnvironmentStrings(), som expanderar referenser till miljövariabler som %NAME% i en indatasträng. Handle-objekten som tillhandahålls av denna modul stöder nu kontextprotokollet, så att de kan användas i with-satser. (Bidrag från Christian Heimes.)

  _winreg har också bättre stöd för x64-system, med funktionerna DisableReflectionKey(), EnableReflectionKey() och QueryReflectionKey(), som aktiverar och inaktiverar registerreflektion för 32-bitars processer som körs på 64-bitars system. (bpo-1753245)

• Modulen msilib:s Record-objekt har fått metoderna GetInteger() och GetString() som returnerar fältvärden som ett heltal eller en sträng. (Bidrag från Floris Bruynooghe; bpo-2125.)

Hamnspecifika ändringar: Mac OS X

• När du kompilerar en ramverksversion av Python kan du nu ange vilket ramverksnamn som ska användas genom att ange alternativet --with-framework-name= till skriptet configure.

• Modulen macfs har tagits bort. Detta krävde i sin tur att funktionen macostools.touched() togs bort eftersom den var beroende av modulen macfs. (bpo-1490190)

• Många andra Mac OS-moduler har blivit föråldrade och kommer att tas bort i Python 3.0: _builtinSuites, aepack, aetools, aetypes, applesingle, appletrawmain, appletrunner, argvemulator, Audio_mac, autoGIL, Carbon, cfmfile, CodeWarrior, ColorPicker, EasyDialogs, Explorer, Finder, FrameWork, findertools, ic, icglue, icopen, macerrors, MacOS, macfs, macostools, macresource, MiniAEFrame, Nav, Netscape, OSATerminology, pimp, PixMapWrapper, StdSuites, SystemEvents, Terminal, och terminalcommand.

Portspecifika ändringar: IRIX

Ett antal gamla IRIX-specifika moduler har föråldrats och kommer att tas bort i Python 3.0: al och AL, cd, cddb, cdplayer, CL och cl, DEVICE, ERRNO, FILE, FL och fl, flp, fm, GET, GLWS, GL och gl, IN, IOCTL, jpeg, panelparser, readcd, SV och sv, torgb, videoreader, och WAIT.

Portning till Python 2.6

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

• Klasser som inte är avsedda att vara hashbara bör ange __hash__ = None i sina definitioner för att ange detta.

• Strängundantag har tagits bort. Försök att använda dem ger upphov till ett TypeError.

• Metoden __init__() i collections.deque rensar nu allt befintligt innehåll i deque innan element läggs till från iterabeln. Denna ändring gör att beteendet matchar list.__init__().

• object.__init__() accepterade tidigare godtyckliga argument och nyckelordsargument och ignorerade dem. I Python 2.6 är detta inte längre tillåtet och kommer att resultera i ett TypeError. Detta kommer att påverka __init__()-metoder som i slutändan anropar motsvarande metod på object (kanske genom att använda super()). Se bpo-1683368 för diskussion.

• Konstruktorn Decimal accepterar nu inledande och avslutande blanksteg när den får en sträng. Tidigare skulle den ge upphov till ett InvalidOperation undantag. Å andra sidan, metoden create_decimal() för Context-objekt tillåter nu uttryckligen inte extra blanksteg, vilket ger upphov till ett ConversionSyntax-undantag.

• På grund av en implementeringsolycka, om du skickade en filsökväg till den inbyggda __import__()-funktionen, skulle den faktiskt importera den angivna filen. Detta var dock aldrig tänkt att fungera, och implementationen kontrollerar nu uttryckligen för detta fall och ger upphov till ett ImportError.

• C API: funktionerna PyImport_Import() och PyImport_ImportModule() använder nu som standard absolut import, inte relativ import. Detta kommer att påverka C-tillägg som importerar andra moduler.

• C API: Tilläggsdatatyper som inte bör vara hashbara bör definiera sin tp_hash-plats till PyObject_HashNotImplemented().

• Modulundantaget socket socket.error ärver nu från IOError. Tidigare var det inte en underklass till StandardError men nu är det det, genom IOError. (Implementerat av Gregory P. Smith; bpo-1706815.)

• Modulen xmlrpclib konverterar inte längre automatiskt datetime.date och datetime.time till typen xmlrpclib.DateTime; konverteringssemantiken var inte nödvändigtvis korrekt för alla applikationer. Kod som använder xmlrpclib bör konvertera date och time instanser. (bpo-1330538)

• (3.0-warning mode) Klassen Exception varnar nu vid åtkomst med slicing eller indexåtkomst; att Exception beter sig som en tuple håller på att fasas ut.

• (3.0-varningsläge) ojämlikhetsjämförelser mellan två ordböcker eller två objekt som inte implementerar jämförelsemetoder rapporteras som varningar. dict1 == dict2 fungerar fortfarande, men dict1 < dict2 håller på att fasas ut.

  Jämförelser mellan celler, som är en implementeringsdetalj av Pythons scoping-regler, orsakar också varningar eftersom sådana jämförelser är helt förbjudna i 3.0.

För applikationer som bygger in Python:

• Funktionen PySys_SetArgvEx() lades till i Python 2.6.6, vilket gör det möjligt för applikationer att täppa till ett säkerhetshål när den befintliga funktionen PySys_SetArgv() användes. Kontrollera om du anropar PySys_SetArgv() och överväg noga om programmet bör använda PySys_SetArgvEx() med updatepath satt till false.

Tack till

Författaren vill tacka följande personer för förslag, korrigeringar och hjälp med olika utkast av denna artikel: Georg Brandl, Steve Brown, Nick Coghlan, Ralph Corderoy, Jim Jewett, Kent Johnson, Chris Lambacher, Martin Michlmayr, Antoine Pitrou, Brian Warner.