Python-Steuerungssyntax, Funktionen (Python-Lernnotiz ②)

Dieses Mal ist ein Lernprotokoll über Steuerungssyntax und -funktionen.

if-Anweisung

Punkt

• Es gibt kein swhich (benutze if, elif, sonst stattdessen)

#Sie können auf eine solche Eingabe warten
x = int(input("Bitte geben Sie eine Ganzzahl ein: "))

if x < 0:
    x = 0
    print ("Negative Zahl ist Null")
elif x == 0:
    print("Null")
elif x == 1:
    print("Einer")
else:
    print("Mehr")

zur Aussage

Punkt

• Für Elemente in einer beliebigen Sequenz (Liste oder Zeichenfolge) können Sie x in der Reihenfolge innerhalb dieser Sequenz iterieren.
• Wenn Sie die Sequenz während der Iteration ändern müssen, wird empfohlen, eine Kopie zu erstellen und diese zu wiederholen. Es ist zweckmäßig, hierfür die Slice-Notation zu verwenden.

#Messen Sie die Länge einer Zeichenfolge
words = ['cat', 'window', 'defenstrate']
for w in words:
    print(w, len(w))

#Ausgabe
# cat 3
# window 6
# defenstrate 11

#Durchlaufen Sie die Slice-Kopie der gesamten Liste
words = ['cat', 'window', 'defenstrate']
#Machen Sie eine flache Kopie der Liste
for w in words[:]:
    if len(w) > 6:
        words.insert(0, w)
print(words)

#Ausgabe
# ['defenstrate', 'cat', 'window', 'defenstrate']

range () Funktion

Punkt

• Praktisch beim Wiederholen einer Reihe von Zahlen
• Enthält nicht den angegebenen Endpunkt
• Die 10 Werte, die durch "Bereich (10)" erzeugt werden, sind genau die Indizes für jedes Element in einer Sequenz der Länge 10 (die Sequenz kann wiederholt indiziert werden).
• In vielen Fällen ist es jedoch zweckmäßig, die Funktion enumerate () zu verwenden
• Das vom Bereich zurückgegebene Objekt verhält sich wie eine Liste, ist jedoch keine Liste ("iterierbares" Objekt).
• Sparen Sie wirklich Ressourcen, indem Sie keine Listen verwenden

#Iteration nach Reichweite
for i in range(5):
    print(i)

#Ausgabe
# 0
# 1
# 2
# 3
# 4

#Iteration mit Sequenzindex
a = ['Mary', 'had', 'a', 'little', 'lamb']
for i in range(len(a)):
    print(i, a[i])

#Ausgabe
# 0 Mary
# 1 had
# 2 a
# 3 little
# 4 lamb

break and continue-Anweisungen, sonst Klausel in der Schleife

Punkt

• Die break-Anweisung unterbricht die for- oder while-Schleife wie in der C-Sprache.
• Wie die C-Sprache überspringt die continue-Anweisung den Rest der Schleife und fährt mit der nächsten Iteration fort.
• Sie können auch eine else-Klausel für oder während angeben
• For for, else wird aufgerufen, wenn die Liste erschöpft ist
• Im Fall von while wird else aufgerufen, wenn der bedingte Ausdruck nicht erfüllt ist

for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, 'equals', x, '*', n//x)
            break
    else:
        #Dies hängt sonst von ab
        #Wenn Sie den Bruch in der Schleife nicht finden können
        print(n, 'is a prime number')

#Ausgabe
# 2 is a prime number
# 3 is a prime number
# 4 equals 2 * 2
# 5 is a prime number
# 6 equals 2 * 3
# 7 is a prime number
# 8 equals 2 * 4
# 9 equals 3 * 3

pass-Anweisung

Punkt

• Die pass-Anweisung macht nichts
• Verwenden Sie diese Option, wenn Sie eine Anweisung syntaktisch benötigen, aber nichts programmgesteuert ausführen müssen
• Wird auch häufig verwendet, um die kleinste Klasse zu generieren
• Wenn Sie neuen Code schreiben, können Sie ihn als Platzhalter in den Hauptteil einer Funktion oder Bedingung einfügen, um über eine abstraktere Ebene nachzudenken.

while True:
    pass #Mach nichts Strg+Warten Sie, bis Sie mit C fertig sind

#Generieren Sie die kleinste Klasse
class MyEmptyClass
    pass

#Funktionsdefinition
def initLog(*args):
    pass #Nach der Implementierung löschen

Funktionsdefinition

Punkt

• Sie können ein Zeichenfolgenliteral in der ersten Anweisung des Funktionskörpers verwenden (dies ist die Dokumentationszeichenfolge der Funktion). Dies ist eine gute Tat, also machen Sie es sich zur Gewohnheit.
• Es ist praktisch, eine Dokumentzeichenfolge zu schreiben, damit das Dokument automatisch generiert werden kann.
• Globale Variablen können grundsätzlich nur in Funktionen referenziert werden
• Sie können keinen Wert direkt zuweisen (sofern nicht in der Anweisung "global" angegeben).
• Die beim Aufruf einer Funktion tatsächlich übergebenen Argumente werden zum Zeitpunkt des Aufrufs zur lokalen Symboltabelle der Funktion hinzugefügt.
• Bei Objekten wird ein Verweis auf das Objekt übergeben
• Funktionen ohne return-Anweisung geben None zurück

def fib(n):
    """Zeigen Sie Fibonacci-Serien bis zu n an"""
    a, b = 0, 1
    while a < n:
        print(a, end=' ')
        a, b = b, a+b
    print()

fib(2000)

#Ausgabe
# 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Weiter zur Funktionsdefinition

Standardwert des Arguments

Punkt

• Der Standardwert kann für das Argument definiert werden
• Die Auswertung des Standardwerts erfolgt in dem Bereich, in dem die Definition bei der Definition der Funktion geschrieben wird (Beispiel ①).
• Beachten Sie, dass die Standardwertauswertung nur einmal erfolgt
• Wenn der Standardwert ein variables Objekt wie eine Liste oder ein Wörterbuch ist, wirkt sich dies darauf aus (Beispiel 2).

#Beispiel ①
i = 5

def f(arg=i):
    print(arg)

i = 6
f()

#Ausgabe
# 5

#Beispiel ②
def f(a, L=[]):
    L.append(a)
    return L

print(f(1))
print(f(2))
print(f(3))

#Ausgabe
# [1]
# [1, 2]
# [1, 2, 3]

Schlüsselwortargument

Punkt

• Funktionen können Schlüsselwortargumente annehmen
• Wenn Sie eine Funktion aufrufen, muss das Positionsargument an erster Stelle und das Schlüsselwortargument an erster Stelle stehen.
• Alle Schlüsselwortargumente müssen mit denen übereinstimmen, die in den formalen Argumenten der Funktionsdefinition geschrieben sind, aber die Reihenfolge spielt keine Rolle.
• Das Argument kann den Wert nur einmal annehmen (doppelte Argumentspezifikation ist ungültig)

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print("-- This parrot wouldn't", action, end=' ');

#Sie können eines der folgenden Formulare aufrufen
parrot(1000)                                         #1 Positionsargument
parrot(voltage=1000)                                 #1 Schlüsselwortargument
parrot(voltage=100000000, action='VOOOOOM')          #2 Schlüsselwortargumente
parrot(action='VOOOOOOOM', voltage=1000000)          #2 Schlüsselwortargumente
parrot('a million', 'bereft of life', 'jump')        #3 Positionsargumente
parrot('a tousand', state='pushing up the daisies')  #1 Positionsargument 1 Schlüsselwortargument

#Der nächste Anruf ist ungültig
# parrot()                     #Fehlende erforderliche Argumente
# parrot(voltage=5.0, 'dead')  #Nicht-Keyword-Argument nach Keyword-Argument
# parrot(110, voltage=220)     #Das gleiche Argument zweimal gegeben
# parrot(actor='John Cleese')  #Unbekanntes Schlüsselwortargument

• Wenn das formale Argument in der Form "** name" endet, erhält dieses Argument ein Wörterbuch
• Dieses Wörterbuch enthält alle Schlüsselwortargumente mit Ausnahme der Schlüsselwörter, die den formalen Argumenten entsprechen (dh Sie können Schlüsselwörter verwenden, die nicht in den formalen Argumenten enthalten sind).
• Kann auch mit dem Format * name kombiniert werden
• Im folgenden Beispiel wird das Ergebnis der key () -Methode verwendet, wenn der Inhalt des Schlüsselwortwörterbuchs angezeigt wird. Dies legt die Anzeigereihenfolge der Argumente fest.

def cheeseshop(kind, *arguments, **keywords):
    print("-- Do you have any", kind, "?")
    print("-- I'm sorry, we're all out of", kind)
    for arg in arguments:
        print(arg)
        print("-" * 40)
        keys = sorted(keywords.keys())
        for kw in keys:
            print(kw, ":", keywords[kw])
            
cheeseshop("Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.",
           shopkeeper="Michael Palin",
           client="John Cleese",
           sketch="Cheese Shop Sketch")

#Ausgabe
# -- Do you have any Limburger ?
# -- I'm sorry, we're all out of Limburger
# It's very runny, sir.
# ----------------------------------------
# client : John Cleese
# shopkeeper : Michael Palin
# sketch : Cheese Shop Sketch
# It's really very, VERY runny, sir.
# ----------------------------------------
# client : John Cleese
# shopkeeper : Michael Palin
# sketch : Cheese Shop Sketch

Liste der optionalen Argumente

Punkt

• Kann eine variable Anzahl von Argumenten akzeptieren
• Argumente sind in Taples gruppiert
• Normale Argumente können vor die variable Anzahl von Argumenten gestellt werden
• Fügen Sie am Ende der formalen Argumentliste eine variable Anzahl von Argumenten ein (da alle übrigen an die Funktion übergebenen Argumente berücksichtigt werden).
• Im Format * args können alle nachfolgenden formalen Argumente nur als Schlüsselwortargumente verwendet werden, nicht als Positionsargumente.

def concat(*args, sep="/"):
    return sep.join(args)

print(concat("earth", "mars", "venus"))

#Ausgabe
# earth/mars/venus

print(concat("earth", "mars", "venus", sep="."))

#Ausgabe
# earth.mars.venus

Argumentliste entpacken

Punkt

• Es gibt eine bequeme Möglichkeit in Situationen, in denen das gewünschte Argument bereits eine Liste oder ein Tapple ist und Sie es für eine Funktion entpacken müssen, für die ein positioniertes Argument erforderlich ist. Mit der Funktion * range und dem Format * args können Sie Listen und Taples einfach entpacken

>>> list(range(3, 6))
[3, 4, 5]

>>> args = [3, 6]
>>> list(range(*args))
[3, 4, 5]

• Ebenso kann das Wörterbuch mit dem Operator ** als Schlüsselwortargument übergeben werden.

>>> def parrot(voltage, state='a stiff', action='voom'):
...     print("-- This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

Lambda-Ausdruck

Punkt

• Sie können eine kleine anonyme Funktion mit dem Schlüsselwort "Lambda" schreiben
• Es gibt eine syntaktische Einschränkung, dass dieses Format nur einen einzigen Ausdruck haben kann

def make_incrementor(n):
    return lambda x: x + n #Gibt eine anonyme Funktion zurück

f = make_incrementor(42)

f(0) # 42
f(1) # 43

Dokumentzeichenfolge (docstring)

Punkt

• Die erste Zeile sollte immer eine kurze und präzise Zusammenfassung des Objektzwecks sein
• Diese Zeile beginnt mit einem Großbuchstaben und endet mit einem Punkt
• Wenn es eine Fortsetzung gibt, lassen Sie die zweite Zeile der Dokumentationszeichenfolge leer und trennen Sie die Zusammenfassung visuell von den anderen Beschreibungen.
• Die Übergangslinie sollte Absätze verwenden, um zu beschreiben, wie sie aufgerufen wird und welche Nebenwirkungen sie hat.
• Der Python-Parser entfernt nicht die Einrückung mehrzeiliger Zeichenfolgenliterale. Wenn Sie sie entfernen möchten, verwenden Sie das Dokumentationstool.

def my_function():
    """Do nothing, but document it.
    
    No, really, it doesn't do anything.
    """
    pass

print(my_function.__doc__)

#Ausgabe
# Do nothing, but document it.
# 
#     No, really, it doesn't do anything.

Funktionsanmerkung (Funktionsanmerkung)

Punkt

• Informationen zu Typmetadaten können hinzugefügt werden
• Wird als Wörterbuch im Attribut __annotations__ der Funktion gespeichert und hat keine Auswirkungen auf andere Teile der Funktion
• Argumentanmerkungen können definiert werden, indem dem Argumentnamen ein Doppelpunkt und ein Ausdruck folgen.
• Die Annotation des Rückgabewerts wird durch Einfügen eines Literal -> vor dem Doppelpunkt am Ende der def-Anweisung und zwischen der formalen Argumentliste definiert.

def f(ham: str, eggs: str = 'eggs') -> str:
    print("Annotations:", f.__annotations__)
    print("Arguments:", ham, eggs)
    return ham + ' and ' + eggs

f('spam')

#Ausgabe
# Annotations: {'ham': <class 'str'>, 'eggs': <class 'str'>, 'return': <class 'str'>}
# Arguments: spam eggs
# 'spam and eggs'

Codierungsstil

Punkt

• Einzug mit 4 Leerzeichen, keine Tabulatoren
• Zeilen mit 79 Zeichen oder weniger umbrechen
• Verwenden Sie Leerzeilen, um Funktionen, Klassen und große Blöcke innerhalb von Funktionen zu trennen
• Kommentieren Sie Kommentarzeilen nach Möglichkeit unabhängig
• Verwenden Sie docstring
• Setzen Sie ein Leerzeichen um den Operator und nach dem Komma, aber nicht nur innerhalb der Klammern Beispiel: a = f (1, 2) + g (3, 4)
• Verwenden Sie CamelCase für Klassen und Kleinbuchstaben_mit_underscores für Funktionen und Methoden
• Verwenden Sie immer self als erstes Argument der Methode
• Verwenden Sie zum Codieren das Standard-UTF-8 oder ASCII