Versteckte Funktionen von Python [geschlossen]

Was sind die weniger bekannten, aber nützlichen Funktionen der Programmiersprache Python?

• Versuchen Sie, die Antworten auf den Python-Kern zu beschränken.
• Eine Funktion pro Antwort.
• Geben Sie ein Beispiel und eine kurze Beschreibung der Funktion, nicht nur einen Link zur Dokumentation.
• Beschriften Sie das Feature mit einem Titel als erste Zeile.

Schnelle Links zu Antworten:

• Argument entpacken
• Hosenträger
• Verketten von Vergleichsoperatoren
• Dekorateure
• Standardargument Fallstricke / Gefahren veränderlicher Standardargumente
• Deskriptoren
• Wörterbuch .getStandardwert
• Docstring-Tests
• Ellipsis Slicing Syntax
• Aufzählung
• Für / sonst
• Funktion als iter () Argument
• Generatorausdrücke
• import this
• In Place Value Swapping
• Listenschritt
• __missing__ Artikel
• Mehrzeiliger Regex
• Benannte Zeichenfolgenformatierung
• Verschachteltes Listen- / Generatorverständnis
• Neue Typen zur Laufzeit
• .pth Dateien
• ROT13-Codierung
• Regex-Debugging
• Senden an Generatoren
• Tab-Vervollständigung in Interactive Interpreter
• Ternärer Ausdruck
• try/except/else
• Auspacken + print()Funktion
• with Aussage

Verketten von Vergleichsoperatoren:

>>> x = 5
>>> 1 < x < 10
True
>>> 10 < x < 20 
False
>>> x < 10 < x*10 < 100
True
>>> 10 > x <= 9
True
>>> 5 == x > 4
True

Wenn Sie denken, dass es funktioniert 1 < x, was herauskommt True, und dann vergleichen True < 10, was auch ist True, dann nein, das ist wirklich nicht das, was passiert (siehe das letzte Beispiel). Es übersetzt wirklich in 1 < x and x < 10und x < 10 and 10 < x * 10 and x*10 < 100, aber mit weniger Tippen und jedem Begriff wird nur einmal ausgewertet.

Holen Sie sich den Python-Regex-Analysebaum, um Ihren Regex zu debuggen.

Reguläre Ausdrücke sind eine großartige Funktion von Python, aber das Debuggen kann schmerzhaft sein, und es ist allzu leicht, einen regulären Ausdruck falsch zu verstehen.

Glücklicherweise kann Python den Regex-Analysebaum drucken, indem das undokumentierte, experimentelle, versteckte Flag re.DEBUG(tatsächlich 128) an übergeben wird re.compile.

>>> re.compile("^\[font(?:=(?P<size>[-+][0-9]{1,2}))?\](.*?)[/font]",
    re.DEBUG)
at at_beginning
literal 91
literal 102
literal 111
literal 110
literal 116
max_repeat 0 1
  subpattern None
    literal 61
    subpattern 1
      in
        literal 45
        literal 43
      max_repeat 1 2
        in
          range (48, 57)
literal 93
subpattern 2
  min_repeat 0 65535
    any None
in
  literal 47
  literal 102
  literal 111
  literal 110
  literal 116

Sobald Sie die Syntax verstanden haben, können Sie Ihre Fehler erkennen. Dort können wir sehen, dass ich vergessen habe, dem []In zu entkommen [/font].

Natürlich können Sie es mit beliebigen Flags kombinieren, z. B. mit kommentierten regulären Ausdrücken:

>>> re.compile("""
 ^              # start of a line
 \[font         # the font tag
 (?:=(?P<size>  # optional [font=+size]
 [-+][0-9]{1,2} # size specification
 ))?
 \]             # end of tag
 (.*?)          # text between the tags
 \[/font\]      # end of the tag
 """, re.DEBUG|re.VERBOSE|re.DOTALL)

aufzählen

Wenn Sie eine iterable Datei mit enumerate umschließen, wird das Element zusammen mit seinem Index angezeigt.

Zum Beispiel:

>>> a = ['a', 'b', 'c', 'd', 'e']
>>> for index, item in enumerate(a): print index, item
...
0 a
1 b
2 c
3 d
4 e
>>>

Verweise:

• Python-Tutorial - Schleifentechniken
• Python-Dokumente - integrierte Funktionen -enumerate
• PEP 279

Generatorobjekte erstellen

Wenn du schreibst

x=(n for n in foo if bar(n))

Sie können den Generator herausholen und x zuweisen. Jetzt können Sie es tun

for n in x:

Dies hat den Vorteil, dass Sie keinen Zwischenspeicher benötigen, den Sie sonst benötigen würden

x = [n for n in foo if bar(n)]

In einigen Fällen kann dies zu einer erheblichen Beschleunigung führen.

Sie können viele if-Anweisungen an das Ende des Generators anhängen und im Grunde verschachtelte for-Schleifen replizieren:

>>> n = ((a,b) for a in range(0,2) for b in range(4,6))
>>> for i in n:
...   print i 

(0, 4)
(0, 5)
(1, 4)
(1, 5)

iter () kann ein aufrufbares Argument annehmen

Zum Beispiel:

def seek_next_line(f):
    for c in iter(lambda: f.read(1),'\n'):
        pass

Die iter(callable, until_value)Funktion ruft wiederholt auf callableund gibt das Ergebnis aus, bis until_valuees zurückgegeben wird.

Seien Sie vorsichtig mit veränderlichen Standardargumenten

>>> def foo(x=[]):
...     x.append(1)
...     print x
... 
>>> foo()
[1]
>>> foo()
[1, 1]
>>> foo()
[1, 1, 1]

Verwenden Sie stattdessen einen Sentinel-Wert, der "nicht angegeben" bedeutet, und ersetzen Sie ihn durch die veränderbare Variable, die Sie standardmäßig verwenden möchten:

>>> def foo(x=None):
...     if x is None:
...         x = []
...     x.append(1)
...     print x
>>> foo()
[1]
>>> foo()
[1]

Senden von Werten in Generatorfunktionen . Zum Beispiel mit dieser Funktion:

def mygen():
    """Yield 5 until something else is passed back via send()"""
    a = 5
    while True:
        f = (yield a) #yield a and possibly get f in return
        if f is not None: 
            a = f  #store the new value

Du kannst:

>>> g = mygen()
>>> g.next()
5
>>> g.next()
5
>>> g.send(7)  #we send this back to the generator
7
>>> g.next() #now it will yield 7 until we send something else
7

Wenn Sie keine Leerzeichen verwenden möchten, um Bereiche zu kennzeichnen, können Sie den C-Stil {} verwenden, indem Sie Folgendes ausgeben:

from __future__ import braces

Das Schrittargument in Slice-Operatoren. Zum Beispiel:

a = [1,2,3,4,5]
>>> a[::2]  # iterate over the whole list in 2-increments
[1,3,5]

Der Sonderfall x[::-1]ist eine nützliche Redewendung für 'x umgekehrt'.

>>> a[::-1]
[5,4,3,2,1]

Dekorateure

Mit Dekorateuren können Sie eine Funktion oder Methode in eine andere Funktion einbinden, die Funktionen hinzufügen, Argumente oder Ergebnisse ändern usw. Sie schreiben Dekorateure eine Zeile über der Funktionsdefinition, beginnend mit einem "at" -Zeichen (@).

Das Beispiel zeigt einen print_argsDekorateur, der die Argumente der dekorierten Funktion druckt, bevor er sie aufruft:

>>> def print_args(function):
>>>     def wrapper(*args, **kwargs):
>>>         print 'Arguments:', args, kwargs
>>>         return function(*args, **kwargs)
>>>     return wrapper

>>> @print_args
>>> def write(text):
>>>     print text

>>> write('foo')
Arguments: ('foo',) {}
foo

Die for ... else-Syntax (siehe http://docs.python.org/ref/for.html )

for i in foo:
    if i == 0:
        break
else:
    print("i was never 0")

Der "else" -Block wird normalerweise am Ende der for-Schleife ausgeführt, es sei denn, die Pause wird aufgerufen.

Der obige Code könnte wie folgt emuliert werden:

found = False
for i in foo:
    if i == 0:
        found = True
        break
if not found: 
    print("i was never 0")

Ab 2.5 haben Diktate eine spezielle Methode __missing__, die für fehlende Gegenstände aufgerufen wird:

>>> class MyDict(dict):
...  def __missing__(self, key):
...   self[key] = rv = []
...   return rv
... 
>>> m = MyDict()
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{'foo': [1, 2]}

Es gibt auch eine diktierte Unterklasse in collectionsaufgerufen defaultdict, die fast dasselbe tut, aber eine Funktion ohne Argumente für nicht vorhandene Elemente aufruft:

>>> from collections import defaultdict
>>> m = defaultdict(list)
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{'foo': [1, 2]}

Ich empfehle, solche Diktate in reguläre Diktate umzuwandeln, bevor Sie sie an Funktionen übergeben, die solche Unterklassen nicht erwarten. Viele Codes verwenden d[a_key]und fangen KeyErrors, um zu überprüfen, ob ein Element vorhanden ist, das dem Diktat ein neues Element hinzufügen würde.

In-Place-Wertetausch

>>> a = 10
>>> b = 5
>>> a, b
(10, 5)

>>> a, b = b, a
>>> a, b
(5, 10)

Die rechte Seite der Zuweisung ist ein Ausdruck, der ein neues Tupel erstellt. Die linke Seite der Zuweisung entpackt sofort das (nicht referenzierte) Tupel zu den Namen aund b.

Nach der Zuweisung wird das neue Tupel nicht referenziert und für die Speicherbereinigung markiert, und die Werte sind an gebunden aund bwurden ausgetauscht.

Wie im Python-Tutorial zu Datenstrukturen erwähnt ,

Beachten Sie, dass die Mehrfachzuweisung eigentlich nur eine Kombination aus Tupelpacken und Sequenzentpacken ist.

Lesbare reguläre Ausdrücke

In Python können Sie einen regulären Ausdruck auf mehrere Zeilen aufteilen, Ihre Übereinstimmungen benennen und Kommentare einfügen.

Beispiel für eine ausführliche Syntax (von Dive in Python ):

>>> pattern = """
... ^                   # beginning of string
... M{0,4}              # thousands - 0 to 4 M's
... (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
...                     #            or 500-800 (D, followed by 0 to 3 C's)
... (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
...                     #        or 50-80 (L, followed by 0 to 3 X's)
... (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
...                     #        or 5-8 (V, followed by 0 to 3 I's)
... $                   # end of string
... """
>>> re.search(pattern, 'M', re.VERBOSE)

Beispiel für Namensnamenübereinstimmungen (aus dem HOWTO für reguläre Ausdrücke )

>>> p = re.compile(r'(?P<word>\b\w+\b)')
>>> m = p.search( '(((( Lots of punctuation )))' )
>>> m.group('word')
'Lots'

re.VERBOSEDank der Verkettung von Zeichenfolgenliteralen können Sie auch einen regulären Ausdruck ohne Verwendung ausführlich schreiben .

>>> pattern = (
...     "^"                 # beginning of string
...     "M{0,4}"            # thousands - 0 to 4 M's
...     "(CM|CD|D?C{0,3})"  # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
...                         #            or 500-800 (D, followed by 0 to 3 C's)
...     "(XC|XL|L?X{0,3})"  # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
...                         #        or 50-80 (L, followed by 0 to 3 X's)
...     "(IX|IV|V?I{0,3})"  # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
...                         #        or 5-8 (V, followed by 0 to 3 I's)
...     "$"                 # end of string
... )
>>> print pattern
"^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$"

Entpacken des Funktionsarguments

Sie können eine Liste oder ein Wörterbuch als Funktionsargumente mit *und entpacken **.

Zum Beispiel:

def draw_point(x, y):
    # do some magic

point_foo = (3, 4)
point_bar = {'y': 3, 'x': 2}

draw_point(*point_foo)
draw_point(**point_bar)

Sehr nützliche Verknüpfung, da Listen, Tupel und Diktate häufig als Container verwendet werden.

ROT13 ist eine gültige Codierung für den Quellcode, wenn Sie die richtige Codierungsdeklaration oben in der Codedatei verwenden:

#!/usr/bin/env python
# -*- coding: rot13 -*-

cevag "Uryyb fgnpxbiresybj!".rapbqr("rot13")

Erstellen Sie neue Typen auf voll dynamische Weise

>>> NewType = type("NewType", (object,), {"x": "hello"})
>>> n = NewType()
>>> n.x
"hello"

das ist genau das gleiche wie

>>> class NewType(object):
>>>     x = "hello"
>>> n = NewType()
>>> n.x
"hello"

Wahrscheinlich nicht das Nützlichste, aber schön zu wissen.

Bearbeiten : Der feste Name des neuen Typs sollte NewTypegenau so sein wie bei der classAnweisung.

Bearbeiten : Der Titel wurde angepasst, um die Funktion genauer zu beschreiben.

Kontextmanager und die withAnweisung " "

Eingeführt im PEP 343 , ein Kontext - Manager ist ein Objekt , das für eine Reihe von Aussagen , die als Laufzeitkontext wirkt.

Da die Funktion neue Schlüsselwörter verwendet, wird sie schrittweise eingeführt: Sie ist in Python 2.5 über die __future__Direktive verfügbar . Python 2.6 und höher (einschließlich Python 3) ist standardmäßig verfügbar.

Ich habe die "with" -Anweisung oft verwendet, weil ich denke, dass es ein sehr nützliches Konstrukt ist. Hier ist eine kurze Demo:

from __future__ import with_statement

with open('foo.txt', 'w') as f:
    f.write('hello!')

Was hier hinter den Kulissen passiert, ist, dass die Anweisung "with" das Special __enter__und die __exit__Methoden für das Dateiobjekt aufruft . Ausnahmedetails werden auch an übergeben, __exit__wenn eine Ausnahme aus dem with-Anweisungshauptteil ausgelöst wurde, sodass dort eine Ausnahmebehandlung stattfinden kann.

In diesem speziellen Fall bedeutet dies für Sie, dass die Datei geschlossen wird, wenn die Ausführung außerhalb des Bereichs der withSuite liegt, unabhängig davon, ob dies normal erfolgt oder ob eine Ausnahme ausgelöst wurde. Dies ist im Grunde eine Möglichkeit, allgemeinen Code für die Ausnahmebehandlung zu abstrahieren.

Andere häufige Anwendungsfälle hierfür sind das Sperren mit Threads und Datenbanktransaktionen.

Wörterbücher haben eine get () -Methode

Wörterbücher haben eine 'get ()' - Methode. Wenn Sie d ['key'] ausführen und key nicht vorhanden ist, erhalten Sie eine Ausnahme. Wenn Sie d.get ('key') ausführen, erhalten Sie None zurück, wenn 'key' nicht vorhanden ist. Sie können ein zweites Argument hinzufügen, um dieses Element anstelle von "Keine" zurückzugewinnen, z. B.: D.get ('Schlüssel', 0).

Es ist großartig für Dinge wie das Addieren von Zahlen:

sum[value] = sum.get(value, 0) + 1

Deskriptoren

Sie sind die Magie hinter einer ganzen Reihe von Python-Kernfunktionen.

Wenn Sie einen gepunkteten Zugriff verwenden, um ein Mitglied (z. B. xy) nachzuschlagen, sucht Python zuerst nach dem Mitglied im Instanzwörterbuch. Wenn es nicht gefunden wird, sucht es im Klassenwörterbuch danach. Wenn es im Klassenwörterbuch gefunden wird und das Objekt das Deskriptorprotokoll implementiert, führt Python es aus, anstatt es nur zurückzugeben. Ein Deskriptor ist jede Klasse , die die Geräte __get__, __set__oder __delete__Methoden.

So implementieren Sie Ihre eigene (schreibgeschützte) Version der Eigenschaft mithilfe von Deskriptoren:

class Property(object):
    def __init__(self, fget):
        self.fget = fget

    def __get__(self, obj, type):
        if obj is None:
            return self
        return self.fget(obj)

und Sie würden es genau wie die eingebaute Eigenschaft () verwenden:

class MyClass(object):
    @Property
    def foo(self):
        return "Foo!"

Deskriptoren werden in Python verwendet, um unter anderem Eigenschaften, gebundene Methoden, statische Methoden, Klassenmethoden und Slots zu implementieren. Wenn man sie versteht, kann man leicht erkennen, warum viele Dinge, die früher wie Python-Macken aussahen, so sind, wie sie sind.

Raymond Hettinger hat ein exzellentes Tutorial , das sie viel besser beschreibt als ich.

Bedingte Zuordnung

x = 3 if (y == 1) else 2

Es macht genau das, wonach es sich anhört: "Weisen Sie x 3 zu, wenn y 1 ist, andernfalls weisen Sie x 2 zu". Beachten Sie, dass die Parens nicht notwendig sind, aber ich mag sie für die Lesbarkeit. Sie können es auch verketten, wenn Sie etwas Komplizierteres haben:

x = 3 if (y == 1) else 2 if (y == -1) else 1

Ab einem bestimmten Punkt geht es allerdings etwas zu weit.

Beachten Sie, dass Sie if ... else in einem beliebigen Ausdruck verwenden können. Zum Beispiel:

(func1 if y == 1 else func2)(arg1, arg2) 

Hier wird func1 aufgerufen, wenn y 1 ist, andernfalls func2. In beiden Fällen wird die entsprechende Funktion mit den Argumenten arg1 und arg2 aufgerufen.

Analog gilt auch:

x = (class1 if y == 1 else class2)(arg1, arg2)

Dabei sind Klasse1 und Klasse2 zwei Klassen.

Doctest : Dokumentation und Unit-Test gleichzeitig.

Beispiel aus der Python-Dokumentation:

def factorial(n):
    """Return the factorial of n, an exact integer >= 0.

    If the result is small enough to fit in an int, return an int.
    Else return a long.

    >>> [factorial(n) for n in range(6)]
    [1, 1, 2, 6, 24, 120]
    >>> factorial(-1)
    Traceback (most recent call last):
        ...
    ValueError: n must be >= 0

    Factorials of floats are OK, but the float must be an exact integer:
    """

    import math
    if not n >= 0:
        raise ValueError("n must be >= 0")
    if math.floor(n) != n:
        raise ValueError("n must be exact integer")
    if n+1 == n:  # catch a value like 1e300
        raise OverflowError("n too large")
    result = 1
    factor = 2
    while factor <= n:
        result *= factor
        factor += 1
    return result

def _test():
    import doctest
    doctest.testmod()    

if __name__ == "__main__":
    _test()

Benannte Formatierung

Die% -Formatierung erfordert ein Wörterbuch (gilt auch für die Validierung von% i /% s usw.).

>>> print "The %(foo)s is %(bar)i." % {'foo': 'answer', 'bar':42}
The answer is 42.

>>> foo, bar = 'question', 123

>>> print "The %(foo)s is %(bar)i." % locals()
The question is 123.

Und da local () auch ein Wörterbuch ist, können Sie dies einfach als Diktat übergeben und% -substitions aus Ihren lokalen Variablen haben. Ich denke, das ist verpönt, vereinfacht aber die Dinge.

Neue Stilformatierung

>>> print("The {foo} is {bar}".format(foo='answer', bar=42))

Um weitere Python-Module hinzuzufügen (insbesondere solche von Drittanbietern), scheinen die meisten Benutzer PYTHONPATH-Umgebungsvariablen zu verwenden, oder sie fügen Symlinks oder Verzeichnisse in ihre Site-Package-Verzeichnisse ein. Eine andere Möglichkeit ist die Verwendung von * .pth-Dateien. Hier ist die Erklärung des offiziellen Python-Dokuments:

"Der bequemste Weg [um den Suchpfad von Python zu ändern] besteht darin, eine Pfadkonfigurationsdatei zu einem Verzeichnis hinzuzufügen, das sich bereits im Python-Pfad befindet, normalerweise zum Verzeichnis ... / site-packages /. Pfadkonfigurationsdateien haben die Erweiterung .pth und jede Zeile muss einen einzelnen Pfad enthalten, der an sys.path angehängt wird. (Da die neuen Pfade an sys.path angehängt werden, überschreiben Module in den hinzugefügten Verzeichnissen Standardmodule nicht. Dies bedeutet, dass Sie diesen Mechanismus nicht verwenden können zum Installieren fester Versionen von Standardmodulen.) "

Ausnahme sonst Klausel:

try:
  put_4000000000_volts_through_it(parrot)
except Voom:
  print "'E's pining!"
else:
  print "This parrot is no more!"
finally:
  end_sketch()

Die Verwendung der else-Klausel ist besser als das Hinzufügen von zusätzlichem Code zur try-Klausel, da dadurch vermieden wird, dass versehentlich eine Ausnahme abgefangen wird, die nicht durch den durch die try ... außer -Anweisung geschützten Code ausgelöst wurde.

Siehe http://docs.python.org/tut/node10.html

Ausnahmen erneut erheben :

# Python 2 syntax
try:
    some_operation()
except SomeError, e:
    if is_fatal(e):
        raise
    handle_nonfatal(e)

# Python 3 syntax
try:
    some_operation()
except SomeError as e:
    if is_fatal(e):
        raise
    handle_nonfatal(e)

Die Anweisung 'raise' ohne Argumente in einem Fehlerhandler weist Python an, die Ausnahme mit intaktem ursprünglichen Traceback erneut auszulösen , sodass Sie sagen können: "Oh, sorry, sorry, ich wollte das nicht abfangen, sorry, sorry. ""

Wenn Sie den ursprünglichen Traceback drucken, speichern oder damit experimentieren möchten, können Sie ihn mit sys.exc_info () abrufen. Der Druckvorgang erfolgt wie in Python mit dem Traceback-Modul.

Hauptnachrichten :)

import this
# btw look at this module's source :)

Entschlüsselt :

Das Zen von Python von Tim Peters

Schön ist besser als hässlich.
Explizit ist besser als implizit.
Einfach ist besser als komplex.
Komplex ist besser als kompliziert.
Wohnung ist besser als verschachtelt.
Spärlich ist besser als dicht.
Lesbarkeit zählt.
Sonderfälle sind nicht speziell genug, um gegen die Regeln zu verstoßen.
Obwohl Praktikabilität die Reinheit übertrifft.
Fehler sollten niemals stillschweigend vergehen.
Sofern nicht ausdrücklich zum Schweigen gebracht.
Verweigern Sie angesichts von Zweideutigkeiten die Versuchung zu raten. Es sollte einen - und vorzugsweise nur einen - offensichtlichen Weg geben, dies zu tun.
Obwohl dieser Weg zunächst vielleicht nicht offensichtlich ist, es sei denn, Sie sind Niederländer.
Jetzt ist besser als nie.
Obwohl nie oft besser ist alsgerade jetzt.
Wenn die Implementierung schwer zu erklären ist, ist es eine schlechte Idee.
Wenn die Implementierung leicht zu erklären ist, kann dies eine gute Idee sein.
Namespaces sind eine großartige Idee - lasst uns mehr davon machen!

Vervollständigung der Registerkarte Interaktiver Interpreter

try:
    import readline
except ImportError:
    print "Unable to load readline module."
else:
    import rlcompleter
    readline.parse_and_bind("tab: complete")


>>> class myclass:
...    def function(self):
...       print "my function"
... 
>>> class_instance = myclass()
>>> class_instance.<TAB>
class_instance.__class__   class_instance.__module__
class_instance.__doc__     class_instance.function
>>> class_instance.f<TAB>unction()

Sie müssen auch eine PYTHONSTARTUP-Umgebungsvariable festlegen.

Verschachtelte Listenverständnisse und Generatorausdrücke:

[(i,j) for i in range(3) for j in range(i) ]    
((i,j) for i in range(4) for j in range(i) )

Diese können große Teile des Nested-Loop-Codes ersetzen.

Überlastung des setBedieners für das eingebaute Gerät:

>>> a = set([1,2,3,4])
>>> b = set([3,4,5,6])
>>> a | b # Union
{1, 2, 3, 4, 5, 6}
>>> a & b # Intersection
{3, 4}
>>> a < b # Subset
False
>>> a - b # Difference
{1, 2}
>>> a ^ b # Symmetric Difference
{1, 2, 5, 6}

Weitere Details finden Sie in der Standardbibliotheksreferenz: Set Types