Versteckte Funktionen von Python

Question

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

• Versuchen Sie, die Antworten auf den Kern von Python zu beschränken.
• Ein Merkmal pro Antwort.
• Geben Sie ein Beispiel und eine kurze Beschreibung der Funktion, nicht nur einen Link zur Dokumentation.
• Beschriften Sie das Merkmal mit einem Titel in der ersten Zeile.

Schnelle Links zu den Antworten:

• Auspacken von Argumenten
• Hosenträger
• Verkettung von Vergleichsoperatoren
• Dekorateure
• Standardargumente Gotchas / Gefahren von veränderbaren Standardargumenten
• Deskriptoren
• Wörterbuch Standard .get Wert
• Docstring-Tests
• Ellipsis Slicing-Syntax
• Aufzählung
• Für/Sonst
• Funktion als iter()-Argument
• Generator-Ausdrücke
• import this
• In Place Value Swapping
• Liste Stepping
• __missing__ Artikel
• Mehrzeiliger Regex
• Formatierung benannter Zeichenketten
• Verschachtelte Listen/Generator-Verständnisse
• Neue Typen zur Laufzeit
• .pth Dateien
• ROT13 Kodierung
• Regex-Fehlersuche
• Senden an Generatoren
• Tabulatorvervollständigung im Interaktiven Dolmetscher
• Ternäre Expression
• try/except/else
• Auspacken+ print() Funktion
• with Anweisung

Answer 1

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

Answer 2

Ab Version 2.5 haben Dicts eine spezielle Methode __missing__ die bei fehlenden Einträgen 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 Unterklasse dict in collections genannt. defaultdict die so ziemlich 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 Dicts in reguläre Dicts zu konvertieren, bevor sie an Funktionen übergeben werden, die solche Unterklassen nicht erwarten. Eine Menge Code verwendet d[a_key] und fängt KeyErrors ab, um zu prüfen, ob ein Element existiert, das ein neues Element zum Diktat hinzufügen würde.

Answer 3

Austausch von Werten an Ort und Stelle

>>> 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 erzeugt. Die linke Seite der Zuweisung packt dieses (nicht referenzierte) Tupel sofort in die Namen a y b .

Nach der Zuweisung wird das neue Tupel nicht referenziert und für die Garbage Collection markiert, und die Werte, die an a y b ausgetauscht worden sind.

Wie in der Python-Tutorial Abschnitt über Datenstrukturen ,

Beachten Sie, dass die Mehrfachzuweisung eigentlich nur eine Kombination aus Tupel-Packing und Sequence-Unpacking ist.

Answer 4

Lesbare reguläre Ausdrücke

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

Beispiel für eine ausführliche Syntax (aus Eintauchen 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 Namensübereinstimmungen (von Reguläre Ausdrücke HOWTO )

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

Sie können eine Regex auch ausführlich schreiben, ohne re.VERBOSE dank der Verkettung von String-Literalen.

>>> 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})$"

Answer 5

Entpacken von Funktionsargumenten

Sie können eine Liste oder ein Wörterbuch als Funktionsargumente auspacken, indem Sie * y ** .

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 Abkürzung, da Listen, Tupel und Dicts häufig als Container verwendet werden.