Was ist neu in Python 2.6

Autor:

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

Dieser Artikel erklärt die neuen Funktionen in Python 2.6, veröffentlicht am 1. Oktober 2008. Der Veröffentlichungsplan wird in PEP 361 beschrieben.

Das Hauptthema von Python 2.6 ist die Vorbereitung des Migrationspfads zu Python 3.0, einer grundlegenden Neugestaltung der Sprache. Wo immer möglich, integriert Python 2.6 neue Funktionen und Syntax aus 3.0 und bleibt dabei mit bestehendem Code kompatibel, indem ältere Funktionen oder Syntax nicht entfernt werden. Wenn dies nicht möglich ist, versucht Python 2.6, das Bestmögliche zu tun, indem es Kompatibilitätsfunktionen in einem Modul future_builtins und einem Schalter -3 hinzufügt, um auf Verwendungen hinzuweisen, die in 3.0 nicht mehr unterstützt werden.

Einige bedeutende neue Pakete wurden zur Standardbibliothek hinzugefügt, wie z. B. die Module multiprocessing und json, aber es gibt nicht viele neue Funktionen, die nicht in irgendeiner Weise mit Python 3.0 zusammenhängen.

Python 2.6 bringt auch eine Reihe von Verbesserungen und Fehlerbehebungen im gesamten Quellcode mit sich. Eine Suche in den Changelogs ergibt, dass zwischen Python 2.5 und 2.6 259 Patches angewendet und 612 Fehler behoben wurden. Beide Zahlen sind wahrscheinlich Unterschätzungen.

Dieser Artikel versucht nicht, eine vollständige Spezifikation der neuen Funktionen zu liefern, sondern bietet stattdessen einen praktischen Überblick. Für vollständige Details sollten Sie die Dokumentation für Python 2.6 konsultieren. Wenn Sie die Begründung für das Design und die Implementierung verstehen möchten, lesen Sie die PEP für eine bestimmte neue Funktion. Wo immer möglich, verlinkt „Was ist neu in Python“ auf den Bug-/Patch-Eintrag für jede Änderung.

Python 3.0

Der Entwicklungszyklus für die Python-Versionen 2.6 und 3.0 war synchronisiert, wobei die Alpha- und Beta-Versionen beider Versionen am selben Tag veröffentlicht wurden. Die Entwicklung von 3.0 hat viele Funktionen in 2.6 beeinflusst.

Python 3.0 ist eine weitreichende Neugestaltung von Python, die die Kompatibilität mit der 2.x-Serie bricht. Das bedeutet, dass bestehender Python-Code konvertiert werden muss, um unter Python 3.0 zu laufen. Jedoch brechen nicht alle Änderungen in 3.0 notwendigerweise die Kompatibilität. In Fällen, in denen neue Funktionen keinen bestehenden Code brechen, wurden sie nach 2.6 zurückportiert und werden in diesem Dokument an der entsprechenden Stelle beschrieben. Einige der aus 3.0 abgeleiteten Funktionen sind

• Eine Methode __complex__() zur Konvertierung von Objekten in eine komplexe Zahl.

• Alternative Syntax zum Abfangen von Ausnahmen: except TypeError as exc.

• Die Hinzufügung von functools.reduce() als Synonym für die eingebaute Funktion reduce().

Python 3.0 fügt mehrere neue eingebaute Funktionen hinzu und ändert die Semantik einiger bestehender eingebauter Funktionen. Funktionen, die in 3.0 neu sind, wie bin(), wurden einfach zu Python 2.6 hinzugefügt, aber bestehende eingebaute Funktionen wurden nicht geändert; stattdessen enthält das Modul future_builtins Versionen mit der neuen 3.0-Semantik. Code, der mit 3.0 kompatibel sein soll, kann from future_builtins import hex, map nach Bedarf verwenden.

Ein neuer Kommandozeilenschalter, -3, aktiviert Warnungen über Funktionen, die in Python 3.0 entfernt werden. Sie können Code mit diesem Schalter ausführen, um zu sehen, wie viel Arbeit erforderlich sein wird, um Code nach 3.0 zu portieren. Der Wert dieses Schalters ist für Python-Code als boolesche Variable sys.py3kwarning und für C-Erweiterungscode als Py_Py3kWarningFlag verfügbar.

Siehe auch

Die 3xxx-Serie von PEPs, die Vorschläge für Python 3.0 enthält. PEP 3000 beschreibt den Entwicklungsprozess für Python 3.0. Beginnen Sie mit PEP 3100, der die allgemeinen Ziele für Python 3.0 beschreibt, und erkunden Sie dann die höher nummerierten PEPs, die spezifische Funktionen vorschlagen.

Änderungen am Entwicklungsprozess

Während der Entwicklung von 2.6 durchlief der Python-Entwicklungsprozess zwei bedeutende Änderungen: Wir wechselten vom Issue-Tracker von SourceForge zu einer angepassten Roundup-Installation, und die Dokumentation wurde von LaTeX zu reStructuredText konvertiert.

Neuer Issue Tracker: Roundup

Lange Zeit waren die Python-Entwickler zunehmend von SourceForges Bug-Tracker genervt. Die von SourceForge gehostete Lösung erlaubt keine große Anpassung; es war beispielsweise nicht möglich, den Lebenszyklus von Issues anzupassen.

Das Infrastrukturkomitee der Python Software Foundation veröffentlichte daraufhin eine Aufforderung zur Einreichung von Issue-Trackern und bat Freiwillige, verschiedene Produkte einzurichten und einige der Bugs und Patches von SourceForge zu importieren. Vier verschiedene Tracker wurden untersucht: Jira, Launchpad, Roundup und Trac. Das Komitee entschied sich schließlich für Jira und Roundup als die beiden Kandidaten. Jira ist ein kommerzielles Produkt, das kostenlose gehostete Instanzen für Freie-Software-Projekte anbietet; Roundup ist ein Open-Source-Projekt, das Freiwillige für die Administration und einen Server zum Hosting benötigt.

Nachdem eine Aufforderung an Freiwillige veröffentlicht wurde, wurde eine neue Roundup-Installation unter https://bugs.python.org eingerichtet. Eine Roundup-Installation kann mehrere Tracker hosten, und dieser Server hostet nun auch Issue-Tracker für Jython und für die Python-Website. Er wird sicher auch in Zukunft weitere Verwendung finden. Soweit möglich, verlinkt diese Ausgabe von „Was ist neu in Python“ auf den Bug-/Patch-Eintrag für jede Änderung.

Das Hosting des Python-Bug-Trackers wird freundlicherweise von Upfront Systems aus Stellenbosch, Südafrika, bereitgestellt. Martin von Löwis hat viel Aufwand in den Import bestehender Bugs und Patches von SourceForge gesteckt; seine Skripte für diesen Importvorgang sind unter https://svn.python.org/view/tracker/importer/ zu finden und könnten für andere Projekte nützlich sein, die von SourceForge zu Roundup wechseln möchten.

Siehe auch

https://bugs.python.org

Der Python Bug Tracker.

https://bugs.jython.org:

Der Jython Bug Tracker.

https://roundup.sourceforge.io/

Roundup-Downloads und Dokumentation.

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

Martins von Löwis Konvertierungsskripte.

Neues Dokumentationsformat: reStructuredText mit Sphinx

Die Python-Dokumentation wurde seit Beginn des Projekts um 1989 herum mit LaTeX erstellt. In den 1980er und frühen 1990er Jahren wurde die meiste Dokumentation ausgedruckt, um sie später zu studieren, nicht online gelesen. LaTeX wurde weit verbreitet verwendet, da es ansprechenden gedruckten Output lieferte und gleichzeitig einfach zu schreiben war, sobald die Grundregeln des Markup gelernt waren.

Heute wird LaTeX immer noch für das Schreiben von Druckpublikationen verwendet, aber die Landschaft der Programmierwerkzeuge hat sich verändert. Wir drucken keine Dokumentationsseiten mehr aus; stattdessen durchsuchen wir sie online und HTML ist das wichtigste zu unterstützende Format geworden. Leider ist die Konvertierung von LaTeX zu HTML ziemlich kompliziert, und Fred L. Drake Jr., der langjährige Python-Dokumentationseditor, hat viel Zeit mit der Wartung des Konvertierungsprozesses verbracht. Gelegentlich schlugen Leute vor, die Dokumentation in SGML und später in XML zu konvertieren, aber eine gute Konvertierung durchzuführen ist eine große Aufgabe, und niemand hat jemals die erforderliche Zeit investiert, um sie abzuschließen.

Während des 2.6-Entwicklungszyklus hat Georg Brandl viel Aufwand in den Aufbau einer neuen Toolchain zur Verarbeitung der Dokumentation gesteckt. Das resultierende Paket heißt Sphinx und ist unter https://sphinx-doc.de/ erhältlich.

Sphinx konzentriert sich auf HTML-Ausgabe und produziert ansprechend gestaltetes und modernes HTML; gedruckte Ausgabe wird weiterhin durch Konvertierung nach LaTeX unterstützt. Das Eingabeformat ist reStructuredText, eine Markup-Syntax, die benutzerdefinierte Erweiterungen und Direktiven unterstützt und in der Python-Community häufig verwendet wird.

Sphinx ist ein eigenständiges Paket, das zum Schreiben verwendet werden kann, und fast zwei Dutzend andere Projekte (auf der Sphinx-Website aufgelistet) haben Sphinx als ihr Dokumentationswerkzeug übernommen.

Siehe auch

Dokumentation von Python

Beschreibt, wie für die Python-Dokumentation geschrieben wird.

Sphinx

Dokumentation und Code für die Sphinx-Toolchain.

Docutils

Der zugrunde liegende reStructuredText-Parser und das Toolset.

PEP 343: Die ‚with‘-Anweisung

Die Vorgängerversion, Python 2.5, fügte die ‚with‘-Anweisung als optionale Funktion hinzu, die durch die Direktive from __future__ import with_statement aktiviert werden musste. In 2.6 muss die Anweisung nicht mehr speziell aktiviert werden; dies bedeutet, dass with jetzt immer ein Schlüsselwort ist. Der Rest dieses Abschnitts ist eine Kopie des entsprechenden Abschnitts aus dem Dokument „Was ist neu in Python 2.5“; wenn Sie mit der ‚with‘-Anweisung aus Python 2.5 vertraut sind, können Sie diesen Abschnitt überspringen.

Die ‚with‘-Anweisung verdeutlicht Code, der zuvor try...finally-Blöcke verwendet hätte, um sicherzustellen, dass Bereinigungsarbeiten ausgeführt werden. In diesem Abschnitt werde ich die Anweisung so besprechen, wie sie üblicherweise verwendet wird. Im nächsten Abschnitt werde ich die Implementierungsdetails untersuchen und zeigen, wie Objekte für die Verwendung mit dieser Anweisung geschrieben werden.

Die ‚with‘-Anweisung ist eine Kontrollflussstruktur, deren grundlegende Struktur lautet

with expression [as variable]:
    with-block

Der Ausdruck wird ausgewertet und sollte ein Objekt ergeben, das das Kontextmanagement-Protokoll unterstützt (d. h. Methoden __enter__() und __exit__() hat).

Die Methode __enter__() des Objekts wird aufgerufen, bevor der *with-Block* ausgeführt wird, und kann daher Setup-Code ausführen. Sie kann auch einen Wert zurückgeben, der an den Namen *variable* gebunden wird, falls dieser angegeben ist. (Beachten Sie sorgfältig, dass *variable* *nicht* das Ergebnis von *expression* zugewiesen bekommt.)

Nach Abschluss der Ausführung des *with-Blocks* wird die Methode __exit__() des Objekts aufgerufen, auch wenn der Block eine Ausnahme ausgelöst hat, und kann daher Bereinigungsarbeiten ausführen.

Einige Standard-Python-Objekte unterstützen jetzt das Kontextmanagement-Protokoll und können mit der ‚with‘-Anweisung verwendet werden. Dateiobjekte sind ein Beispiel

with open('/etc/passwd', 'r') as f:
    for line in f:
        print line
        ... more processing code ...

Nachdem diese Anweisung ausgeführt wurde, ist das Dateiobjekt in *f* automatisch geschlossen worden, selbst wenn die for-Schleife teilweise im Block eine Ausnahme ausgelöst hat.

Hinweis

In diesem Fall ist *f* dasselbe Objekt, das von open() erstellt wurde, da __enter__() *self* zurückgibt.

Die Locks und Bedingungsvariablen des Moduls threading unterstützen ebenfalls die ‚with‘-Anweisung

lock = threading.Lock()
with lock:
    # Critical section of code
    ...

Der Lock wird vor der Ausführung des Blocks erworben und immer freigegeben, sobald der Block abgeschlossen ist.

Die Funktion localcontext() im Modul decimal erleichtert das Speichern und Wiederherstellen des aktuellen Dezimalkontexts, der die gewünschte Präzision und Rundungseigenschaften für Berechnungen kapselt.

from decimal import Decimal, Context, localcontext

# Displays with default precision of 28 digits
v = Decimal('578')
print v.sqrt()

with localcontext(Context(prec=16)):
    # All code in this block uses a precision of 16 digits.
    # The original context is restored on exiting the block.
    print v.sqrt()

Schreiben von Kontextmanagern

Unter der Haube ist die ‚with‘-Anweisung ziemlich kompliziert. Die meisten Leute werden ‚with‘ nur in Verbindung mit vorhandenen Objekten verwenden und müssen diese Details nicht kennen, daher können Sie den Rest dieses Abschnitts überspringen, wenn Sie möchten. Autoren neuer Objekte müssen die Details der zugrunde liegenden Implementierung verstehen und sollten weiterlesen.

Eine High-Level-Erklärung des Kontextmanagement-Protokolls lautet

• Der Ausdruck wird ausgewertet und sollte ein Objekt namens „Kontextmanager“ ergeben. Der Kontextmanager muss die Methoden __enter__() und __exit__() haben.

• Die Methode __enter__() des Kontextmanagers wird aufgerufen. Der zurückgegebene Wert wird an *VAR* zugewiesen. Wenn keine Klausel as VAR vorhanden ist, wird der Wert einfach verworfen.

• Der Code in *BLOCK* wird ausgeführt.

• Wenn *BLOCK* eine Ausnahme auslöst, wird die Methode __exit__() des Kontextmanagers mit drei Argumenten aufgerufen: den Ausnahmeinformationen (type, value, traceback – dieselben Werte, die von sys.exc_info() zurückgegeben werden, die auch None sein können, wenn keine Ausnahme aufgetreten ist). Der Rückgabewert der Methode steuert, ob eine Ausnahme erneut ausgelöst wird: Ein falscher Wert löst die Ausnahme erneut aus, und True unterdrückt sie. Sie werden nur selten die Ausnahme unterdrücken wollen, da der Autor des Codes, der die ‚with‘-Anweisung enthält, sonst nie merkt, dass etwas schiefgegangen ist.

• Wenn *BLOCK* keine Ausnahme ausgelöst hat, wird die Methode __exit__() trotzdem aufgerufen, aber *type*, *value* und *traceback* sind alle None.

Denken wir über ein Beispiel nach. Ich werde keinen detaillierten Code präsentieren, sondern nur die Methoden skizzieren, die für eine Datenbank, die Transaktionen unterstützt, notwendig sind.

(Für Leute, die mit Datenbankterminologie nicht vertraut sind: Eine Reihe von Änderungen an der Datenbank wird zu einer Transaktion zusammengefasst. Transaktionen können entweder committet werden, d. h. alle Änderungen werden in die Datenbank geschrieben, oder zurückgerollt, d. h. alle Änderungen werden verworfen und die Datenbank bleibt unverändert. Siehe jedes Datenbanklehrbuch für weitere Informationen.)

Nehmen wir an, es gibt ein Objekt, das eine Datenbankverbindung darstellt. Unser Ziel wird es sein, den Benutzer Code wie diesen schreiben zu lassen

db_connection = DatabaseConnection()
with db_connection as cursor:
    cursor.execute('insert into ...')
    cursor.execute('delete from ...')
    # ... more operations ...

Die Transaktion sollte entweder committet werden, wenn der Code im Block fehlerfrei läuft, oder zurückgerollt, wenn eine Ausnahme auftritt. Hier ist die grundlegende Schnittstelle für DatabaseConnection, die ich annehmen werde

class DatabaseConnection:
    # Database interface
    def cursor(self):
        "Returns a cursor object and starts a new transaction"
    def commit(self):
        "Commits current transaction"
    def rollback(self):
        "Rolls back current transaction"

Die Methode __enter__() ist ziemlich einfach, sie muss nur eine neue Transaktion starten. Für diese Anwendung wäre das resultierende Cursor-Objekt ein nützliches Ergebnis, daher wird die Methode es zurückgeben. Der Benutzer kann dann as cursor zu seiner ‚with‘-Anweisung hinzufügen, um den Cursor an einen Variablennamen zu binden.

class DatabaseConnection:
    ...
    def __enter__(self):
        # Code to start a new transaction
        cursor = self.cursor()
        return cursor

Die Methode __exit__() ist am kompliziertesten, da hier die meiste Arbeit geleistet werden muss. Die Methode muss prüfen, ob eine Ausnahme aufgetreten ist. Wenn keine Ausnahme aufgetreten ist, wird die Transaktion committet. Die Transaktion wird zurückgerollt, wenn eine Ausnahme aufgetreten ist.

Im folgenden Code fällt die Ausführung einfach vom Ende der Funktion ab und gibt den Standardwert None zurück. None ist falsch, daher wird die Ausnahme automatisch erneut ausgelöst. Wenn Sie möchten, könnten Sie expliziter sein und eine return-Anweisung an der markierten Stelle hinzufügen.

class DatabaseConnection:
    ...
    def __exit__(self, type, value, tb):
        if tb is None:
            # No exception, so commit
            self.commit()
        else:
            # Exception occurred, so rollback.
            self.rollback()
            # return False

Das Modul contextlib

Das Modul contextlib stellt einige Funktionen und einen Dekorator bereit, die beim Schreiben von Objekten für die Verwendung mit der ‚with‘-Anweisung nützlich sind.

Der Dekorator heißt contextmanager() und ermöglicht es Ihnen, eine einzelne Generatorfunktion zu schreiben, anstatt eine neue Klasse zu definieren. Der Generator sollte genau einen Wert erzeugen. Der Code bis zum yield wird als Methode __enter__() ausgeführt, und der erzeugte Wert wird der Rückgabewert der Methode sein, der an die Variable in der Klausel as der ‚with‘-Anweisung gebunden wird, falls vorhanden. Der Code nach dem yield wird in der Methode __exit__() ausgeführt. Jede Ausnahme, die im Block ausgelöst wird, wird von der Anweisung yield ausgelöst.

Mit diesem Dekorator könnte unser Datenbankbeispiel aus dem vorherigen Abschnitt so geschrieben werden

from contextlib import contextmanager

@contextmanager
def db_transaction(connection):
    cursor = connection.cursor()
    try:
        yield cursor
    except:
        connection.rollback()
        raise
    else:
        connection.commit()

db = DatabaseConnection()
with db_transaction(db) as cursor:
    ...

Das Modul contextlib enthält auch eine Funktion nested(mgr1, mgr2, ...), die mehrere Kontextmanager kombiniert, sodass Sie keine verschachtelten ‚with‘-Anweisungen schreiben müssen. In diesem Beispiel startet die einzelne ‚with‘-Anweisung sowohl eine Datenbanktransaktion als auch erwirbt sie einen Thread-Lock.

lock = threading.Lock()
with nested (db_transaction(db), lock) as (cursor, locked):
    ...

Schließlich gibt die Funktion closing() ihr Argument zurück, damit es an eine Variable gebunden werden kann, und ruft die Methode .close() des Arguments am Ende des Blocks auf.

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)

Siehe auch

PEP 343 - Die „with“-Anweisung

PEP geschrieben von Guido van Rossum und Nick Coghlan; implementiert von Mike Bland, Guido van Rossum und Neal Norwitz. Die PEP zeigt den Code, der für eine ‚with‘-Anweisung generiert wird, was beim Erlernen der Funktionsweise der Anweisung hilfreich sein kann.

Die Dokumentation für das Modul contextlib.

PEP 366: Explizite relative Imports aus einem Hauptmodul

Der Schalter -m von Python erlaubt das Ausführen eines Moduls als Skript. Wenn Sie ein Modul ausführten, das sich innerhalb eines Pakets befand, funktionierten relative Imports nicht korrekt.

Die Korrektur für Python 2.6 fügt ein Attribut module.__package__ hinzu. Wenn dieses Attribut vorhanden ist, werden relative Imports relativ zum Wert dieses Attributs statt zum Attribut __name__ sein.

PEP 302-kompatible Importer können dann __package__ nach Bedarf setzen. Das Modul runpy, das den -m-Schalter implementiert, tut dies nun, so dass relative Imports nun korrekt in Skripten funktionieren, die aus einem Paket heraus ausgeführt werden.

PEP 370: Per-User site-packages-Verzeichnis

Wenn Sie Python ausführen, enthält der Modulsuchpfad sys.path normalerweise ein Verzeichnis, dessen Pfad auf "site-packages" endet. Dieses Verzeichnis ist für lokal installierte Pakete vorgesehen, die für alle Benutzer auf einem Rechner oder einer bestimmten Site-Installation verfügbar sind.

Python 2.6 führt eine Konvention für benutzerspezifische Site-Verzeichnisse ein. Das Verzeichnis variiert je nach Plattform

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

• Windows: %APPDATA%/Python

Innerhalb dieses Verzeichnisses gibt es versionsspezifische Unterverzeichnisse, wie z. B. lib/python2.6/site-packages unter Unix/Mac OS und Python26/site-packages unter Windows.

Wenn Ihnen das Standardverzeichnis nicht gefällt, kann es durch eine Umgebungsvariable überschrieben werden. PYTHONUSERBASE legt das Stammverzeichnis fest, das für alle Python-Versionen verwendet wird, die diese Funktion unterstützen. Unter Windows kann das Verzeichnis für anwendungsspezifische Daten durch Setzen der Umgebungsvariable APPDATA geändert werden. Sie können auch die Datei site.py Ihrer Python-Installation ändern.

Die Funktion kann vollständig deaktiviert werden, indem Python mit der Option -s gestartet oder die Umgebungsvariable PYTHONNOUSERSITE gesetzt wird.

Siehe auch

PEP 370 - Per-User site-packages-Verzeichnis

PEP geschrieben und implementiert von Christian Heimes.

PEP 371: Das Paket multiprocessing

Das neue Paket multiprocessing ermöglicht es Python-Programmen, neue Prozesse zu erstellen, die eine Berechnung durchführen und ein Ergebnis an das Elternprogramm zurückgeben. Die Eltern- und Kindprozesse können mit Queues und Pipes kommunizieren, ihre Operationen mit Locks und Semaphoren synchronisieren und einfache Datenarrays teilen.

Das Modul multiprocessing begann als exakte Emulation des Moduls threading unter Verwendung von Prozessen anstelle von Threads. Dieses Ziel wurde auf dem Weg zu Python 2.6 aufgegeben, aber der allgemeine Ansatz des Moduls ist immer noch ähnlich. Die grundlegende Klasse ist Process, der ein aufrufbares Objekt und eine Sammlung von Argumenten übergeben werden. Die Methode start() startet den Aufruf in einem Unterprozess, danach können Sie die Methode is_alive() aufrufen, um zu prüfen, ob der Unterprozess noch läuft, und die Methode join(), um auf das Beenden des Prozesses zu warten.

Hier ist ein einfaches Beispiel, bei dem der Unterprozess eine Fakultät berechnet. Die Funktion, die die Berechnung durchführt, ist seltsam geschrieben, so dass sie deutlich länger dauert, wenn das Eingabeargument ein Vielfaches von 4 ist.

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

Eine Queue wird verwendet, um das Ergebnis der Fakultät zu kommunizieren. Das Objekt Queue wird in einer globalen Variable gespeichert. Der Kindprozess verwendet den Wert der Variablen, als das Kind erstellt wurde; da es sich um eine Queue handelt, können Eltern- und Kindprozess das Objekt zur Kommunikation verwenden. (Wenn der Elternprozess den Wert der globalen Variable ändern würde, wäre der Wert des Kindes unberührt und umgekehrt.)

Zwei weitere Klassen, Pool und Manager, bieten höherstufige Schnittstellen. Pool erstellt eine feste Anzahl von Worker-Prozessen, und Anfragen können dann an die Worker verteilt werden, indem apply() oder apply_async() aufgerufen wird, um eine einzelne Anfrage hinzuzufügen, und map() oder map_async(), um eine Reihe von Anfragen hinzuzufügen. Der folgende Code verwendet einen Pool, um Anfragen auf 5 Worker-Prozesse zu verteilen und eine Liste von Ergebnissen abzurufen.

from multiprocessing import Pool

def factorial(N, dictionary):
    "Compute a factorial."
    ...
p = Pool(5)
result = p.map(factorial, range(1, 1000, 10))
for v in result:
    print v

Dies erzeugt die folgende Ausgabe.

1
39916800
51090942171709440000
8222838654177922817725562880000000
33452526613163807108170062053440751665152000000000
...

Die andere Schnittstelle auf hoher Ebene, die Klasse Manager, erstellt einen separaten Serverprozess, der Masterkopien von Python-Datenstrukturen enthalten kann. Andere Prozesse können dann über Proxy-Objekte auf diese Datenstrukturen zugreifen und sie ändern. Das folgende Beispiel erstellt ein gemeinsam genutztes Wörterbuch, indem die Methode dict() aufgerufen wird; die Worker-Prozesse fügen dann Werte in das Wörterbuch ein. (Die Sperrung wird nicht automatisch für Sie durchgeführt, was in diesem Beispiel keine Rolle spielt. Die Methoden von Manager enthalten auch Lock(), RLock() und Semaphore() zur Erstellung gemeinsam genutzter Sperren.)

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

Dies erzeugt die Ausgabe

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

Siehe auch

Die Dokumentation für das Modul multiprocessing.

PEP 371 - Hinzufügung des multiprocessing-Pakets

PEP geschrieben von Jesse Noller und Richard Oudkerk; implementiert von Richard Oudkerk und Jesse Noller.

PEP 3101: Erweiterte Zeichenfolgenformatierung

In Python 3.0 wird der Operator % durch eine leistungsfähigere Methode zur Zeichenfolgenformatierung, format(), ergänzt. Unterstützung für die Methode str.format() wurde in Python 2.6 zurückportiert.

In 2.6 haben sowohl 8-Bit- als auch Unicode-Zeichenfolgen eine .format()-Methode, die die Zeichenfolge als Vorlage behandelt und die zu formatierenden Argumente entgegennimmt. Die Formatvorlage verwendet geschweifte Klammern ({, }) als Sonderzeichen

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

Geschweifte Klammern können durch Verdopplung escaped werden

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

Feldnamen können ganze Zahlen sein, die positionale Argumente angeben, wie z.B. {0}, {1}, usw., oder Namen von Schlüsselwortargumenten. Sie können auch zusammengesetzte Feldnamen angeben, die Attribute lesen oder Wörterbuchschlüssel aufrufen

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

Beachten Sie, dass bei der Verwendung von wörterbuchähnlicher Notation wie [.mp4] keine Anführungszeichen um die Zeichenfolge gesetzt werden müssen; der Wert wird unter Verwendung von .mp4 als Schlüssel nachgeschlagen. Zeichenfolgen, die mit einer Zahl beginnen, werden in eine ganze Zahl umgewandelt. Sie können keine komplexeren Ausdrücke innerhalb einer Formatzeichenfolge schreiben.

Bisher haben wir gezeigt, wie angegeben wird, welches Feld in die resultierende Zeichenfolge eingefügt werden soll. Die genaue Formatierung kann auch durch Hinzufügen eines Doppelpunkts gefolgt von einem Format-Spezifizierer gesteuert werden. Zum Beispiel

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

Format-Spezifizierer können andere Felder durch Verschachtelung referenzieren

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

Die Ausrichtung eines Feldes innerhalb der gewünschten Breite kann angegeben werden

Zeichen	Auswirkung
< (Standard)	Linksbündig ausrichten
>	Rechtsbündig ausrichten
^	Zentrieren
=	(Nur für numerische Typen) Nach dem Vorzeichen auffüllen.

Format-Spezifizierer können auch einen Darstellungstyp enthalten, der steuert, wie der Wert formatiert wird. Gleitkommazahlen können zum Beispiel als allgemeine Zahl oder in exponentieller Notation formatiert werden

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

Eine Vielzahl von Darstellungstypen steht zur Verfügung. Konsultieren Sie die Dokumentation für 2.6 für eine vollständige Liste; hier ist ein Beispiel

b	Binär. Gibt die Zahl in Basis 2 aus.
c	Zeichen. Konvertiert die ganze Zahl vor der Ausgabe in das entsprechende Unicode-Zeichen.
d	Dezimalzahl. Gibt die Zahl in Basis 10 aus.
o	Oktalformat. Gibt die Zahl in Basis 8 aus.
x	Hex-Format. Gibt die Zahl in Basis 16 aus, wobei Kleinbuchstaben für die Ziffern über 9 verwendet werden.
e	Exponentielle Notation. Gibt die Zahl in wissenschaftlicher Notation aus, wobei der Buchstabe 'e' zur Angabe des Exponenten verwendet wird.
g	Allgemeines Format. Dies gibt die Zahl als Festkommazahl aus, es sei denn, die Zahl ist zu groß, in welchem Fall sie zu exponentieller Notation 'e' wechselt.
n	Zahl. Dies ist dasselbe wie 'g' (für Gleitkommazahlen) oder 'd' (für ganze Zahlen), mit der Ausnahme, dass die aktuelle Locale-Einstellung verwendet wird, um die entsprechenden Zahlentrennzeichen einzufügen.
%	Prozent. Multipliziert die Zahl mit 100 und zeigt sie im Festkommaformat ('f') gefolgt von einem Prozentzeichen an.

Klassen und Typen können eine Methode __format__() definieren, um zu steuern, wie sie formatiert werden. Sie empfängt ein einzelnes Argument, den Format-Spezifizierer

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

Es gibt auch eine integrierte Funktion format(), die einen einzelnen Wert formatiert. Sie ruft die __format__()-Methode des Typs mit dem angegebenen Spezifizierer auf

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

Siehe auch

Format-String-Syntax

Die Referenzdokumentation für Formatfelder.

PEP 3101 - Erweiterte Zeichenfolgenformatierung

PEP geschrieben von Talin. Implementiert von Eric Smith.

PEP 3105: print Als Funktion

Die print-Anweisung wird in Python 3.0 zur Funktion print(). Indem print() zu einer Funktion gemacht wird, kann die Funktion durch def print(...) ersetzt oder eine neue Funktion von woanders importiert werden.

Python 2.6 hat einen __future__-Import, der print als Sprachsyntax entfernt und die funktionale Form stattdessen verwendet. Zum Beispiel

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

Die Signatur der neuen Funktion lautet

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

Die Parameter sind

• args: positionale Argumente, deren Werte ausgegeben werden.

• sep: das Trennzeichen, das zwischen den Argumenten ausgegeben wird.

• end: der Endtext, der nach der Ausgabe aller Argumente ausgegeben wird.

• file: das Dateiobjekt, an das die Ausgabe gesendet wird.

Siehe auch

PEP 3105 - Print als Funktion

PEP geschrieben von Georg Brandl.

PEP 3110: Änderungen bei der Ausnahmebehandlung

Ein Fehler, der Python-Programmierern gelegentlich unterläuft, ist das Schreiben des folgenden Codes

try:
    ...
except TypeError, ValueError:  # Wrong!
    ...

Der Autor versucht wahrscheinlich, sowohl TypeError als auch ValueError-Ausnahmen abzufangen, aber dieser Code tut etwas anderes: er fängt TypeError ab und bindet das resultierende Ausnahmeobjekt an den lokalen Namen "ValueError". Die ValueError-Ausnahme wird überhaupt nicht abgefangen. Der korrekte Code gibt ein Tupel von Ausnahmen an

try:
    ...
except (TypeError, ValueError):
    ...

Dieser Fehler tritt auf, weil die Verwendung des Kommas hier mehrdeutig ist: kennzeichnet es zwei verschiedene Knoten im Parse-Baum oder einen einzelnen Knoten, der ein Tupel ist?

Python 3.0 macht dies eindeutig, indem das Komma durch das Wort „as“ ersetzt wird. Um eine Ausnahme abzufangen und das Ausnahmeobjekt in der Variablen exc zu speichern, müssen Sie schreiben

try:
    ...
except TypeError as exc:
    ...

Python 3.0 unterstützt nur die Verwendung von „as“ und interpretiert daher das erste Beispiel als das Abfangen zweier verschiedener Ausnahmen. Python 2.6 unterstützt sowohl das Komma als auch „as“, sodass bestehender Code weiterhin funktioniert. Wir empfehlen daher, „as“ zu verwenden, wenn neuer Python-Code geschrieben wird, der nur mit 2.6 ausgeführt werden soll.

Siehe auch

PEP 3110 - Ausnahmen in Python 3000 abfangen

PEP geschrieben und implementiert von Collin Winter.

PEP 3112: Byte-Literale

Python 3.0 übernimmt Unicode als grundlegenden Zeichentyp der Sprache und bezeichnet 8-Bit-Literale unterschiedlich, entweder als b'string' oder unter Verwendung eines Konstruktors bytes. Für zukünftige Kompatibilität fügt Python 2.6 bytes als Synonym für den Typ str hinzu und unterstützt auch die Notation b''.

Das 2.6 str unterscheidet sich in verschiedenen Punkten vom 3.0-Typ bytes; am bemerkenswertesten ist, dass der Konstruktor komplett anders ist. In 3.0 ist bytes([65, 66, 67]) 3 Elemente lang und enthält die Bytes, die ABC darstellen; in 2.6 gibt bytes([65, 66, 67]) die 12 Byte lange Zeichenfolge zurück, die die str() der Liste darstellt.

Die primäre Verwendung von bytes in 2.6 wird zum Testen von Objekttypen wie isinstance(x, bytes) dienen. Dies wird dem 2to3-Konverter helfen, der nicht erkennen kann, ob 2.x-Code Strings enthalten soll, die entweder Zeichen oder 8-Bit-Bytes sind; Sie können jetzt entweder bytes oder str verwenden, um Ihre Absicht genau auszudrücken, und der resultierende Code wird auch in Python 3.0 korrekt sein.

Es gibt auch einen __future__-Import, der dazu führt, dass alle Zeichenfolgenliterale Unicode-Zeichenfolgen werden. Das bedeutet, dass \u-Escape-Sequenzen verwendet werden können, um Unicode-Zeichen einzufügen

from __future__ import unicode_literals

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

print len(s)               # 12 Unicode characters

Auf C-Ebene wird Python 3.0 den vorhandenen 8-Bit-Zeichenfolgentyp, PyStringObject in Python 2.x genannt, in PyBytesObject umbenennen. Python 2.6 verwendet #define, um die Verwendung der Namen PyBytesObject(), PyBytes_Check(), PyBytes_FromStringAndSize() und aller anderen Funktionen und Makros, die mit Zeichenfolgen verwendet werden, zu unterstützen.

Instanzen des Typs bytes sind unveränderlich, genau wie Zeichenfolgen. Ein neuer Typ bytearray speichert eine veränderliche Sequenz von 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'

Byte-Arrays unterstützen die meisten Methoden von Zeichentypen, wie z.B. startswith()/endswith(), find()/rfind() und einige der Methoden von Listen, wie z.B. append(), pop() und reverse().

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

Es gibt auch eine entsprechende C-API mit PyByteArray_FromObject(), PyByteArray_FromStringAndSize() und verschiedenen anderen Funktionen.

Siehe auch

PEP 3112 - Byte-Literale in Python 3000

PEP geschrieben von Jason Orendorff; zurückportiert nach 2.6 von Christian Heimes.

PEP 3116: Neue I/O-Bibliothek

Die integrierten Dateiobjekte von Python unterstützen eine Reihe von Methoden, aber dateiähnliche Objekte unterstützen nicht unbedingt alle davon. Objekte, die Dateien nachahmen, unterstützen normalerweise read() und write(), aber sie unterstützen möglicherweise nicht readline(). Python 3.0 führt eine geschichtete I/O-Bibliothek im Modul io ein, die Pufferungs- und Textverarbeitungsfunktionen von den grundlegenden Lese- und Schreiboperationen trennt.

Es gibt drei Ebenen von abstrakten Basisklassen, die vom Modul io bereitgestellt werden

• RawIOBase definiert rohe I/O-Operationen: read(), readinto(), write(), seek(), tell(), truncate() und close(). Die meisten Methoden dieser Klasse werden oft einem einzigen Systemaufruf zugeordnet. Es gibt auch die Methoden readable(), writable() und seekable() zur Bestimmung, welche Operationen ein gegebenes Objekt zulässt.

  Python 3.0 verfügt über konkrete Implementierungen dieser Klasse für Dateien und Sockets, aber Python 2.6 hat seine Datei- und Socket-Objekte nicht auf diese Weise umstrukturiert.

• BufferedIOBase ist eine abstrakte Basisklasse, die Daten im Speicher puffert, um die Anzahl der verwendeten Systemaufrufe zu reduzieren und die I/O-Verarbeitung effizienter zu gestalten. Sie unterstützt alle Methoden von RawIOBase und fügt ein Attribut raw hinzu, das das zugrunde liegende Roh-Objekt enthält.

  Es gibt fünf konkrete Klassen, die diese ABC implementieren. BufferedWriter und BufferedReader sind für Objekte, die eine reine Schreib- oder Leseoperation unterstützen und eine seek()-Methode für zufälligen Zugriff haben. BufferedRandom-Objekte unterstützen Lese- und Schreibzugriff auf denselben zugrunde liegenden Stream, und BufferedRWPair ist für Objekte wie TTYs, die sowohl Lese- als auch Schreiboperationen auf nicht verbundenen Datenströmen ausführen. Die Klasse BytesIO unterstützt Lesen, Schreiben und Suchen in einem In-Memory-Puffer.

• TextIOBase: Bietet Funktionen zum Lesen und Schreiben von Zeichenfolgen (beachten Sie, dass Zeichenfolgen in Python 3.0 Unicode sein werden) und unterstützt universelle Zeilenumbrüche. TextIOBase definiert die Methode readline() und unterstützt die Iteration über Objekte.

  Es gibt zwei konkrete Implementierungen. TextIOWrapper umschließt ein gepuffertes I/O-Objekt und unterstützt alle Methoden für Text-I/O und fügt ein Attribut buffer für den Zugriff auf das zugrunde liegende Objekt hinzu. StringIO puffert einfach alles im Speicher, ohne jemals etwas auf die Festplatte zu schreiben.

  (In Python 2.6 ist io.StringIO in reinem Python implementiert, daher ist es ziemlich langsam. Sie sollten daher vorerst beim vorhandenen Modul StringIO oder cStringIO bleiben. Irgendwann wird das io-Modul von Python 3.0 für Geschwindigkeit in C neu geschrieben, und vielleicht wird die C-Implementierung in die 2.x-Releases zurückportiert.)

In Python 2.6 wurden die zugrunde liegenden Implementierungen nicht so umstrukturiert, dass sie auf den Klassen des io-Moduls aufbauen. Das Modul wird bereitgestellt, um das Schreiben von Code zu erleichtern, der zukunftssicher für 3.0 ist, und um Entwicklern die Mühe des Schreibens eigener Implementierungen für Pufferung und Text-I/O zu ersparen.

Siehe auch

PEP 3116 - Neues I/O

PEP geschrieben von Daniel Stutzbach, Mike Verdone und Guido van Rossum. Code von Guido van Rossum, Georg Brandl, Walter Doerwald, Jeremy Hylton, Martin von Löwis, Tony Lownds und anderen.

PEP 3118: Überarbeitetes Pufferprotokoll

Das Pufferprotokoll ist eine C-API, die es Python-Typen ermöglicht, Zeiger auf ihre internen Darstellungen auszutauschen. Eine speicherabgebildete Datei kann zum Beispiel als Puffer von Zeichen betrachtet werden, und dies ermöglicht es einem anderen Modul wie re, speicherabgebildete Dateien als Zeichenkette zu behandeln, die durchsucht werden soll.

Die Hauptnutzer des Pufferprotokolls sind numerische Verarbeitungspakete wie NumPy, die die interne Darstellung von Arrays offenlegen, damit Aufrufer Daten direkt in ein Array schreiben können, anstatt eine langsamere API zu verwenden. Dieses PEP aktualisiert das Pufferprotokoll angesichts der Erfahrungen aus der NumPy-Entwicklung und fügt eine Reihe neuer Funktionen hinzu, wie z.B. die Angabe der Form eines Arrays oder das Sperren eines Speicherbereichs.

Die wichtigste neue C-API-Funktion ist PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags), die ein Objekt und eine Reihe von Flags entgegennimmt und die Struktur Py_buffer mit Informationen über die Speicherrepräsentation des Objekts füllt. Objekte können diese Operation verwenden, um Speicher zu sperren, während ein externer Aufrufer den Inhalt ändern könnte. Es gibt daher eine entsprechende Funktion PyBuffer_Release(Py_buffer *view), um anzuzeigen, dass der externe Aufrufer fertig ist.

Das Argument flags für PyObject_GetBuffer() gibt Einschränkungen für den zurückgegebenen Speicher an. Einige Beispiele sind

• PyBUF_WRITABLE gibt an, dass der Speicher beschreibbar sein muss.

• PyBUF_LOCK fordert eine schreibgeschützte oder exklusive Sperre für den Speicher an.

• PyBUF_C_CONTIGUOUS und PyBUF_F_CONTIGUOUS fordern eine C-kontinuierliche (die letzte Dimension variiert am schnellsten) oder Fortran-kontinuierliche (die erste Dimension variiert am schnellsten) Array-Anordnung an.

Zwei neue Argumentcodes für PyArg_ParseTuple(), s* und z*, geben gesperrte Pufferobjekte für ein Argument zurück.

Siehe auch

PEP 3118 - Überarbeitung des Pufferprotokolls

PEP geschrieben von Travis Oliphant und Carl Banks; implementiert von Travis Oliphant.

PEP 3119: Abstrakte Basisklassen

Einige objektorientierte Sprachen wie Java unterstützen Schnittstellen, die deklarieren, dass eine Klasse eine gegebene Menge von Methoden hat oder ein gegebenes Zugriffsprotokoll unterstützt. Abstrakte Basisklassen (oder ABCs) sind ein äquivalentes Merkmal für Python. Die ABC-Unterstützung besteht aus einem Modul abc, das eine Metaklasse namens ABCMeta enthält, eine spezielle Behandlung dieser Metaklasse durch die integrierten Funktionen isinstance() und issubclass() und eine Sammlung grundlegender ABCs, die nach Meinung der Python-Entwickler weit verbreitet sein werden. Zukünftige Python-Versionen werden wahrscheinlich weitere ABCs hinzufügen.

Nehmen wir an, Sie haben eine bestimmte Klasse und möchten wissen, ob sie den Zugriff im Stil eines Wörterbuchs unterstützt. Die Formulierung "im Stil eines Wörterbuchs" ist jedoch vage. Wahrscheinlich bedeutet dies, dass der Zugriff auf Elemente mit obj[1] funktioniert. Bedeutet dies, dass das Setzen von Elementen mit obj[2] = value funktioniert? Oder dass das Objekt die Methoden keys(), values() und items() haben wird? Was ist mit den iterativen Varianten wie iterkeys()? copy`und :meth:()!update`? Die Iteration über das Objekt mit iter()?

Das Modul collections in Python 2.6 enthält eine Reihe verschiedener ABCs, die diese Unterscheidungen darstellen. Iterable gibt an, dass eine Klasse __iter__() definiert, und Container bedeutet, dass die Klasse eine Methode __contains__() definiert und daher Ausdrücke der Form x in y unterstützt. Die grundlegende Wörterbuchschnittstelle zum Abrufen von Elementen, zum Setzen von Elementen und für keys(), values() und items() wird durch die MutableMapping ABC definiert.

Sie können Ihre eigenen Klassen von einer bestimmten ABC ableiten, um anzuzeigen, dass sie die Schnittstelle dieser ABC unterstützen.

import collections

class Storage(collections.MutableMapping):
    ...

Alternativ könnten Sie die Klasse schreiben, ohne von der gewünschten ABC abzuleiten, und stattdessen die Klasse registrieren, indem Sie die Methode register() der ABC aufrufen.

import collections

class Storage:
    ...

collections.MutableMapping.register(Storage)

Für Klassen, die Sie selbst schreiben, ist die Ableitung von der ABC wahrscheinlich klarer. Die Methode register() ist nützlich, wenn Sie eine neue ABC geschrieben haben, die einen vorhandenen Typ oder eine vorhandene Klasse beschreiben kann, oder wenn Sie deklarieren möchten, dass eine Drittanbieterklasse eine ABC implementiert. Wenn Sie beispielsweise eine PrintableType ABC definieren, ist es legal,

# Register Python's types
PrintableType.register(int)
PrintableType.register(float)
PrintableType.register(str)

Klassen sollten die von einer ABC angegebenen Semantiken befolgen, aber Python kann dies nicht überprüfen; es liegt am Klassenautor, die Anforderungen der ABC zu verstehen und den Code entsprechend zu implementieren.

Um zu überprüfen, ob ein Objekt eine bestimmte Schnittstelle unterstützt, können Sie jetzt schreiben

def func(d):
    if not isinstance(d, collections.MutableMapping):
        raise ValueError("Mapping object expected, not %r" % d)

Sie müssen nicht das Gefühl haben, dass Sie jetzt viele Überprüfungen wie im obigen Beispiel schreiben müssen. Python hat eine starke Tradition des Duck-Typings, bei dem explizite Typüberprüfungen nie durchgeführt werden und Code einfach Methoden auf einem Objekt aufruft, in der Erwartung, dass diese Methoden vorhanden sein werden, und andernfalls eine Ausnahme auslöst. Seien Sie umsichtig bei der Überprüfung auf ABCs und tun Sie dies nur, wo es absolut notwendig ist.

Sie können Ihre eigenen ABCs schreiben, indem Sie abc.ABCMeta als Metaklasse in einer Klassendefinition verwenden.

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):
        ...

In der obigen Drawable ABC rendert die Methode draw_doubled() das Objekt mit doppelter Größe und kann auf Basis anderer in Drawable beschriebener Methoden implementiert werden. Klassen, die diese ABC implementieren, müssen daher keine eigene Implementierung von draw_doubled() bereitstellen, obwohl sie dies tun können. Eine Implementierung von draw() ist jedoch notwendig; die ABC kann keine nützliche generische Implementierung bereitstellen.

Sie können den Dekorator @~abc.abstractmethod auf Methoden wie draw() anwenden, die implementiert werden müssen; Python löst dann eine Ausnahme für Klassen aus, die die Methode nicht definieren. Beachten Sie, dass die Ausnahme nur ausgelöst wird, wenn Sie tatsächlich versuchen, eine Instanz einer Unterklasse zu erstellen, der die Methode fehlt.

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

Abstrakte Datenattribute können mit dem Dekorator @abstractproperty deklariert werden.

from abc import abstractproperty
...

@abstractproperty
def readonly(self):
   return self._x

Unterklassen müssen dann eine readonly Eigenschaft definieren.

Siehe auch

PEP 3119 - Einführung von Abstrakten Basisklassen

PEP geschrieben von Guido van Rossum und Talin. Implementiert von Guido van Rossum. Zurückportiert nach 2.6 von Benjamin Aranguren, mit Alex Martelli.

PEP 3127: Integer-Literal-Unterstützung und Syntax

Python 3.0 ändert die Syntax für Oktal-Integer-Literale (Basis 8), indem sie mit "0o" oder "0O" statt einer führenden Null präfixiert werden, und fügt Unterstützung für Binär-Integer-Literale (Basis 2) hinzu, die durch ein "0b" oder "0B" Präfix signalisiert werden.

Python 2.6 entfernt die Unterstützung für eine führende 0, die eine Oktalzahl signalisiert, nicht, aber es fügt Unterstützung für "0o" und "0b" hinzu.

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

Die eingebaute Funktion oct() gibt weiterhin Zahlen mit einem führenden Nullpräfix zurück, und eine neue eingebaute Funktion bin() gibt die Binärdarstellung einer Zahl zurück.

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

Die eingebauten Funktionen int() und long() akzeptieren nun die Präfixe "0o" und "0b", wenn die Basis 8 oder 2 angefordert wird, oder wenn das Argument base null ist (was signalisiert, dass die zu verwendende Basis aus dem String bestimmt werden soll).

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

Siehe auch

PEP 3127 - Integer Literal Support and Syntax

PEP geschrieben von Patrick Maupin; zurückportiert nach 2.6 von Eric Smith.

PEP 3129: Class-Dekoratoren

Dekoratoren wurden von Funktionen auf Klassen erweitert. Es ist nun legal, Folgendes zu schreiben:

@foo
@bar
class A:
  pass

Dies ist äquivalent zu

class A:
  pass

A = foo(bar(A))

Siehe auch

PEP 3129 - Class Decorators

PEP geschrieben von Collin Winter.

PEP 3141: Eine Typenhierarchie für Zahlen

Python 3.0 fügt mehrere abstrakte Basisklassen für numerische Typen hinzu, die von Schemes numerischem Turm inspiriert sind. Diese Klassen wurden als Modul numbers nach 2.6 zurückportiert.

Die allgemeinste ABC ist Number. Sie definiert keinerlei Operationen und existiert nur, um zu überprüfen, ob ein Objekt eine Zahl ist, indem isinstance(obj, Number) verwendet wird.

Complex ist eine Unterklasse von Number. Komplexe Zahlen können den grundlegenden Operationen Addition, Subtraktion, Multiplikation, Division und Potenzierung unterzogen werden, und Sie können den Real- und Imaginärteil abrufen und die Konjugierte einer Zahl erhalten. Pythons eingebaute komplexe Typ ist eine Implementierung von Complex.

Real leitet sich weiter von Complex ab und fügt Operationen hinzu, die nur für reelle Zahlen gelten: floor(), trunc(), Rundung, Rest modulo N, Ganzzahldivision und Vergleiche.

Rationale Zahlen leiten sich von Real ab, haben die Eigenschaften numerator und denominator und können in Fließkommazahlen umgewandelt werden. Python 2.6 fügt eine einfache rationale Zahlklasse, Fraction, im Modul fractions hinzu. (Sie heißt Fraction anstelle von Rational, um einen Namenskonflikt mit numbers.Rational zu vermeiden.)

Integral Zahlen leiten sich von Rational ab und können mit << und >> nach links und rechts verschoben, mit bitweisen Operationen wie & und | kombiniert und als Array-Indizes und Slice-Grenzen verwendet werden.

In Python 3.0 definiert die PEP leicht die bestehenden eingebauten Funktionen round(), math.floor(), math.ceil() und fügt eine neue hinzu, math.trunc(), die nach Python 2.6 zurückportiert wurde. math.trunc() rundet in Richtung Null und gibt die nächste Integral zurück, die zwischen dem Argument der Funktion und Null liegt.

Siehe auch

PEP 3141 - A Type Hierarchy for Numbers

PEP geschrieben von Jeffrey Yasskin.

Schemes numerischer Turm, aus dem Guile-Handbuch.

Schemes Zahl-Datentypen aus der R5RS Scheme-Spezifikation.

Das Modul fractions

Um die Hierarchie der numerischen Typen zu vervollständigen, bietet das Modul fractions eine rationale Zahlklasse. Rationale Zahlen speichern ihre Werte als Zähler und Nenner, die einen Bruch bilden, und können Zahlen wie 2/3 exakt darstellen, die Gleitkommazahlen nur annähern können.

Der Konstruktor Fraction nimmt zwei Integral Werte entgegen, die der Zähler und der Nenner des resultierenden Bruchs sein werden.

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

Zur Konvertierung von Gleitkommazahlen in rationale Zahlen verfügt der Gleitkommatyp nun über eine Methode as_integer_ratio(), die den Zähler und den Nenner für einen Bruch zurückgibt, der zum selben Gleitkommawert ausgewertet wird.

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

Beachten Sie, dass Werte, die von Gleitkommazahlen nur angenähert werden können, wie z. B. 1./3, nicht auf die approximierte Zahl vereinfacht werden; der Bruch versucht, den Gleitkommawert **exakt** abzugleichen.

Das Modul fractions basiert auf einer Implementierung von Sjoerd Mullender, die lange Zeit im Verzeichnis Demo/classes/ von Python vorhanden war. Diese Implementierung wurde von Jeffrey Yasskin erheblich aktualisiert.

Andere Sprachänderungen

Einige kleinere Änderungen am Kern der Python-Sprache sind:

• Verzeichnisse und ZIP-Archive, die eine Datei __main__.py enthalten, können nun direkt ausgeführt werden, indem ihr Name an den Interpreter übergeben wird. Das Verzeichnis oder das ZIP-Archiv wird automatisch als erster Eintrag in sys.path eingefügt. (Vorschlag und erster Patch von Andy Chu, anschließend überarbeitet von Phillip J. Eby und Nick Coghlan; bpo-1739468.)

• Die Funktion hasattr() fing alle Fehler ab und ignorierte sie, unter der Annahme, dass dies bedeutete, dass eine Methode __getattr__() irgendwie fehlschlug und der Rückgabewert von hasattr() daher False wäre. Diese Logik sollte jedoch nicht auf KeyboardInterrupt und SystemExit angewendet werden; Python 2.6 verwirft solche Ausnahmen nicht mehr, wenn hasattr() ihnen begegnet. (Behoben von Benjamin Peterson; bpo-2196.)

• Beim Aufruf einer Funktion mit der ** Syntax zur Bereitstellung von Schlüsselwortargumenten müssen Sie nicht mehr ein Python-Wörterbuch verwenden; jede Zuordnung ist nun zulässig.

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

  (Beigetragen von Alexander Belopolsky; bpo-1686487.)

  Es ist auch zulässig geworden, Schlüsselwortargumente nach einem *args Argument für einen Funktionsaufruf bereitzustellen.

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

  Zuvor wäre dies ein Syntaxfehler gewesen. (Beigetragen von Amaury Forgeot d’Arc; bpo-3473.)

• Eine neue eingebaute Funktion, next(iterator, [default]), gibt das nächste Element aus dem angegebenen Iterator zurück. Wenn das Argument default bereitgestellt wird, wird es zurückgegeben, wenn iterator erschöpft ist; andernfalls wird die Ausnahme StopIteration ausgelöst. (Zurückportiert in bpo-2719.)

• Tupel haben nun die Methoden index() und count(), die den Methoden index() und count() des Listentyps entsprechen.

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

  (Beigetragen von Raymond Hettinger)

• Die eingebauten Typen haben nun eine verbesserte Unterstützung für erweiterte Slice-Syntax, die verschiedene Kombinationen von (start, stop, step) akzeptiert. Zuvor war die Unterstützung teilweise und bestimmte Eckfälle funktionierten nicht. (Implementiert von Thomas Wouters.)

• Eigenschaften haben nun drei Attribute, getter, setter und deleter, die Dekoratoren sind und nützliche Abkürzungen für das Hinzufügen einer Getter-, Setter- oder Deleter-Funktion zu einer bestehenden Eigenschaft bieten. Sie würden sie wie folgt verwenden:

  class C(object):
      @property
      def x(self):
          return self._x
  
      @x.setter
      def x(self, value):
          self._x = value
  
      @x.deleter
      def x(self):
          del self._x
  
  class D(C):
      @C.x.getter
      def x(self):
          return self._x * 2
  
      @x.setter
      def x(self, value):
          self._x = value / 2
  

• Mehrere Methoden der eingebauten Set-Typen akzeptieren nun mehrere Iterables: intersection(), intersection_update(), union(), update(), difference() und difference_update().

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

  (Beigetragen von Raymond Hettinger.)

• Viele Gleitkommafunktionen wurden hinzugefügt. Die Funktion float() wandelt nun den String nan in einen IEEE 754 Not A Number-Wert um, und +inf und -inf in positive oder negative Unendlichkeit. Dies funktioniert auf jeder Plattform mit IEEE 754-Semantik. (Beigetragen von Christian Heimes; bpo-1635.)

  Andere Funktionen im Modul math, isinf() und isnan(), geben wahr zurück, wenn ihr Gleitkommaargument unendlich oder keine Zahl ist. (bpo-1640)

  Konvertierungsfunktionen wurden hinzugefügt, um Gleitkommazahlen in Hexadezimalstrings umzuwandeln (bpo-3008). Diese Funktionen konvertieren Floats in und aus einer Stringdarstellung, ohne Rundungsfehler bei der Konvertierung zwischen Dezimal und Binär einzuführen. Floats haben eine Methode hex(), die eine Stringdarstellung zurückgibt, und die Methode float.fromhex() konvertiert einen String zurück in eine Zahl.

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

• Eine numerische Feinheit: Beim Erstellen einer komplexen Zahl aus zwei Fließkommazahlen auf Systemen, die vorzeichenbehaftete Nullen (-0 und +0) unterstützen, behält der Konstruktor complex() nun das Vorzeichen der Null bei. (Behoben von Mark T. Dickinson; bpo-1507.)

• Klassen, die eine Methode __hash__() von einer Elternklasse erben, können __hash__ = None setzen, um anzuzeigen, dass die Klasse nicht hashbar ist. Dies bewirkt, dass hash(obj) eine TypeError auslöst und die Klasse nicht als Implementierer der Hashable ABC angezeigt wird.

  Dies sollten Sie tun, wenn Sie eine Methode __cmp__() oder __eq__() definiert haben, die Objekte nach ihrem Wert anstelle ihrer Identität vergleicht. Alle Objekte haben eine Standard-Hash-Methode, die id(obj) als Hash-Wert verwendet. Es gibt keine elegante Möglichkeit, die von einer Elternklasse geerbte Methode __hash__() zu entfernen, daher wurde die Zuweisung von None als Überschreibung implementiert. Auf C-Ebene können Erweiterungen tp_hash auf PyObject_HashNotImplemented() setzen. (Behoben von Nick Coghlan und Amaury Forgeot d’Arc; bpo-2235.)

• Die Ausnahme GeneratorExit erbt nun von BaseException anstelle von Exception. Das bedeutet, dass ein Ausnahmebehandler, der except Exception: verwendet, GeneratorExit nicht versehentlich abfängt. (Beigetragen von Chad Austin; bpo-1537.)

• Generatorobjekte haben nun ein Attribut gi_code, das sich auf das ursprüngliche Codeobjekt bezieht, das den Generator unterstützt. (Beigetragen von Collin Winter; bpo-1473257.)

• Die eingebaute Funktion compile() akzeptiert nun neben Positionsargumenten auch Schlüsselwortargumente. (Beigetragen von Thomas Wouters; bpo-1444529.)

• Der Konstruktor complex() akzeptiert nun Zeichenketten, die geklammerte komplexe Zahlen enthalten, was bedeutet, dass complex(repr(cplx)) nun Werte rundet. Zum Beispiel gibt complex('(3+4j)') nun den Wert (3+4j) zurück. (bpo-1491866)

• Die String-Methode translate() akzeptiert nun None als Übersetzungstabellenparameter, was als Identitätstransformation behandelt wird. Dies erleichtert das Löschen von Zeichen. (Beigetragen von Bengt Richter und implementiert von Raymond Hettinger; bpo-1193128.)

• Die eingebaute Funktion dir() prüft nun auf eine Methode __dir__() auf den Objekten, die sie erhält. Diese Methode muss eine Liste von Zeichenketten zurückgeben, die die Namen gültiger Attribute für das Objekt enthalten, und ermöglicht es dem Objekt, den Wert zu steuern, den dir() produziert. Objekte, die Methoden __getattr__() oder __getattribute__() haben, können dies verwenden, um Pseudo-Attribute anzukündigen, die sie honorieren werden. (bpo-1591665)

• Instanzmethodenobjekte haben neue Attribute für das Objekt und die Funktion, aus denen die Methode besteht; das neue Synonym für im_self ist __self__, und im_func ist ebenfalls als __func__ verfügbar. Die alten Namen werden in Python 2.6 noch unterstützt, sind aber in 3.0 nicht mehr vorhanden.

• Eine obskure Änderung: Wenn Sie die Funktion locals() innerhalb einer class-Anweisung verwenden, gibt das resultierende Wörterbuch keine freien Variablen mehr zurück. (Freie Variablen sind in diesem Fall Variablen, auf die in der class-Anweisung verwiesen wird, die aber keine Attribute der Klasse sind.)

Optimierungen

• Das Modul warnings wurde in C neu geschrieben. Dies ermöglicht die Auslösung von Warnungen durch den Parser und kann auch den Interpreter-Start beschleunigen. (Beigetragen von Neal Norwitz und Brett Cannon; bpo-1631171.)

• Typobjekte verfügen nun über einen Cache von Methoden, der den Aufwand für die Ermittlung der richtigen Methodenimplementierung für eine bestimmte Klasse reduzieren kann. Nach dem Caching muss der Interpreter nicht mehr Basisklassen durchlaufen, um die richtige aufzurufende Methode zu ermitteln. Der Cache wird gelöscht, wenn eine Basisklasse oder die Klasse selbst geändert wird, sodass der Cache auch angesichts der dynamischen Natur von Python korrekt bleibt. (Ursprüngliche Optimierung implementiert von Armin Rigo, aktualisiert für Python 2.6 von Kevin Jacobs; bpo-1700288.)

  Standardmäßig wird diese Änderung nur auf Typen angewendet, die im Python-Kern enthalten sind. Erweiterungsmodule sind möglicherweise nicht unbedingt mit diesem Cache kompatibel, daher müssen sie explizit Py_TPFLAGS_HAVE_VERSION_TAG in das Feld tp_flags des Moduls aufnehmen, um den Methoden-Cache zu aktivieren. (Um mit dem Methoden-Cache kompatibel zu sein, darf der Code des Erweiterungsmoduls nicht direkt auf das tp_dict-Mitglied eines der von ihm implementierten Typen zugreifen und es ändern. Die meisten Module tun dies nicht, aber es ist für den Python-Interpreter unmöglich, dies festzustellen. Siehe bpo-1878 für einige Diskussionen.)

• Funktionsaufrufe mit Schlüsselwortargumenten sind erheblich schneller, da ein schneller Pointer-Vergleich durchgeführt wird, was in der Regel die Zeit für einen vollständigen String-Vergleich spart. (Beigetragen von Raymond Hettinger, nach einer ersten Implementierung von Antoine Pitrou; bpo-1819.)

• Alle Funktionen im Modul struct wurden dank der Arbeit auf dem Need For Speed Sprint in C neu geschrieben. (Beigetragen von Raymond Hettinger.)

• Einige der Standard-eingebauten Typen setzen nun ein Bit in ihren Typobjekten. Dies beschleunigt die Überprüfung, ob ein Objekt eine Unterklasse eines dieser Typen ist. (Beigetragen von Neal Norwitz.)

• Unicode-Strings verwenden nun einen schnelleren Code zur Erkennung von Leerzeichen und Zeilenumbrüchen; dies beschleunigt die Methode split() um etwa 25 % und splitlines() um 35 %. (Beigetragen von Antoine Pitrou.) Der Speicherverbrauch wird durch die Verwendung von pymalloc für die Daten des Unicode-Strings reduziert.

• Die with-Anweisung speichert nun die Methode __exit__() auf dem Stack, was zu einer kleinen Geschwindigkeitssteigerung führt. (Implementiert von Jeffrey Yasskin.)

• Um den Speicherverbrauch zu reduzieren, löscht der Garbage Collector nun interne Freilisten, wenn die höchste Generation von Objekten gesammelt wird. Dies kann Speicher früher an das Betriebssystem zurückgeben.

Interpreter-Änderungen

Zwei Kommandozeilenoptionen wurden für die Verwendung durch andere Python-Implementierungen reserviert. Der Schalter -J wurde für Jython für Jython-spezifische Optionen reserviert, wie z. B. Schalter, die an die zugrunde liegende JVM übergeben werden. -X wurde für Optionen reserviert, die für eine bestimmte Implementierung von Python wie CPython, Jython oder IronPython spezifisch sind. Wenn eine der Optionen mit Python 2.6 verwendet wird, meldet der Interpreter, dass die Option derzeit nicht verwendet wird.

Python kann nun daran gehindert werden, .pyc- oder .pyo-Dateien zu schreiben, indem der Schalter -B an den Python-Interpreter übergeben wird, oder indem die Umgebungsvariable PYTHONDONTWRITEBYTECODE gesetzt wird, bevor der Interpreter ausgeführt wird. Diese Einstellung ist für Python-Programme als Variable sys.dont_write_bytecode verfügbar, und Python-Code kann den Wert ändern, um das Verhalten des Interpreters zu modifizieren. (Beigetragen von Neal Norwitz und Georg Brandl.)

Die für Standardeingabe, -ausgabe und -fehlerausgabe verwendete Kodierung kann durch Setzen der Umgebungsvariable PYTHONIOENCODING vor der Ausführung des Interpreters festgelegt werden. Der Wert sollte eine Zeichenkette im Format <encoding> oder <encoding>:<errorhandler> sein. Der Teil encoding gibt den Namen der Kodierung an, z. B. utf-8 oder latin-1; der optionale Teil errorhandler gibt an, was mit Zeichen geschehen soll, die von der Kodierung nicht behandelt werden können, und sollte einer von "error", "ignore" oder "replace" sein. (Beigetragen von Martin von Löwis.)

Neue und verbesserte Module

Wie in jeder Veröffentlichung hat die Standardbibliothek von Python eine Reihe von Verbesserungen und Fehlerkorrekturen erhalten. Hier ist eine Teilliste der bemerkenswertesten Änderungen, alphabetisch nach Modulnamen sortiert. Konsultieren Sie die Datei Misc/NEWS im Quellbaum für eine vollständigere Liste der Änderungen oder durchsuchen Sie die Subversion-Logs nach allen Details.

• Die Module asyncore und asynchat werden wieder aktiv gepflegt und es wurden eine Reihe von Patches und Fehlerkorrekturen angewendet. (Gepflegt von Josiah Carlson; siehe bpo-1736190 für einen Patch.)

• Das Modul bsddb hat ebenfalls einen neuen Betreuer, Jesús Cea Avión, und das Paket ist nun als eigenständiges Paket verfügbar. Die Webseite für das Paket ist www.jcea.es/programacion/pybsddb.htm. Geplant ist, das Paket ab Python 3.0 aus der Standardbibliothek zu entfernen, da seine Veröffentlichungsrate viel häufiger ist als die von Python.

  Das Modul bsddb.dbshelve verwendet nun das höchste verfügbare Pickling-Protokoll anstelle der Beschränkung auf Protokoll 1. (Beigesteuert von W. Barnes.)

• Das Modul cgi liest nun Variablen aus der Query-String einer HTTP POST-Anfrage. Dies ermöglicht die Verwendung von Formularaktionen mit URLs, die Query-Strings enthalten, wie z. B. „/cgi-bin/add.py?category=1“. (Beigesteuert von Alexandre Fiori und Nubis; bpo-1817.)

  Die Funktionen parse_qs() und parse_qsl() wurden aus dem Modul cgi in das Modul urlparse verschoben. Die im Modul cgi noch verfügbaren Versionen lösen in 2.6 PendingDeprecationWarning-Meldungen aus (bpo-600362).

• Das Modul cmath wurde umfassend überarbeitet, beigesteuert von Mark Dickinson und Christian Heimes. Fünf neue Funktionen wurden hinzugefügt

  • polar() konvertiert eine komplexe Zahl in Polarkoordinaten und gibt den Betrag und das Argument der komplexen Zahl zurück.

  • rect() tut das Gegenteil und wandelt ein Paar aus Betrag und Argument zurück in die entsprechende komplexe Zahl um.

  • phase() gibt das Argument (auch Winkel genannt) einer komplexen Zahl zurück.

  • isnan() gibt True zurück, wenn der reale oder imaginäre Teil seines Arguments NaN ist.

  • isinf() gibt True zurück, wenn der reale oder imaginäre Teil seines Arguments unendlich ist.

  Die Überarbeitungen verbesserten auch die numerische Stabilität des Moduls cmath. Bei allen Funktionen sind die reellen und imaginären Teile der Ergebnisse, wann immer möglich, bis auf wenige Einheiten der kleinsten Genauigkeit (ulps) genau. Details finden Sie unter bpo-1381. Die Schnittgrenzen für asinh(), atanh(): und atan() wurden ebenfalls korrigiert.

  Die Tests für das Modul wurden stark erweitert; fast 2000 neue Testfälle testen die algebraischen Funktionen.

  Auf IEEE 754-Plattformen behandelt das Modul cmath nun IEEE 754-Spezialwerte und Gleitkomma-Ausnahmen konsistent mit Anhang G des C99-Standards.

• Ein neuer Datentyp im Modul collections: namedtuple(typename, fieldnames) ist eine Fabrikfunktion, die Unterklassen des Standard-Tuples erstellt, deren Felder sowohl nach Namen als auch nach Index zugänglich sind. Zum Beispiel

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

  Mehrere Stellen in der Standardbibliothek, die Tupel zurückgaben, wurden so geändert, dass sie Instanzen von namedtuple() zurückgeben. Zum Beispiel gibt die Methode Decimal.as_tuple() nun ein benanntes Tupel mit den Feldern sign, digits und exponent zurück.

  (Beigetragen von Raymond Hettinger.)

• Eine weitere Änderung am Modul collections ist, dass der Typ deque nun einen optionalen Parameter maxlen unterstützt; wenn dieser angegeben ist, wird die Größe der deque auf höchstens maxlen Elemente beschränkt. Das Hinzufügen weiterer Elemente zu einer vollen deque führt zum Verwerfen alter Elemente.

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

  (Beigetragen von Raymond Hettinger.)

• Die Morsel-Objekte des Moduls Cookie unterstützen nun ein Attribut httponly. In einigen Browsern können Cookies mit diesem gesetzten Attribut nicht von JavaScript-Code aufgerufen oder manipuliert werden. (Beigesteuert von Arvin Schnell; bpo-1638033.)

• Eine neue Fenster-Methode im Modul curses, chgat(), ändert die Anzeigeattribute für eine bestimmte Anzahl von Zeichen in einer einzelnen Zeile. (Beigesteuert von Fabian Kreutz.)

  # Boldface text starting at y=0,x=21
  # and affecting the rest of the line.
  stdscr.chgat(0, 21, curses.A_BOLD)
  

  Die Klasse Textbox im Modul curses.textpad unterstützt nun sowohl die Bearbeitung im Einfügemodus als auch im Überschreibmodus. Der Einfügemodus wird aktiviert, indem ein wahrer Wert für den Parameter insert_mode beim Erstellen der Textbox-Instanz übergeben wird.

• Die strftime()-Methoden des Moduls datetime unterstützen nun einen Formatcode %f, der sich zur Anzahl der Mikrosekunden im Objekt erweitert, links auf sechs Stellen mit Nullen aufgefüllt. (Beigesteuert von Skip Montanaro; bpo-1158.)

• Das Modul decimal wurde auf Version 1.66 der General Decimal Specification aktualisiert. Neue Funktionen umfassen einige Methoden für grundlegende mathematische Funktionen wie exp() und log10()

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

  Die Methode as_tuple() von Decimal-Objekten gibt nun ein benanntes Tupel mit den Feldern sign, digits und exponent zurück.

  (Implementiert von Facundo Batista und Mark Dickinson. Unterstützung für benannte Tupel hinzugefügt von Raymond Hettinger.)

• Die Klasse SequenceMatcher des Moduls difflib gibt nun benannte Tupel zurück, die Übereinstimmungen darstellen, mit den Attributen a, b und size. (Beigesteuert von Raymond Hettinger.)

• Ein optionaler Parameter timeout, der ein Timeout in Sekunden angibt, wurde zum Konstruktor der Klasse ftplib.FTP sowie zur Methode connect() hinzugefügt. (Hinzugefügt von Facundo Batista.) Außerdem nehmen die Methoden storbinary() und storlines() der Klasse FTP nun einen optionalen Parameter callback entgegen, der nach dem Senden jedes Datenblocks mit den Daten aufgerufen wird. (Beigesteuert von Phil Schwartz; bpo-1221598.)

• Die eingebaute Funktion reduce() ist auch im Modul functools verfügbar. In Python 3.0 wird die eingebaute Funktion entfernt und reduce() ist nur noch aus functools verfügbar; derzeit gibt es keine Pläne, die eingebaute Funktion in der 2.x-Reihe zu entfernen. (Gepatcht von Christian Heimes; bpo-1739906.)

• Wenn möglich, verwendet das Modul getpass nun /dev/tty, um eine Eingabeaufforderung auszugeben und das Passwort zu lesen, und greift bei Bedarf auf Standardfehler und Standardeingabe zurück. Wenn das Passwort möglicherweise auf das Terminal ausgegeben wird, wird vor der Anzeige der Eingabeaufforderung eine Warnung ausgegeben. (Beigesteuert von Gregory P. Smith.)

• Die Funktion glob.glob() kann nun Unicode-Dateinamen zurückgeben, wenn ein Unicode-Pfad verwendet wurde und Unicode-Dateinamen im Verzeichnis übereinstimmen. (bpo-1001604)

• Eine neue Funktion im Modul heapq, merge(iter1, iter2, ...), nimmt beliebige Iterables entgegen, die Daten in sortierter Reihenfolge zurückgeben, und gibt einen neuen Generator zurück, der die Inhalte aller Iteratoren ebenfalls in sortierter Reihenfolge zurückgibt. Zum Beispiel

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

  Eine weitere neue Funktion, heappushpop(heap, item), fügt item in heap ein und zieht dann das kleinste Element heraus und gibt es zurück. Dies ist effizienter, als heappush() und dann heappop() aufzurufen.

  heapq ist nun so implementiert, dass nur die Kleiner-als-Vergleichung verwendet wird, anstatt der Kleiner-als-oder-gleich-Vergleichung, die zuvor verwendet wurde. Dies entspricht der Verwendung von heapq mit dem Typ list.sort(). (Beigesteuert von Raymond Hettinger.)

• Ein optionaler Parameter timeout, der ein Timeout in Sekunden angibt, wurde zu den Konstruktoren der Klassen httplib.HTTPConnection und HTTPSConnection hinzugefügt. (Hinzugefügt von Facundo Batista.)

• Die meisten Funktionen des Moduls inspect, wie z. B. getmoduleinfo() und getargs(), geben nun benannte Tupel zurück. Zusätzlich zu ihrer Funktionalität als Tupel können die Elemente des Rückgabewerts auch als Attribute abgerufen werden. (Beigesteuert von Raymond Hettinger.)

  Einige neue Funktionen in dem Modul sind isgenerator(), isgeneratorfunction() und isabstract().

• Das Modul itertools hat mehrere neue Funktionen erhalten.

  izip_longest(iter1, iter2, ...[, fillvalue]) erstellt Tupel aus jedem der Elemente; wenn einige der Iterables kürzer sind als andere, werden die fehlenden Werte auf fillvalue gesetzt. Zum Beispiel

  >>> 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]) gibt das kartesische Produkt der übergebenen Iterables zurück, eine Menge von Tupeln, die jede mögliche Kombination der von jedem Iterable zurückgegebenen Elemente enthält.

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

  Das optionale Schlüsselwortargument repeat wird verwendet, um das Produkt eines Iterables oder einer Menge von Iterables mit sich selbst zu nehmen, wobei es N Mal wiederholt wird. Bei einem einzelnen Iterable-Argument werden N-Tupel zurückgegeben

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

  Bei zwei Iterables werden 2N-Tupel zurückgegeben.

  >>> 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) gibt Untersequenzen der Länge r aus den Elementen von iterable zurück.

  >>> 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]) gibt alle Permutationen der Länge r der Elemente des Iterables zurück. Wenn r nicht angegeben ist, wird es standardmäßig auf die Anzahl der vom Iterable erzeugten Elemente gesetzt.

  >>> 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) ist eine bestehende Funktion in itertools, die in Python 2.6 einen neuen Konstruktor erhalten hat. itertools.chain.from_iterable(iterable) nimmt ein einzelnes Iterable entgegen, das andere Iterables zurückgeben soll. chain() gibt dann alle Elemente des ersten Iterables zurück, dann alle Elemente des zweiten und so weiter.

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

  (Alles beigesteuert von Raymond Hettinger.)

• Die Klasse FileHandler des Moduls logging und ihre Unterklassen WatchedFileHandler, RotatingFileHandler und TimedRotatingFileHandler haben nun einen optionalen Parameter delay für ihre Konstruktoren. Wenn delay true ist, wird die Eröffnung der Protokolldatei bis zum ersten Aufruf von emit() verzögert. (Beigesteuert von Vinay Sajip.)

  TimedRotatingFileHandler hat auch einen utc-Konstruktorparameter. Wenn das Argument true ist, wird die UTC-Zeit verwendet, um zu bestimmen, wann Mitternacht eintritt, und um Dateinamen zu generieren; andernfalls wird die lokale Zeit verwendet.

• Mehrere neue Funktionen wurden zum Modul math hinzugefügt

  • isinf() und isnan() ermitteln, ob eine gegebene Fließkommazahl eine (positive oder negative) Unendlichkeit bzw. eine NaN (Not a Number) ist.

  • copysign() kopiert das Vorzeichenbit einer IEEE 754-Zahl und gibt den Absolutwert von x kombiniert mit dem Vorzeichenbit von y zurück. Zum Beispiel gibt math.copysign(1, -0.0) -1.0 zurück. (Beigesteuert von Christian Heimes.)

  • factorial() berechnet die Fakultät einer Zahl. (Beigesteuert von Raymond Hettinger; bpo-2138.)

  • fsum() summiert den Strom von Zahlen aus einem Iterable und achtet darauf, Präzisionsverluste durch die Verwendung von Teilsammen zu vermeiden. (Beigesteuert von Jean Brouwers, Raymond Hettinger und Mark Dickinson; bpo-2819.)

  • acosh(), asinh() und atanh() berechnen die inversen hyperbolischen Funktionen.

  • log1p() gibt den natürlichen Logarithmus von 1+x (Basis e) zurück.

  • trunc() rundet eine Zahl in Richtung Null und gibt die nächstgelegene Integral zurück, die zwischen dem Argument der Funktion und Null liegt. Hinzugefügt als Teil des Backports der PEP 3141 Typenhierarchie für Zahlen.

• Das Modul math wurde verbessert, um ein konsistenteres Verhalten auf verschiedenen Plattformen zu erzielen, insbesondere im Hinblick auf die Behandlung von Gleitkomma-Ausnahmen und IEEE 754-Spezialwerten.

  Wenn möglich, folgt das Modul den Empfehlungen des C99-Standards für die Spezialwerte von 754. Zum Beispiel sollte sqrt(-1.) nun auf fast allen Plattformen einen ValueError ergeben, während sqrt(float('NaN')) auf allen IEEE 754-Plattformen ein NaN zurückgeben sollte. Wo Anhang F des C99-Standards die Signalgebung von „divide-by-zero“ oder „invalid“ empfiehlt, wird Python ValueError auslösen. Wo Anhang F des C99-Standards die Signalgebung von „overflow“ empfiehlt, wird Python OverflowError auslösen. (Siehe bpo-711019 und bpo-1640.)

  (Beigesteuert von Christian Heimes und Mark Dickinson.)

• mmap-Objekte verfügen nun über eine Methode rfind(), die nach einer Teilzeichenkette sucht, beginnend am Ende der Zeichenkette und rückwärts suchend. Die Methode find() hat ebenfalls einen Parameter end erhalten, der einen Index angibt, an dem die Suche gestoppt werden soll. (Beigesteuert von John Lenton.)

• Das Modul operator hat die Funktion methodcaller() erhalten, die einen Namen und eine optionale Menge von Argumenten entgegennimmt und einen aufrufbaren Wert zurückgibt, der die benannte Funktion für alle übergebenen Argumente aufruft. Zum Beispiel

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

  (Beigesteuert von Georg Brandl, nach einem Vorschlag von Gregory Petrosyan.)

  Die Funktion attrgetter() akzeptiert nun gepunktete Namen und führt die entsprechenden Attribut-Lookups durch

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

  (Beigesteuert von Georg Brandl, nach einem Vorschlag von Barry Warsaw.)

• Das Modul os wickelt nun mehrere neue Systemaufrufe ab. fchmod(fd, mode) und fchown(fd, uid, gid) ändern den Modus und die Eigentümerschaft einer geöffneten Datei, und lchmod(path, mode) ändert den Modus eines Symlinks. (Beigesteuert von Georg Brandl und Christian Heimes.)

  chflags() und lchflags() sind Wrapper für die entsprechenden Systemaufrufe (sofern verfügbar) und ändern die gesetzten Flags einer Datei. Konstanten für die Flag-Werte sind im Modul stat definiert; einige mögliche Werte sind UF_IMMUTABLE, um anzuzeigen, dass die Datei nicht geändert werden kann, und UF_APPEND, um anzuzeigen, dass nur an die Datei angehängt werden kann. (Beigesteuert von M. Levinson.)

  os.closerange(low, high) schließt effizient alle Dateideskriptoren von low bis high, ignoriert dabei alle Fehler und schließt high selbst nicht ein. Diese Funktion wird nun vom Modul subprocess verwendet, um das Starten von Prozessen zu beschleunigen. (Beigesteuert von Georg Brandl; bpo-1663329.)

• Die Methode clear() des Objekts os.environ unsettet nun die Umgebungsvariablen mithilfe von os.unsetenv() zusätzlich zum Leeren der Schlüssel des Objekts. (Beigesteuert von Martin Horcicka; bpo-1181.)

• Die Funktion os.walk() hat nun einen Parameter followlinks. Wenn dieser auf True gesetzt ist, folgt die Funktion Symlinks, die auf Verzeichnisse zeigen, und besucht den Inhalt des Verzeichnisses. Aus Gründen der Abwärtskompatibilität ist der Standardwert des Parameters false. Beachten Sie, dass die Funktion in eine unendliche Rekursion geraten kann, wenn ein Symlink auf ein übergeordnetes Verzeichnis zeigt. (bpo-1273829)

• Im Modul os.path wurde die Funktion splitext() so geändert, dass sie nicht auf führende Punktzeichen aufteilt. Dies liefert bessere Ergebnisse bei der Arbeit mit Unix-Dot-Files. Zum Beispiel gibt os.path.splitext('.ipython') nun ('.ipython', '') anstelle von ('', '.ipython') zurück. (bpo-1115886)

  Eine neue Funktion, os.path.relpath(path, start='.'), gibt einen relativen Pfad vom start-Pfad, falls vorhanden, oder vom aktuellen Arbeitsverzeichnis zum Ziel path zurück. (Beigesteuert von Richard Barran; bpo-1339796.)

  Unter Windows erweitert os.path.expandvars() nun Umgebungsvariablen in der Form „%var%“ und „~user“ wird in den Home-Verzeichnispfad des Benutzers erweitert. (Beigesteuert von Josiah Carlson; bpo-957650.)

• Der von dem Modul pdb bereitgestellte Python-Debugger hat einen neuen Befehl erhalten: „run“ startet das zu debuggende Python-Programm neu und kann optional neue Kommandozeilenargumente für das Programm entgegennehmen. (Beigesteuert von Rocky Bernstein; bpo-1393667.)

• Die Funktion pdb.post_mortem(), die zum Starten des Debuggings eines Tracebacks verwendet wird, verwendet nun den von sys.exc_info() zurückgegebenen Traceback, wenn kein Traceback übergeben wird. (Beigesteuert von Facundo Batista; bpo-1106316.)

• Das Modul pickletools hat nun eine Funktion optimize(), die eine Zeichenkette mit einem Pickle entgegennimmt und einige ungenutzte Opcodes entfernt, und ein kürzeres Pickle zurückgibt, das dieselbe Datenstruktur enthält. (Beigesteuert von Raymond Hettinger.)

• Eine Funktion get_data() wurde dem Modul pkgutil hinzugefügt, die den Inhalt von Ressourcendateien zurückgibt, die mit einem installierten Python-Paket enthalten sind. Zum Beispiel

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

  (Beigesteuert von Paul Moore; bpo-2439.)

• Die Parser-Objekte des Moduls pyexpat erlauben nun das Setzen ihres Attributs buffer_size, um die Größe des Puffers zu ändern, der zur Speicherung von Zeichendaten verwendet wird. (Beigesteuert von Achim Gaedke; bpo-1137.)

• Das Modul Queue bietet nun Queue-Varianten an, die Einträge in unterschiedlicher Reihenfolge abrufen. Die Klasse PriorityQueue speichert engeboarde Elemente in einem Heap und ruft sie in Prioritätsreihenfolge ab, und LifoQueue ruft die zuletzt hinzugefügten Einträge zuerst ab, was bedeutet, dass sie sich wie ein Stack verhält. (Beigesteuert von Raymond Hettinger.)

• Objekte vom Typ Random des Moduls random können nun auf einem 32-Bit-System gespeichert und auf einem 64-Bit-System geladen werden und umgekehrt. Leider bedeutet diese Änderung auch, dass Random-Objekte aus Python 2.6 nicht korrekt auf früheren Python-Versionen geladen werden können. (Beigetragen von Shawn Ligocki; bpo-1727780.)

  Die neue Funktion triangular(low, high, mode) gibt Zufallszahlen zurück, die einer Dreiecksverteilung folgen. Die zurückgegebenen Werte liegen zwischen low und high, wobei high nicht eingeschlossen ist, und mode ist der am häufigsten vorkommende Wert in der Verteilung. (Beigetragen von Wladmir van der Laan und Raymond Hettinger; bpo-1681432.)

• Lange Suchen mit regulären Ausdrücken, die vom Modul re durchgeführt werden, prüfen nun auf empfangene Signale, sodass zeitaufwendige Suchen unterbrochen werden können. (Beigetragen von Josh Hoyt und Ralf Schmitt; bpo-846388.)

  Das Modul für reguläre Ausdrücke wird durch Kompilierung von Bytecodes für eine kleine, auf reguläre Ausdrücke spezialisierte virtuelle Maschine implementiert. Nicht vertrauenswürdiger Code könnte direkt bösartige Bytecode-Strings erzeugen und Abstürze verursachen, daher enthält Python 2.6 einen Verifizierer für den Regex-Bytecode. (Beigetragen von Guido van Rossum aus der Arbeit für Google App Engine; bpo-3487.)

• Die Methode Completer.complete() des Moduls rlcompleter ignoriert nun Ausnahmen, die bei der Auswertung eines Namens ausgelöst werden. (Behoben von Lorenz Quack; bpo-2250.)

• Instanzen von scheduler aus dem Modul sched verfügen nun über ein schreibgeschütztes Attribut queue, das den Inhalt der Scheduler-Warteschlange zurückgibt, dargestellt als Liste von benannten Tupeln mit den Feldern (time, priority, action, argument). (Beigetragen von Raymond Hettinger; bpo-1861.)

• Das Modul select verfügt nun über Wrapper-Funktionen für die Linux-Systemaufrufe epoll() und BSD kqueue(). Die Methode modify() wurde den vorhandenen poll-Objekten hinzugefügt; pollobj.modify(fd, eventmask) nimmt einen Dateideskriptor oder ein Datei-Objekt und eine Ereignismaske entgegen und modifiziert die aufgezeichnete Ereignismaske für diese Datei. (Beigetragen von Christian Heimes; bpo-1657.)

• Die Funktion shutil.copytree() verfügt nun über ein optionales Argument ignore, das ein aufrufbares Objekt entgegennimmt. Dieses aufrufbare Objekt erhält jeden Verzeichnispfad und eine Liste des Verzeichnisinhalts und gibt eine Liste von Namen zurück, die ignoriert und nicht kopiert werden.

  Das Modul shutil bietet auch die Funktion ignore_patterns() zur Verwendung mit diesem neuen Parameter. ignore_patterns() nimmt eine beliebige Anzahl von Mustern im Glob-Stil entgegen und gibt ein aufrufbares Objekt zurück, das alle Dateien und Verzeichnisse ignoriert, die mit einem dieser Muster übereinstimmen. Das folgende Beispiel kopiert einen Verzeichnisbaum, überspringt aber sowohl .svn-Verzeichnisse als auch Emacs-Backup-Dateien, deren Namen mit „~“ enden.

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

  (Beigetragen von Tarek Ziadé; bpo-2663.)

• Die Integration der Signalbehandlung mit GUI-Handling-Ereignisschleifen wie denen, die von Tkinter oder GTk+ verwendet werden, war lange ein Problem; die meiste Software pollt und wacht jede Bruchteil einer Sekunde auf, um zu prüfen, ob GUI-Ereignisse aufgetreten sind. Das Modul signal kann dies nun effizienter gestalten. Der Aufruf von signal.set_wakeup_fd(fd) setzt einen Dateideskriptor zur Verwendung; wenn ein Signal empfangen wird, wird ein Byte in diesen Dateideskriptor geschrieben. Es gibt auch eine C-Funktion, PySignal_SetWakeupFd(), zum Setzen des Deskriptors.

  Ereignisschleifen verwenden dies, indem sie eine Pipe öffnen, um zwei Deskriptoren zu erstellen, einen zum Lesen und einen zum Schreiben. Der schreibbare Deskriptor wird an set_wakeup_fd() übergeben, und der lesbare Deskriptor wird zur Liste der Deskriptoren hinzugefügt, die von der Ereignisschleife über select() oder poll() überwacht werden. Beim Empfang eines Signals wird ein Byte geschrieben und die Haupt-Ereignisschleife geweckt, wodurch ein Polling überflüssig wird.

  (Beigetragen von Adam Olsen; bpo-1583.)

  Die Funktion siginterrupt() ist nun aus Python-Code verfügbar und ermöglicht die Änderung, ob Signale Systemaufrufe unterbrechen können oder nicht. (Beigetragen von Ralf Schmitt.)

  Die Funktionen setitimer() und getitimer() wurden ebenfalls hinzugefügt (wo verfügbar). setitimer() ermöglicht das Setzen von Intervall-Timern, die nach einer bestimmten Zeit ein Signal an den Prozess senden, gemessen in Echtzeit, verbrauchter Prozesszeit oder kombinierter Prozess- und Systemzeit. (Beigetragen von Guilherme Polo; bpo-2240.)

• Das Modul smtplib unterstützt nun SMTP über SSL dank der Hinzufügung der Klasse SMTP_SSL. Diese Klasse hat eine Schnittstelle, die identisch mit der vorhandenen Klasse SMTP ist. (Beigetragen von Monty Taylor.) Beide Konstruktoren der Klassen verfügen außerdem über einen optionalen Parameter timeout, der ein Timeout für den ersten Verbindungsversuch in Sekunden angibt. (Beigetragen von Facundo Batista.)

  Eine Implementierung des LMTP-Protokolls (RFC 2033) wurde ebenfalls dem Modul hinzugefügt. LMTP wird anstelle von SMTP beim Übertragen von E-Mails zwischen Agenten verwendet, die keine Mail-Warteschlange verwalten. (LMTP implementiert von Leif Hedstrom; bpo-957003.)

  SMTP.starttls() entspricht nun RFC 3207 und vergisst alle Kenntnisse, die vom Server erhalten wurden und nicht aus der TLS-Verhandlung selbst stammen. (Patch beigetragen von Bill Fenner; bpo-829951.)

• Das Modul socket unterstützt nun TIPC (https://tipc.sourceforge.net/), ein hochperformantes, nicht IP-basiertes Protokoll, das für den Einsatz in Cluster-Umgebungen entwickelt wurde. TIPC-Adressen sind 4- oder 5-Tupel. (Beigetragen von Alberto Bertogli; bpo-1646.)

  Die neue Funktion create_connection() nimmt eine Adresse entgegen, verbindet sich mit ihr unter Verwendung eines optionalen Zeitlimits und gibt das verbundene Socket-Objekt zurück. Diese Funktion ermittelt auch den Typ der Adresse und verbindet sich entsprechend mit IPv4 oder IPv6. Die Umstellung Ihres Codes auf die Verwendung von create_connection() anstelle von socket(socket.AF_INET, ...) könnte ausreichen, damit Ihr Code mit IPv6 funktioniert.

• Die Basisklassen im Modul SocketServer unterstützen nun den Aufruf einer Methode handle_timeout() nach einer Inaktivitätsperiode, die durch das Attribut timeout des Servers angegeben wird. (Beigetragen von Michael Pomraning.) Die Methode serve_forever() nimmt nun ein optionales Polling-Intervall in Sekunden entgegen, das steuert, wie oft der Server auf eine Herunterfahr-Anfrage prüft. (Beigetragen von Pedro Werneck und Jeffrey Yasskin; bpo-742598, bpo-1193577.)

• Das Modul sqlite3, gepflegt von Gerhard Häring, wurde von Version 2.3.2 in Python 2.5 auf Version 2.4.1 aktualisiert.

• Das Modul struct unterstützt nun den C99-Typ _Bool mit dem Formatzeichen '?'. (Beigetragen von David Remahl.)

• Die Objekte vom Typ Popen aus dem Modul subprocess verfügen nun über die Methoden terminate(), kill() und send_signal(). Unter Windows unterstützt send_signal() nur das Signal SIGTERM, und alle diese Methoden sind Aliase für die Win32-API-Funktion TerminateProcess(). (Beigetragen von Christian Heimes.)

• Eine neue Variable im Modul sys, float_info, ist ein Objekt, das Informationen aus der Datei float.h über die Gleitkommaunterstützung der Plattform enthält. Attribute dieses Objekts sind mant_dig (Anzahl der Ziffern im Mantisse), epsilon (kleinster Unterschied zwischen 1,0 und dem nächstgrößeren darstellbaren Wert) und einige andere. (Beigetragen von Christian Heimes; bpo-1534.)

  Eine weitere neue Variable, dont_write_bytecode, steuert, ob Python beim Importieren eines Moduls .pyc- oder .pyo-Dateien schreibt. Wenn diese Variable wahr ist, werden die kompilierten Dateien nicht geschrieben. Die Variable wird beim Start initialisiert, indem der Schalter -B an den Python-Interpreter übergeben wird, oder indem die Umgebungsvariable PYTHONDONTWRITEBYTECODE gesetzt wird, bevor der Interpreter ausgeführt wird. Python-Code kann den Wert dieser Variablen anschließend ändern, um zu steuern, ob Bytecode-Dateien geschrieben werden. (Beigetragen von Neal Norwitz und Georg Brandl.)

  Informationen über die an den Python-Interpreter übergebenen Befehlszeilenargumente sind durch Lesen der Attribute eines benannten Tupels verfügbar, das als sys.flags verfügbar ist. Zum Beispiel ist das Attribut verbose wahr, wenn Python im ausführlichen Modus ausgeführt wurde, debug ist im Debug-Modus wahr, usw. Diese Attribute sind alle schreibgeschützt. (Beigetragen von Christian Heimes.)

  Eine neue Funktion, getsizeof(), nimmt ein Python-Objekt entgegen und gibt den vom Objekt verwendeten Speicher zurück, gemessen in Bytes. Eingebaute Objekte liefern korrekte Ergebnisse; Drittanbieter-Erweiterungen tun dies möglicherweise nicht, können aber eine Methode __sizeof__() definieren, um die Größe des Objekts zurückzugeben. (Beigetragen von Robert Schuppenies; bpo-2898.)

  Es ist nun möglich, die aktuellen Profiler- und Tracer-Funktionen durch Aufrufen von sys.getprofile() und sys.gettrace() zu ermitteln. (Beigetragen von Georg Brandl; bpo-1648.)

• Das Modul tarfile unterstützt nun POSIX.1-2001 (pax) Tar-Dateien zusätzlich zu den bereits unterstützten POSIX.1-1988 (ustar) und GNU Tar-Formaten. Das Standardformat ist GNU Tar; geben Sie den Parameter format an, um eine Datei in einem anderen Format zu öffnen.

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

  Die neuen Parameter encoding und errors geben eine Kodierung und ein Fehlerbehandlungsschema für Zeichenkonvertierungen an. 'strict', 'ignore' und 'replace' sind die drei Standardmethoden, mit denen Python Fehler behandeln kann; 'utf-8' ist ein spezieller Wert, der fehlerhafte Zeichen durch ihre UTF-8-Darstellung ersetzt. (Zeichenkonvertierungen erfolgen, da das PAX-Format Unicode-Dateinamen unterstützt und standardmäßig UTF-8-Kodierung verwendet.)

  Die Methode TarFile.add() akzeptiert nun ein Argument exclude, das eine Funktion sein kann, die verwendet wird, um bestimmte Dateinamen aus einem Archiv auszuschließen. Die Funktion muss einen Dateinamen entgegennehmen und wahr zurückgeben, wenn die Datei ausgeschlossen werden soll, oder falsch, wenn sie archiviert werden soll. Die Funktion wird sowohl auf den Namen angewendet, der ursprünglich an add() übergeben wurde, als auch auf die Namen von Dateien in rekursiv hinzugefügten Verzeichnissen.

  (Alle Änderungen beigetragen von Lars Gustäbel).

• Ein optionaler Parameter timeout wurde dem Konstruktor der Klasse telnetlib.Telnet hinzugefügt, der ein Timeout in Sekunden angibt. (Hinzugefügt von Facundo Batista.)

• Die Klasse tempfile.NamedTemporaryFile löscht normalerweise die von ihr erstellte temporäre Datei, wenn die Datei geschlossen wird. Dieses Verhalten kann nun geändert werden, indem delete=False an den Konstruktor übergeben wird. (Beigetragen von Damien Miller; bpo-1537850.)

  Eine neue Klasse, SpooledTemporaryFile, verhält sich wie eine temporäre Datei, speichert ihre Daten aber im Speicher, bis eine maximale Größe überschritten wird. Wenn dieses Limit erreicht ist, werden die Inhalte in eine temporäre Datei auf der Festplatte geschrieben. (Beigetragen von Dustin J. Mitchell.)

  Die Klassen NamedTemporaryFile und SpooledTemporaryFile funktionieren beide als Kontextmanager, sodass Sie schreiben können: with tempfile.NamedTemporaryFile() as tmp: .... (Beigetragen von Alexander Belopolsky; bpo-2021.)

• Das Modul test.test_support hat eine Reihe von Kontextmanagern erhalten, die für das Schreiben von Tests nützlich sind. EnvironmentVarGuard() ist ein Kontextmanager, der Umgebungsvariablen vorübergehend ändert und sie automatisch in ihre alten Werte zurückversetzt.

  Ein weiterer Kontextmanager, TransientResource, kann Aufrufe an Ressourcen umgeben, die verfügbar sein können oder nicht; er fängt angegebene Ausnahmen ab und ignoriert sie. Zum Beispiel kann ein Netzwerktest bestimmte Fehler beim Verbinden mit einem externen Webserver ignorieren.

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

  Schließlich setzt check_warnings() die Warnfilter des Moduls warning zurück und gibt ein Objekt zurück, das alle ausgelösten Warnmeldungen aufzeichnet (bpo-3781).

  with test_support.check_warnings() as wrec:
      warnings.simplefilter("always")
      # ... code that triggers a warning ...
      assert str(wrec.message) == "function is outdated"
      assert len(wrec.warnings) == 1, "Multiple warnings raised"
  

  (Beigetragen von Brett Cannon.)

• Das Modul textwrap kann nun vorhandene Leerzeichen am Anfang und Ende der neu erstellten Zeilen beibehalten, indem drop_whitespace=False als Argument angegeben wird.

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

  (Beigetragen von Dwayne Bailey; bpo-1581073.)

• Die API des Moduls threading wird geändert, um Eigenschaften wie daemon anstelle der Methoden setDaemon() und isDaemon() zu verwenden, und einige Methoden wurden umbenannt, um Unterstriche anstelle von Camel-Case zu verwenden; zum Beispiel wird die Methode activeCount() in active_count() umbenannt. Sowohl die Versionen 2.6 als auch 3.0 des Moduls unterstützen dieselben Eigenschaften und umbenannten Methoden, entfernen aber nicht die alten Methoden. Für die Deprezierung der alten APIs in Python 3.x wurde kein Datum festgelegt; die alten APIs werden in keiner 2.x-Version entfernt. (Durchgeführt von mehreren Personen, insbesondere Benjamin Peterson.)

  Objekte vom Typ Thread aus dem Modul threading haben eine Eigenschaft ident erhalten, die die Thread-ID, eine ganzzahlige Zahl ungleich Null, zurückgibt. (Beigetragen von Gregory P. Smith; bpo-2871.)

• Das Modul timeit akzeptiert nun sowohl aufrufbare Objekte als auch Strings für die zu messende Anweisung und den Setup-Code. Zwei Hilfsfunktionen wurden zum Erstellen von Timer-Instanzen hinzugefügt: repeat(stmt, setup, time, repeat, number) und timeit(stmt, setup, time, number) erstellen eine Instanz und rufen die entsprechende Methode auf. (Beigetragen von Erik Demaine; bpo-1533909.)

• Das Modul Tkinter akzeptiert nun Listen und Tupel für Optionen, trennt die Elemente durch Leerzeichen, bevor der resultierende Wert an Tcl/Tk übergeben wird. (Beigetragen von Guilherme Polo; bpo-2906.)

• Das Modul turtle für Turtle-Grafiken wurde von Gregor Lingl erheblich erweitert. Neue Funktionen im Modul sind:

  • Bessere Animation von Schildkrötenbewegungen und -rotation.

  • Kontrolle über Schildkrötenbewegungen durch die neuen Methoden delay(), tracer() und speed().

  • Die Möglichkeit, neue Formen für die Schildkröte einzustellen und ein neues Koordinatensystem zu definieren.

  • Schildkröten haben nun eine Methode undo(), die Aktionen rückgängig machen kann.

  • Einfache Unterstützung für die Reaktion auf Eingabeereignisse wie Maus- und Tastaturaktivitäten, was die Erstellung einfacher Spiele ermöglicht.

  • Eine Datei turtle.cfg kann verwendet werden, um das Start-Erscheinungsbild des Schildkrötenbildschirms anzupassen.

  • Die Docstrings des Moduls können durch neue Docstrings ersetzt werden, die in eine andere Sprache übersetzt wurden.

  (bpo-1513695)

• Ein optionaler Parameter timeout wurde zur Funktion urllib.urlopen und zum Konstruktor der Klasse urllib.ftpwrapper sowie zur Funktion urllib2.urlopen hinzugefügt. Der Parameter gibt ein Timeout in Sekunden an. Zum Beispiel:

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

  (Hinzugefügt von Facundo Batista.)

• Die Unicode-Datenbank, die vom Modul unicodedata bereitgestellt wird, wurde auf Version 5.1.0 aktualisiert. (Aktualisiert von Martin von Löwis; bpo-3811.)

• Die Funktionen formatwarning() und showwarning() des Moduls warnings erhielten ein optionales Argument line, mit dem die Quellcodezeile angegeben werden kann. (Hinzugefügt als Teil von bpo-1631171, das einen Teil des Moduls warnings in C-Code neu implementiert.)

  Eine neue Funktion, catch_warnings(), ist ein Kontextmanager für Testzwecke, der es Ihnen ermöglicht, die Warnfilter vorübergehend zu ändern und ihre ursprünglichen Werte wiederherzustellen (bpo-3781).

• Die Klassen SimpleXMLRPCServer und DocXMLRPCServer von XML-RPC können jetzt daran gehindert werden, ihren Socket sofort zu öffnen und zu binden, indem False als Konstruktorparameter bind_and_activate übergeben wird. Dies kann verwendet werden, um das Attribut allow_reuse_address der Instanz zu ändern, bevor die Methoden server_bind() und server_activate() aufgerufen werden, um den Socket zu öffnen und mit dem Abhören von Verbindungen zu beginnen. (Beigetragen von Peter Parente; bpo-1599845.)

  SimpleXMLRPCServer verfügt außerdem über ein Attribut _send_traceback_header; wenn dieser Wert True ist, werden die Ausnahme und der formatierte Traceback als HTTP-Header "X-Exception" und "X-Traceback" zurückgegeben. Diese Funktion dient nur zu Debugging-Zwecken und sollte nicht auf Produktionsservern verwendet werden, da die Tracebacks Passwörter oder andere sensible Informationen preisgeben könnten. (Beigetragen von Alan McIntyre als Teil seines Projekts für Googles Summer of Code 2007.)

• Das Modul xmlrpclib konvertiert datetime.date und datetime.time nicht mehr automatisch in den Typ xmlrpclib.DateTime; die Konvertierungssemantik war nicht unbedingt für alle Anwendungen korrekt. Code, der xmlrpclib verwendet, sollte date und time Instanzen konvertieren. (bpo-1330538) Der Code kann auch Daten vor 1900 verarbeiten (beigetragen von Ralf Schmitt; bpo-2014) und 64-Bit-Integer, die in XML-RPC-Antworten als <i8> dargestellt werden (beigetragen von Riku Lindblad; bpo-2985).

• Die Klasse ZipFile des Moduls zipfile verfügt nun über die Methoden extract() und extractall(), die eine einzelne Datei oder alle Dateien im Archiv in das aktuelle Verzeichnis oder in ein angegebenes Verzeichnis entpacken.

  z = zipfile.ZipFile('python-251.zip')
  
  # Unpack a single file, writing it relative
  # to the /tmp directory.
  z.extract('Python/sysmodule.c', '/tmp')
  
  # Unpack all the files in the archive.
  z.extractall()
  

  (Beigetragen von Alan McIntyre; bpo-467924.)

  Die Methoden open(), read() und extract() können jetzt entweder einen Dateinamen oder ein ZipInfo Objekt akzeptieren. Dies ist nützlich, wenn ein Archiv versehentlich einen doppelten Dateinamen enthält. (Beigetragen von Graham Horler; bpo-1775025.)

  Schließlich unterstützt zipfile jetzt die Verwendung von Unicode-Dateinamen für archivierte Dateien. (Beigetragen von Alexey Borzenkov; bpo-1734346.)

Das Modul ast

Das Modul ast bietet eine abstrakte Syntaxbaum-Darstellung von Python-Code, und Armin Ronacher hat eine Reihe von Hilfsfunktionen beigesteuert, die eine Vielzahl gängiger Aufgaben ausführen. Diese sind nützlich für HTML-Templating-Pakete, Code-Analysatoren und ähnliche Werkzeuge, die Python-Code verarbeiten.

Die Funktion parse() nimmt einen Ausdruck entgegen und gibt einen AST zurück. Die Funktion dump() gibt eine Darstellung eines Baumes aus, die für das Debugging geeignet ist.

import ast

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

Dies gibt einen tief verschachtelten Baum aus.

Module(body=[
  Assign(targets=[
    Name(id='d', ctx=Store())
   ], value=Dict(keys=[], values=[]))
  For(target=Name(id='i', ctx=Store()),
      iter=Str(s='abcdefghijklm'), body=[
    Assign(targets=[
      Subscript(value=
        Name(id='d', ctx=Load()),
          slice=
          Index(value=
            BinOp(left=Name(id='i', ctx=Load()), op=Add(),
             right=Name(id='i', ctx=Load()))), ctx=Store())
     ], value=
     BinOp(left=
      BinOp(left=
       Call(func=
        Name(id='ord', ctx=Load()), args=[
          Name(id='i', ctx=Load())
         ], keywords=[], starargs=None, kwargs=None),
       op=Sub(), right=Call(func=
        Name(id='ord', ctx=Load()), args=[
          Str(s='a')
         ], keywords=[], starargs=None, kwargs=None)),
       op=Add(), right=Num(n=1)))
    ], orelse=[])
   Print(dest=None, values=[
     Name(id='d', ctx=Load())
   ], nl=True)
 ])

Die Methode literal_eval() nimmt eine Zeichenkette oder einen AST entgegen, der einen literalen Ausdruck darstellt, parst und bewertet ihn und gibt den resultierenden Wert zurück. Ein literaler Ausdruck ist ein Python-Ausdruck, der nur Zeichenketten, Zahlen, Wörterbücher usw. enthält, aber keine Anweisungen oder Funktionsaufrufe. Wenn Sie einen Ausdruck auswerten müssen, aber das Sicherheitsrisiko eines eval()-Aufrufs nicht eingehen können, behandelt literal_eval() dies sicher.

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

Das Modul enthält auch die Klassen NodeVisitor und NodeTransformer zum Durchlaufen und Modifizieren eines AST sowie Funktionen für gängige Transformationen wie das Ändern von Zeilennummern.

Das Modul future_builtins

Python 3.0 nimmt viele Änderungen am Repertoire der integrierten Funktionen vor, und die meisten Änderungen können nicht in der Python 2.x-Reihe eingeführt werden, da sie die Kompatibilität brechen würden. Das Modul future_builtins bietet Versionen dieser integrierten Funktionen, die beim Schreiben von 3.0-kompatiblem Code importiert werden können.

Die Funktionen in diesem Modul umfassen derzeit:

• ascii(obj): Äquivalent zu repr(). In Python 3.0 gibt repr() eine Unicode-Zeichenkette zurück, während ascii() eine reine ASCII-Bytestring zurückgibt.

• filter(predicate, iterable), map(func, iterable1, ...): Die 3.0-Versionen geben Iteratoren zurück, im Gegensatz zu den 2.x-Builtins, die Listen zurückgeben.

• hex(value), oct(value): Anstatt die Methoden __hex__() oder __oct__() aufzurufen, rufen diese Versionen die Methode __index__() auf und konvertieren das Ergebnis in Hexadezimal- oder Oktalform. oct() verwendet die neue 0o-Notation für sein Ergebnis.

Das Modul json: JavaScript Object Notation

Das neue Modul json unterstützt die Kodierung und Dekodierung von Python-Typen in JSON (Javascript Object Notation). JSON ist ein leichtgewichtiges Austauschformat, das häufig in Webanwendungen verwendet wird. Weitere Informationen zu JSON finden Sie unter http://www.json.org.

json unterstützt die Dekodierung und Kodierung der meisten integrierten Python-Typen. Das folgende Beispiel kodiert und dekodiert ein Wörterbuch.

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

Es ist auch möglich, eigene Dekoder und Encoder zu schreiben, um weitere Typen zu unterstützen. Die Pretty-Printing-Funktion für JSON-Zeichenketten wird ebenfalls unterstützt.

json (ursprünglich simplejson genannt) wurde von Bob Ippolito geschrieben.

Das Modul plistlib: Ein Property-List-Parser

Das .plist-Format wird häufig unter Mac OS X verwendet, um grundlegende Datentypen (Zahlen, Zeichenketten, Listen und Wörterbücher) zu speichern, indem sie in ein XML-basiertes Format serialisiert werden. Es ähnelt der XML-RPC-Serialisierung von Datentypen.

Obwohl das Format hauptsächlich unter Mac OS X verwendet wird, hat es nichts Spezifisches für Mac und die Python-Implementierung funktioniert auf jeder Plattform, die Python unterstützt. Daher wurde das Modul plistlib in die Standardbibliothek aufgenommen.

Die Verwendung des Moduls ist einfach.

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)

ctypes-Erweiterungen

Thomas Heller pflegte und erweiterte das Modul ctypes weiter.

ctypes unterstützt jetzt einen Datentyp c_bool, der den C99-Typ bool darstellt. (Beigetragen von David Remahl; bpo-1649190.)

Die Zeichenketten-, Puffer- und Array-Typen von ctypes haben eine verbesserte Unterstützung für die erweiterte Slice-Syntax, bei der verschiedene Kombinationen von (start, stop, step) bereitgestellt werden. (Implementiert von Thomas Wouters.)

Alle ctypes-Datentypen unterstützen jetzt die Methoden from_buffer() und from_buffer_copy(), die eine ctypes-Instanz basierend auf einem bereitgestellten Pufferobjekt erstellen. from_buffer_copy() kopiert den Inhalt des Objekts, während from_buffer() denselben Speicherbereich teilt.

Eine neue Aufrufkonvention weist ctypes an, die Variablen errno oder Win32 LastError zu Beginn jedes umschlossenen Aufrufs zu löschen. (Implementiert von Thomas Heller; bpo-1798.)

Sie können jetzt die Unix-Variable errno nach einem Funktionsaufruf abrufen. Beim Erstellen einer umschlossenen Funktion können Sie use_errno=True als Schlüsselwortparameter an die Funktion DLL() übergeben und dann die Modul-Methoden set_errno() und get_errno() aufrufen, um den Fehlerwert festzulegen und abzurufen.

Die Win32 LastError-Variable wird auf ähnliche Weise von den Funktionen DLL(), OleDLL() und WinDLL() unterstützt. Sie übergeben use_last_error=True als Schlüsselwortparameter und rufen dann die Modul-Methoden set_last_error() und get_last_error() auf.

Die Funktion byref(), die zum Abrufen eines Zeigers auf eine ctypes-Instanz verwendet wird, verfügt nun über einen optionalen Parameter offset, der eine Byte-Anzahl darstellt, die zum zurückgegebenen Zeiger addiert wird.

Verbesserte SSL-Unterstützung

Bill Janssen hat Python 2.6s Unterstützung für Secure Sockets Layer um ein neues Modul namens ssl erweitert, das auf der OpenSSL-Bibliothek aufbaut. Dieses neue Modul bietet mehr Kontrolle über das verhandelte Protokoll, die verwendeten X.509-Zertifikate und eine bessere Unterstützung für das Schreiben von SSL-Servern (im Gegensatz zu Clients) in Python. Die bestehende SSL-Unterstützung im Modul socket wurde nicht entfernt und funktioniert weiterhin, wird aber in Python 3.0 entfernt.

Um das neue Modul zu verwenden, müssen Sie zuerst eine TCP-Verbindung auf die übliche Weise herstellen und diese dann an die Funktion ssl.wrap_socket() übergeben. Es ist möglich anzugeben, ob ein Zertifikat erforderlich ist, und Zertifikatsinformationen durch Aufrufen der Methode getpeercert() zu erhalten.

Siehe auch

Die Dokumentation für das Modul ssl.

Veraltete Funktionen und Entfernungen

• Zeichenkettenausnahmen wurden entfernt. Der Versuch, sie zu verwenden, löst einen TypeError aus.

• Die Änderungen an der Schnittstelle Exception, wie sie in PEP 352 festgelegt sind, werden weiterhin vorgenommen. Für 2.6 wird das Attribut message zugunsten des Attributs args als veraltet markiert.

• (3.0-Warnmodus) Python 3.0 wird eine neu organisierte Standardbibliothek enthalten, die viele veraltete Module entfernen und andere umbenennen wird. Python 2.6 im 3.0-Warnmodus wird beim Importieren dieser Module Warnungen ausgeben.

  Die Liste der veralteten Module ist: audiodev, bgenlocations, buildtools, bundlebuilder, Canvas, compiler, dircache, dl, fpformat, gensuitemodule, ihooks, imageop, imgfile, linuxaudiodev, mhlib, mimetools, multifile, new, pure, statvfs, sunaudiodev, test.testall und toaiff.

• Das Modul gopherlib wurde entfernt.

• Die Module MimeWriter und mimify sind veraltet; verwenden Sie stattdessen das Paket email.

• Das Modul md5 ist veraltet; verwenden Sie stattdessen das Modul hashlib.

• Das Modul posixfile ist veraltet; fcntl.lockf() bietet eine bessere Sperrung.

• Das Modul popen2 ist veraltet; verwenden Sie das Modul subprocess.

• Das Modul rgbimg wurde entfernt.

• Das Modul sets ist veraltet; es ist besser, die integrierten Typen set und frozenset zu verwenden.

• Das Modul sha ist veraltet; verwenden Sie stattdessen das Modul hashlib.

Build- und C-API-Änderungen

Änderungen am Build-Prozess von Python und an der C-API umfassen

• Python muss jetzt mit C89-Kompilern kompiliert werden (nach 19 Jahren!). Das bedeutet, dass der Python-Quellbaum seine eigenen Implementierungen von memmove() und strerror() entfernt hat, die sich in der C89-Standardbibliothek befinden.

• Python 2.6 kann mit Microsoft Visual Studio 2008 (Version 9.0) kompiliert werden, und dies ist der neue Standardcompiler. Sehen Sie sich das Verzeichnis PCbuild für die Build-Dateien an. (Implementiert von Christian Heimes.)

• Unter Mac OS X kann Python 2.6 als 4-Wege-Universal-Build kompiliert werden. Das Skript configure kann den Schalter --with-universal-archs=[32-bit|64-bit|all] annehmen, der steuert, ob die Binärdateien für 32-Bit-Architekturen (x86, PowerPC), 64-Bit (x86-64 und PPC-64) oder beides erstellt werden. (Beigetragen von Ronald Oussoren.)

• Eine neue Funktion, die in Python 2.6.6 hinzugefügt wurde, PySys_SetArgvEx(), setzt den Wert von sys.argv und kann optional sys.path aktualisieren, um das Verzeichnis aufzunehmen, das das Skript mit dem Namen sys.argv[0] enthält, abhängig vom Wert eines updatepath-Parameters.

  Diese Funktion wurde hinzugefügt, um eine Sicherheitslücke für Anwendungen zu schließen, die Python einbetten. Die alte Funktion PySys_SetArgv() aktualisierte immer sys.path und fügte manchmal das aktuelle Verzeichnis hinzu. Das bedeutete, wenn Sie eine Anwendung ausführten, die Python in einem von jemand anderem kontrollierten Verzeichnis einbettete, konnten Angreifer ein Trojaner-Modul im Verzeichnis platzieren (z. B. eine Datei namens os.py), die Ihre Anwendung dann importieren und ausführen würde.

  Wenn Sie eine C/C++-Anwendung warten, die Python einbettet, überprüfen Sie, ob Sie PySys_SetArgv() aufrufen, und überlegen Sie sorgfältig, ob die Anwendung PySys_SetArgvEx() mit updatepath auf false setzen sollte. Beachten Sie, dass die Verwendung dieser Funktion die Kompatibilität mit Python-Versionen 2.6.5 und früher unterbricht. Wenn Sie weiterhin mit früheren Versionen arbeiten müssen, können Sie den Aufruf von PySys_SetArgv() beibehalten und anschließend PyRun_SimpleString("sys.path.pop(0)\n") aufrufen, um die erste Komponente von sys.path zu verwerfen.

  Sicherheitslücke gemeldet als CVE 2008-5983; diskutiert in gh-50003 und behoben von Antoine Pitrou.

• Das BerkeleyDB-Modul verfügt jetzt über ein C-API-Objekt, das unter bsddb.db.api verfügbar ist. Dieses Objekt kann von anderen C-Erweiterungen verwendet werden, die das Modul bsddb für ihre eigenen Zwecke nutzen möchten. (Beigetragen von Duncan Grisby.)

• Die neue Puffer-Schnittstelle, die zuvor im Abschnitt PEP 3118 beschrieben wurde, fügt PyObject_GetBuffer() und PyBuffer_Release() sowie einige andere Funktionen hinzu.

• Die Verwendung der C stdio-Bibliothek durch Python ist jetzt threadsicher, oder zumindest so threadsicher, wie die zugrunde liegende Bibliothek es ist. Ein seit langem bestehender potenzieller Fehler trat auf, wenn ein Thread ein Dateiobjekt schloss, während ein anderer Thread von diesem Objekt las oder darauf schrieb. In 2.6 haben Dateiobjekte eine Referenzanzahl, die von den Funktionen PyFile_IncUseCount() und PyFile_DecUseCount() manipuliert wird. Dateiobjekte können nicht geschlossen werden, es sei denn, die Referenzanzahl ist Null. PyFile_IncUseCount() sollte aufgerufen werden, während der GIL noch gehalten wird, bevor eine E/A-Operation mit dem FILE * Zeiger durchgeführt wird, und PyFile_DecUseCount() sollte unmittelbar nach der erneuten Erfassung des GIL aufgerufen werden. (Beigetragen von Antoine Pitrou und Gregory P. Smith.)

• Das gleichzeitige Importieren von Modulen in zwei verschiedenen Threads führt nicht mehr zu einem Deadlock; stattdessen wird ein ImportError ausgelöst. Eine neue API-Funktion, PyImport_ImportModuleNoBlock(), sucht zuerst in sys.modules nach einem Modul und versucht dann, es nach Erfassung eines Import-Locks zu importieren. Wenn der Import-Lock von einem anderen Thread gehalten wird, wird ein ImportError ausgelöst. (Beigetragen von Christian Heimes.)

• Mehrere Funktionen geben Informationen über die Gleitkommaunterstützung der Plattform zurück. PyFloat_GetMax() gibt den maximal darstellbaren Gleitkommawert zurück, und PyFloat_GetMin() gibt den kleinsten positiven Wert zurück. PyFloat_GetInfo() gibt ein Objekt mit weiteren Informationen aus der Datei float.h zurück, wie z. B. "mant_dig" (Anzahl der Stellen im Mantisse), "epsilon" (kleinster Unterschied zwischen 1,0 und dem nächstgrößeren darstellbaren Wert) und einige andere. (Beigetragen von Christian Heimes; bpo-1534.)

• C-Funktionen und -Methoden, die PyComplex_AsCComplex() verwenden, akzeptieren jetzt Argumente, die eine Methode __complex__() haben. Insbesondere die Funktionen im Modul cmath akzeptieren jetzt Objekte mit dieser Methode. Dies ist ein Backport einer Änderung von Python 3.0. (Beigetragen von Mark Dickinson; bpo-1675423.)

• Die C-API von Python enthält jetzt zwei Funktionen für den fallunempfindlichen Zeichenkettenvergleich: PyOS_stricmp(char*, char*) und PyOS_strnicmp(char*, char*, Py_ssize_t). (Beigetragen von Christian Heimes; bpo-1635.)

• Viele C-Erweiterungen definieren ihre eigenen kleinen Makros zum Hinzufügen von Ganzzahlen und Zeichenketten zum Wörterbuch des Moduls in der init*-Funktion. Python 2.6 definiert endlich Standardmakros zum Hinzufügen von Werten zu einem Modul: PyModule_AddStringMacro und PyModule_AddIntMacro(). (Beigetragen von Christian Heimes.)

• Einige Makros wurden sowohl in 3.0 als auch in 2.6 umbenannt, um deutlicher zu machen, dass es sich um Makros und nicht um Funktionen handelt. Py_Size() wurde zu Py_SIZE(), Py_Type() wurde zu Py_TYPE() und Py_Refcnt() wurde zu Py_REFCNT(). Die Makros mit gemischter Groß- und Kleinschreibung sind in Python 2.6 aus Kompatibilitätsgründen weiterhin verfügbar. (bpo-1629)

• Distutils platziert C-Erweiterungen, die es erstellt, in einem anderen Verzeichnis, wenn es auf einer Debug-Version von Python ausgeführt wird. (Beigetragen von Collin Winter; bpo-1530959.)

• Mehrere grundlegende Datentypen, wie Ganzzahlen und Zeichenketten, unterhalten interne Freilisten von Objekten, die wiederverwendet werden können. Die Datenstrukturen für diese Freilisten folgen nun einer Namenskonvention: Die Variable wird immer free_list genannt, der Zähler immer numfree und ein Makro Py<typename>_MAXFREELIST ist immer definiert.

• Ein neues Makefile-Ziel, "make patchcheck", bereitet den Python-Quellbaum für die Erstellung eines Patches vor: Es behebt überflüssige Leerzeichen in allen geänderten .py-Dateien, prüft, ob die Dokumentation geändert wurde, und meldet, ob die Dateien Misc/ACKS und Misc/NEWS aktualisiert wurden. (Beigetragen von Brett Cannon.)

  Ein weiteres neues Ziel, „make profile-opt“, kompiliert ein Python-Binärprogramm unter Verwendung der profilergesteuerten Optimierung von GCC. Es kompiliert Python mit aktiviertem Profiling, führt die Testsuite aus, um eine Reihe von Profiling-Ergebnissen zu erhalten, und kompiliert dann unter Verwendung dieser Ergebnisse zur Optimierung. (Beigetragen von Gregory P. Smith.)

Portspezifische Änderungen: Windows

• Die Unterstützung für Windows 95, 98, ME und NT4 wurde eingestellt. Python 2.6 erfordert mindestens Windows 2000 SP4.

• Der neue Standardcompiler unter Windows ist Visual Studio 2008 (Version 9.0). Die Build-Verzeichnisse für Visual Studio 2003 (Version 7.1) und 2005 (Version 8.0) wurden in das Verzeichnis PC/ verschoben. Das neue Verzeichnis PCbuild unterstützt die Cross-Kompilierung für X64, Debug-Builds und profilergesteuerte Optimierung (PGO). PGO-Builds sind etwa 10 % schneller als normale Builds. (Beigetragen von Christian Heimes mit Hilfe von Amaury Forgeot d’Arc und Martin von Löwis.)

• Das Modul msvcrt unterstützt jetzt sowohl die normalen als auch die Wide-Char-Varianten der Konsolen-I/O-API. Die Funktion getwch() liest einen Tastendruck und gibt einen Unicode-Wert zurück, ebenso wie die Funktion getwche(). Die Funktion putwch() nimmt ein Unicode-Zeichen und schreibt es auf die Konsole. (Beigetragen von Christian Heimes.)

• os.path.expandvars() erweitert nun Umgebungsvariablen in der Form „%var%“, und „~user“ wird in den Pfad zum Home-Verzeichnis des Benutzers erweitert. (Beigetragen von Josiah Carlson; bpo-957650.)

• Die Socket-Objekte des Moduls socket verfügen jetzt über eine Methode ioctl(), die eine begrenzte Schnittstelle zur System-Schnittstelle WSAIoctl() bietet.

• Das Modul _winreg verfügt nun über eine Funktion, ExpandEnvironmentStrings(), die Umgebungsvariablenreferenzen wie %NAME% in einem Eingabestring erweitert. Die von diesem Modul bereitgestellten Handle-Objekte unterstützen nun das Kontextprotokoll, so dass sie in with-Anweisungen verwendet werden können. (Beigetragen von Christian Heimes.)

  _winreg bietet außerdem eine bessere Unterstützung für x64-Systeme, indem es die Funktionen DisableReflectionKey(), EnableReflectionKey() und QueryReflectionKey() verfügbar macht, die die Registrierungswiderspiegelung für 32-Bit-Prozesse auf 64-Bit-Systemen aktivieren und deaktivieren. (bpo-1753245)

• Das Objekt Record des Moduls msilib hat die Methoden GetInteger() und GetString() erhalten, die Feldwerte als Ganzzahl oder String zurückgeben. (Beigetragen von Floris Bruynooghe; bpo-2125.)

Portspezifische Änderungen: Mac OS X

• Beim Kompilieren eines Framework-Builds von Python können Sie jetzt den zu verwendenden Framework-Namen angeben, indem Sie die Option --with-framework-name= zum Skript configure übergeben.

• Das Modul macfs wurde entfernt. Dies wiederum erforderte die Entfernung der Funktion macostools.touched(), da diese vom Modul macfs abhing. (bpo-1490190)

• Viele andere Mac OS-Module wurden als veraltet markiert und werden in Python 3.0 entfernt: _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 und terminalcommand.

Portspezifische Änderungen: IRIX

Eine Reihe alter IRIX-spezifischer Module wurde als veraltet markiert und wird in Python 3.0 entfernt: al und AL, cd, cddb, cdplayer, CL und cl, DEVICE, ERRNO, FILE, FL und fl, flp, fm, GET, GLWS, GL und gl, IN, IOCTL, jpeg, panelparser, readcd, SV und sv, torgb, videoreader und WAIT.

Portierung auf Python 2.6

Dieser Abschnitt listet die zuvor beschriebenen Änderungen und andere Fehlerbehebungen auf, die möglicherweise Änderungen an Ihrem Code erfordern

• Klassen, die nicht hashbar sein sollen, sollten __hash__ = None in ihren Definitionen setzen, um dies anzuzeigen.

• Zeichenkettenausnahmen wurden entfernt. Der Versuch, sie zu verwenden, löst einen TypeError aus.

• Die Methode __init__() von collections.deque löscht nun alle vorhandenen Inhalte des Deques, bevor Elemente aus dem Iterable hinzugefügt werden. Diese Änderung bewirkt, dass das Verhalten dem von list.__init__() entspricht.

• object.__init__() akzeptierte zuvor beliebige Argumente und Schlüsselwortargumente und ignorierte diese. In Python 2.6 ist dies nicht mehr erlaubt und führt zu einem TypeError. Dies wirkt sich auf __init__()-Methoden aus, die schließlich die entsprechende Methode von object aufrufen (möglicherweise durch Verwendung von super()). Siehe bpo-1683368 zur Diskussion.

• Der Konstruktor Decimal akzeptiert nun führende und nachfolgende Leerzeichen, wenn ihm ein String übergeben wird. Zuvor würde dies eine Ausnahme InvalidOperation auslösen. Andererseits verbietet die Methode create_decimal() von Context-Objekten nun explizit zusätzliche Leerzeichen und löst eine Ausnahme ConversionSyntax aus.

• Aufgrund eines Implementierungsunfalls würde die Übergabe eines Dateipfads an die eingebaute Funktion __import__() die angegebene Datei tatsächlich importieren. Dies war jedoch nie beabsichtigt, und die Implementierung prüft nun explizit diesen Fall und löst eine ImportError aus.

• C API: Die Funktionen PyImport_Import() und PyImport_ImportModule() verwenden nun standardmäßig absolute Imports, nicht relative Imports. Dies wirkt sich auf C-Erweiterungen aus, die andere Module importieren.

• C API: Erweiterungsdatentypen, die nicht hashbar sein sollen, sollten ihren Slot tp_hash auf PyObject_HashNotImplemented() setzen.

• Die Ausnahme socket.error des Moduls socket erbt nun von IOError. Zuvor war sie keine Unterklasse von StandardError, aber jetzt ist sie es durch IOError. (Implementiert von Gregory P. Smith; bpo-1706815.)

• Das Modul xmlrpclib konvertiert datetime.date und datetime.time nicht mehr automatisch in den Typ xmlrpclib.DateTime; die Konvertierungssemantik war nicht unbedingt für alle Anwendungen korrekt. Code, der xmlrpclib verwendet, sollte date- und time-Instanzen konvertieren. (bpo-1330538)

• (3.0-Warnmodus) Die Klasse Exception gibt nun eine Warnung aus, wenn sie mit Slicing oder Indexzugriff aufgerufen wird; die Behandlung von Exception wie ein Tupel wird ausgemustert.

• (3.0-Warnmodus) Ungleichheitsvergleiche zwischen zwei Dictionaries oder zwei Objekten, die keine Vergleichsmethoden implementieren, werden als Warnungen gemeldet. dict1 == dict2 funktioniert weiterhin, aber dict1 < dict2 wird ausgemustert.

  Vergleiche zwischen Zellen, die ein Implementierungsdetail der Python-Scoping-Regeln sind, lösen ebenfalls Warnungen aus, da solche Vergleiche in 3.0 vollständig verboten sind.

Für Anwendungen, die Python einbetten

• Die Funktion PySys_SetArgvEx() wurde in Python 2.6.6 hinzugefügt und ermöglicht es Anwendungen, ein Sicherheitsloch zu schließen, wenn die vorhandene Funktion PySys_SetArgv() verwendet wurde. Prüfen Sie, ob Sie PySys_SetArgv() aufrufen und überlegen Sie sorgfältig, ob die Anwendung PySys_SetArgvEx() mit *updatepath* auf false setzen sollte.

Danksagungen

Der Autor möchte sich bei folgenden Personen für Vorschläge, Korrekturen und Hilfe bei verschiedenen Entwürfen dieses Artikels bedanken: Georg Brandl, Steve Brown, Nick Coghlan, Ralph Corderoy, Jim Jewett, Kent Johnson, Chris Lambacher, Martin Michlmayr, Antoine Pitrou, Brian Warner.