[Python-Tutorial] Kontrollstruktur-Tool

Einführung

Dies ist ein Versuch, die 3. Ausgabe des Python-Tutorials zu lesen und zu notieren, was Sie gelernt haben.

Python Tutorial 3rd Edition

Und wenn ich mit dem Lesen fertig bin, möchte ich diese Prüfung ablegen Am Ende hat der Test begonnen ...!

** Lass uns anfangen! ** **.

Grundprüfung zur Python 3 Engineer-Zertifizierung

Ich hoffe es geht weiter, ich hoffe es geht weiter

Kontrollstruktur-Tool

if-Anweisung

>>> x = int(input("Bitte geben Sie eine Ganzzahl ein: "))
Bitte geben Sie eine Ganzzahl ein: 42
>>> if x < 0:
...     x = 0
...     print('Negative Zahl ist Null')
... elif x == 0:
...     print('Null')
... elif x == 1:
...     print('Einer')
... else:
...     print('Mehr')
...
Mehr

zur Aussage

• Wiederholen Sie die Elemente in einer beliebigen Reihenfolge (Liste oder Zeichenfolge) in der Reihenfolge innerhalb dieser Reihenfolge

>>> #Messen Sie die Länge einer Zeichenfolge:
... words = ['cat', 'window', 'defenestrate']
>>> for w in words:
...     print(w, len(w))
...
cat 3
window 6
defenestrate 12

• Es wird empfohlen, eine Kopie zu erstellen und zu wiederholen, wenn die wiederholte Sequenz geändert werden muss
• Durch Wiederholen der Sequenz wird kein implizites Kopieren durchgeführt

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

range () Funktion

• Die integrierte Funktion range () ist nützlich, wenn Sie über eine Reihe von Zahlen iterieren.
• Generieren Sie die gleiche Anzahl von Etagen

>>> for i in range(5):
...     print(i)
...
0
1
2
3
4

• Der angegebene Abschlusswert ist nicht enthalten
• Der von range (10) erzeugte Wert von 10 ist nur ein Index für jedes Element in einer Folge von Länge 10. --range () kann mit einer anderen Zahl als 0 beginnen
• Sie können auch ein Inkrement angeben (Schritt)

range(5, 10)
→ 5 bis 9
range(0, 10, 3)
→ 0, 3, 6, 9
range(-10, -100, -30)
→ -10, -40, -70

• Wenn Sie am Index der Sequenz wiederholen möchten, können Sie range () undlen ()wie folgt kombinieren.
• In solchen Fällen ist es zweckmäßig, die Funktion enumerate () zu verwenden.

>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
...     print(i, a[i])
...
0 Mary
1 had
2 a
3 little
4 lamb

• Das von der Funktion range () zurückgegebene Objekt verhält sich in vielerlei Hinsicht wie eine Liste, jedoch nicht wie eine Liste.
• Ein Objekt, das kontinuierlich Elemente in der gewünschten Reihenfolge zurückgibt, indem es wiederholt wird, wodurch Platz gespart wird.
• Ein solches Objekt heißt ** iterable ** ――Dies bedeutet etwas, das Gegenstände kontinuierlich liefert, bis es wird, und etwas, das als Ziel für Funktionen und Strukturen geeignet ist, die solche Dinge erwarten.
• Die Funktion oder Struktur, die einen wiederholbaren Körper erwartet, heißt ** Iterator **.
• Die Funktion list (), die eine Liste aus einem wiederholbaren Text erstellt, ist auch ein Iterator.

>>> list(range(5))
[0, 1, 2, 3, 4]

break and continue-Anweisungen, sonst Klausel in der Schleife

• Die break Anweisung durchbricht die for oder while Schleife
• Diesen Schleifenanweisungen wird eine else -Klausel hinzugefügt
• Die else -Klausel wird ausgeführt, wenn die Schleife aufgrund der Erschöpfung der Liste endet oder der bedingte Ausdruck false wird, und nicht ausgeführt, wenn die Schleife mit der break-Anweisung endet.

>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...             print(n, 'equals', x, '*', n//x)
...             break
...     else:
...         #Wenn Sie den Bruch in der Schleife nicht finden können
...         print(n, 'is a prime number')
...
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

• Die Anweisung continue überspringt den Rest der Schleife und fährt mit der nächsten Iteration fort

>>> for num in range(2, 10):
...     if num % 2 == 0:
...         print("Found an even number", num)
...         continue
...     print("Found a number", num)
Found an even number 2
Found a number 3
Found an even number 4
Found a number 5
Found an even number 6
Found a number 7
Found an even number 8
Found a number 9

pass-Anweisung

Verwenden Sie diese Option, wenn Sie nichts programmgesteuert ausführen müssen

>>> while True:
...     pass #Tastaturunterbrechung mit starkem Gewicht(Ctrl+C)Warten auf
...

Wird oft verwendet, um die kleinste Klasse zu generieren

>>> class MyEmptyClass:
...     pass
...

Eine andere Verwendung der pass -Anweisung besteht darin, sie als Platzhalter in den Hauptteil einer Funktion oder Bedingung einzufügen, wenn Sie neuen Code schreiben, damit Sie über die abstrakte Ebene nachdenken können.

>>> def initlog(*args):
...     pass #Vergessen Sie nicht zu implementieren!
...

Funktionsdefinition

• Das Schlüsselwort def ist der Anfang der Funktionsdefinition, und Sie müssen den Funktionsnamen und die formale Argumentliste in Klammern schreiben. --Schreiben Sie die Anweisung des Funktionskörpers, der in der nächsten Zeile eingerückt ist

Eine Funktion, die die Fibonacci-Reihe bis zu einer beliebigen Obergrenze schreibt

>>> def fib(n): #Exportieren Sie Fibonacci-Serien bis zu 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()
...
>>> #Nennen wir diese Funktion
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Weiter zur Funktionsdefinition

• Es ist auch möglich, eine Funktion mit einer variablen Anzahl von Argumenten zu definieren ――Es gibt drei Formen, die kombiniert werden können.

Standardwert des Arguments

――Die am häufigsten verwendete Form

• Die folgenden Funktionen können auf verschiedene Arten aufgerufen werden
• Geben Sie nur die erforderlichen Argumente an
  • ask_ok('Do you really want to quit?')
• Geben Sie ein optionales Argument an
  • ask_ok('OK to overwrite the file?', 2)
• Geben Sie alle Argumente
  • ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')

def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
    while True:
        ok = input(prompt)
        if ok in ('y', 'ye', 'yes'):
            return True
        if ok in ('n', 'no', 'nop', 'nope'):
            return False
        retries = retries - 1
        if retries < 0:
            raise OSError('Nicht kooperativer Benutzer')
        print(complaint)

** Die Standardwertauswertung erfolgt nur einmal. ** **. Dies wirkt sich aus, wenn der Standardwert ein veränderbares Objekt ist, nämlich eine Instanz einer Liste, eines Wörterbuchs und der meisten Klassen.

Die folgende Funktion sammelt beispielsweise die im Aufruf übergebenen Argumente

>>> def f(a, L=[]):
...     L.append(a)
...     return L
...
>>> print(f(1))
[1]
>>> print(f(2))
[1, 2]
>>> print(f(3))
[1, 2, 3]
>>>

Wenn Sie nicht möchten, dass die Standardwerte zwischen Aufrufen geteilt werden, können Sie diese Funktion folgendermaßen schreiben:

>>> def f(a, L=None):
...     if L is None:
...             L = []
...     L.append(a)
...     return L
...
>>> print(f(1))
[1]
>>> print(f(2))
[2]
>>> print(f(3))
[3]

Schlüsselwortargument

• Die Funktion kann auch ** Schlüsselwortargument ** in Form von "Schlüsselwort = Wert" annehmen.

>>> def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
...     print("-- This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.")
...     print("-- It's", state, "!")
...

Diese Funktion verwendet ein erforderliches Argument (Spannung), drei optionale Argumente (Status, Aktion, Typ) und kann in einer der folgenden Formen aufgerufen werden:

>>> #Ein Positionsargument
>>> parrot(1000)
-- This parrot wouldn't voom if you put 1000 volts through it.
-- It's a stiff !
>>> #Ein Schlüsselwortargument
>>> parrot(voltage=1000)
-- This parrot wouldn't voom if you put 1000 volts through it.
-- It's a stiff !
>>> #Zwei Schlüsselwortargumente
>>> parrot(voltage=1000000, action='VOOOOOM')
-- This parrot wouldn't VOOOOOM if you put 1000000 volts through it.
-- It's a stiff !
>>> #Drei Schlüsselwortargumente
>>> parrot(action='VOOOOOM', voltage=1000000)
-- This parrot wouldn't VOOOOOM if you put 1000000 volts through it.
-- It's a stiff !
>>> #3 Positionsargumente
>>> parrot('a million', 'bereft of life', 'jump')
-- This parrot wouldn't jump if you put a million volts through it.
-- It's bereft of life !
>>> #1 Positionsargument, 1 Schlüsselwortargument
>>> parrot('a thousand', state='pushing up the daisies')
-- This parrot wouldn't voom if you put a thousand volts through it.
-- It's pushing up the daisies !

Der folgende Aufruf ist jedoch ungültig

>>> #Fehlende erforderliche Argumente
>>> parrot()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: parrot() missing 1 required positional argument: 'voltage'
>>> #Nicht-Keyword-Argument nach Keyword-Argument
>>> parrot(voltage=5.0, 'dead')
  File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument
>>> #Das gleiche Argument zweimal gegeben
>>> parrot(110, voltage=220)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: parrot() got multiple values for argument 'voltage'
>>> #Unbekanntes Schlüsselwortargument
>>> parrot(actor='John Cleese')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: parrot() got an unexpected keyword argument 'actor'

Wenn Sie eine Funktion aufrufen, müssen ** Positionsargumente an erster Stelle stehen und Schlüsselwortargumente nach **

Alle Schlüsselwortargumente müssen mit denen übereinstimmen, die in den formalen Argumenten der Funktionsdefinition geschrieben sind (der Argumentakteur ist in der Papageienfunktion ungültig), aber die Reihenfolge spielt keine Rolle.

Dies gilt auch für nicht optionale Argumente (zB "Papagei (Spannung = 1000)" ist ebenfalls gültig).

Das Argument kann nur einmal einen Wert annehmen. Das Folgende ist ein Beispiel für einen Fehler aufgrund dieser Einschränkung. Ein Typfehler ist aufgetreten, weil das Schlüsselwortargument "a" von function () mehrere Werte hat.

>>> def function(a):
...     pass
...
>>> function(0, a=0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: function() got multiple values for argument 'a'

Wenn das formale Argument in Form eines "**" - Namens 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. Mit anderen Worten, in dieser Form können Schlüsselwörter verwendet werden, die nicht im formalen Argument enthalten sind.

Es kann auch in Kombination mit dem Namensformat * verwendet werden. (Der Name "*" muss vor dem Namen "**" stehen.)

In diesem Format wird ein Taple an die Funktion übergeben, das alle positionsspezifischen Argumente enthält, die nicht im formalen Argument enthalten sind. Daher, wenn Sie die folgende Funktion definieren

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

Sie können es so nennen und die Ausgabe wird sein:

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

Beachten Sie, dass beim Anzeigen des Inhalts des Wörterbuchs "Schlüsselwörter" zunächst die Ergebnisse der Methode "key ()" sortiert und eine Liste der Schlüsselwortargumente erstellt werden. Ist dies nicht der Fall, ist die Anzeigereihenfolge der Argumente undefiniert.

Liste der optionalen Argumente

• Eine Methode zum Schreiben einer Funktion, damit sie mit einer beliebigen Anzahl von Argumenten aufgerufen werden kann
• Nicht oft verwendet
• Die Argumente daraus werden in einem Taple gesammelt.
• Vor diese variable Anzahl von Argumenten kann ein normales Argument gestellt werden.

>>> def write_multiple_items(file, separator, *args):
...     file.write(separator.join(args))

Argumente mit variabler Länge werden am Ende der formalen Argumentliste platziert. Dies liegt daran, dass alle anderen an die Funktion übergebenen Argumente berücksichtigt werden. Im * args-Format sind alle formalen Argumente danach "Nur-Schlüsselwort" -Argumente. Mit anderen Worten, es kann nur als Schlüsselwortargument verwendet werden, nicht als Positionsargument.

>>> def concat(*args, sep="/"):
...     return sep.join(args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'

Argumentliste entpacken

Die gegenteilige Situation ist, dass das, was Sie ein Argument sein möchten, bereits eine Liste oder ein Tapple ist und Sie es für eine Funktion entpacken müssen, die ein positioniertes Argument erfordert.

Beispielsweise erwartet die integrierte Funktion range () separate Argumente für Start und Stopp.

Wenn Sie sie nicht einzeln haben, können Sie entpackte Argumente aus einer Liste übergeben oder tappeln, indem Sie die Funktion mit dem Operator * aufrufen.

>>> #Gewöhnlicher Anruf mit individuellen Argumenten
>>> list(range(3, 6))
[3, 4, 5]
>>> args = [3, 6]
>>> #Aufruf mit entpackten Argumenten aus der Liste
>>> list(range(*args))
[3, 4, 5]

Ebenso können Sie den Operator ** verwenden, um ein Wörterbuch als Schlüsselwortargument zu übergeben.

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

--Verwenden Sie das Schlüsselwort lambda, um eine kleine anonyme Funktion zu multiplizieren --lambda a, b: a + b ist eine Funktion, die die Summe zweier Argumente zurückgibt

• Lambda-Funktionen können überall dort verwendet werden, wo ein Funktionsobjekt benötigt wird
• Dieses Format hat jedoch eine syntaktische Einschränkung, dass nur ein einziger Ausdruck beliebt ist. ――In semantischer Hinsicht ist diese Form nur eine syntaktische Zuckerbeschichtung auf einer gewöhnlichen Funktionsdefinition.
• Wie die Definition der verschachtelten Funktion kann auch die Lambda-Funktion auf die Variablen in dem sie umgebenden Bereich verweisen.

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43

Das Obige ist ein Beispiel für die Rückgabe einer Funktion unter Verwendung eines Lambda-Ausdrucks. Eine andere Verwendung ist die Übergabe einer kleinen Funktion als Argument

>>> pairs = [(1, 'one'), (2, 'tow'), (3, 'three'), (4, 'four')]
>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'tow')]

Dokumentzeichenfolge (docstring)

• Die erste Zeile sollte immer eine kurze und präzise Zusammenfassung des Objektzwecks sein
• Geben Sie nichts anderes wie den Namen oder den Typ des Objekts an
  (außer wenn der Funktionsname bereits ein Verb ist, das sein Verhalten beschreibt)
• Diese Zeile beginnt mit einem Großbuchstaben und endet mit einem Punkt
• Wenn eine Fortsetzung vorhanden ist, lassen Sie die zweite Zeile der Dokumentationszeichenfolge leer, um die Zusammenfassung visuell von anderen Beschreibungen zu trennen.
• Verwenden Sie in den folgenden Zeilen Absätze, um zu beschreiben, wie ** und ** Nebenwirkungen ** des Objekts aufgerufen werden.
• Der Python-Parser entfernt den Einzug mehrzeiliger Zeichenfolgenliterale nicht. Wenn Sie ihn also entfernen möchten, müssen Sie ihn im Dokumentverarbeitungstool ausführen.
• Zunächst wird die nicht leere Zeile nach der ersten Zeile als Grundlage für das Einrücken der gesamten Dokumentzeichenfolge verwendet.
  (Die erste Zeile kann nicht verwendet werden. Dies erfolgt in der Regel unmittelbar nach dem Anführungszeichen. , Die Anzahl der Einrückungen spiegelt sich nicht im Literalkörper der Zeichenkette wider.) --Entfernen Sie die "äquivalenten" Leerzeichen von diesem Einzugsbetrag ab dem Beginn jedes Geschäfts in der Zeichenfolge.

Das Folgende ist ein Beispiel für eine mehrzeilige "Dokumentzeichenfolge" (beachten Sie den Teil, der von "doc" aufgerufen wird).

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

        No, really, it doesn't do anything.

Funktionsanmerkung (Funktionsanmerkung)

• Funktionsanmerkung ist die Option einer Person
• Geben Sie Metadateninformationen ein, die in benutzerdefinierten Funktionen verwendet werden --Anmerkungen werden als Wörterbücher im Attribut __annotations__ der Funktion gespeichert.
• Beeinflusst keine anderen Teile der Funktion --Die Argumentanmerkung kann definiert werden, indem dem Argumentnamen ein Doppelpunkt und ein Ausdruck folgen. Dieser Ausdruck wird ausgewertet und wird zum Wert der Annotation. --Die Annotation des Rückgabewerts wird definiert, indem ein Literal "->" und ein Ausdruck vor dem letzten Doppelpunkt für "def" Minuten und zwischen der formalen Argumentliste eingefügt werden.

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

Codierungsstil (nur die Hauptpunkte aus PEP8)

--Indent mit 4 Leerzeichen, keine Tabulatoren

• Zeilen mit maximal 79 Zeichen umbrechen
• Verwenden Sie Leerzeilen, um Funktionen, Klassen und noch größere Blöcke innerhalb von Funktionen zu trennen
• Wenn möglich unabhängige Kommentarzeilen --Verwenden Sie die Dokumentzeichenfolge
• Setzen Sie ein Leerzeichen um den Operator oder nach dem Komma, aber nicht nur innerhalb der Klammern
• a = f(1, 2) + g(3, 4)
• Konsistente Benennung von Klassen und Funktionen --Camel Case in der Klasse --SnakeCase für Funktionen und Methoden
• Die Kodierung sollte UTF-8 oder einfaches ASCII sein
• Verwenden Sie keine Nicht-ASCII-Zeichen in Bezeichnern im Code, die von Personen gelesen oder verwaltet werden können, die andere Wörter sprechen

der Begriff

Reihenfolge

• Ein Sequenztyp ist eine Sammlung geordneter Elemente wie eine Zeichenfolge oder eine Liste.
• Der integrierte Typ enthält 6 Sequenztypen. --Zeichenkette --Unicode-Zeichenfolge --Aufführen --Taple --Puffer --xrange Objekt

Wiederholbar

• Die Struktur, die iteriert werden kann, heißt iterabel. --Iteration ist "Wiederholen" und "Zugreifen auf das nächste Element"
• Als Beispiel ein Objekt, das mit einer for-Anweisung gedreht werden kann
• Genau genommen ein Objekt, das ein Iterator sein kann

Iterator

--Iterierbares Objekt, das sich an den Status erinnert (wo es kursiv geschrieben wurde) --Iterator ist eines der iterierbaren Objekte

• Mit der Iter-Funktion können Sie aus einem iterierbaren Objekt einen Iterator erstellen.
• Der Iterator kann den Status mit der nächsten Methode vorrücken. Wenn eine Iteration nicht mehr möglich ist (in diesem Fall ist das letzte Element erreicht), wird eine Ausnahme namens StopIteration ausgelöst.
• Es ist nicht nur die nächste Funktion, die den Iterator voranbringen kann

Platzhalter

• Maßnahmen zur vorübergehenden Sicherung eines Platzes bis zur Eingabe des offiziellen Wertes
• http://wa3.i-3-i.info/word118.html

Auspacken

Wenn die rechte Seite ein Tapple ist, können Sie den Inhalt erweitern, indem Sie mehrere Variablen auf der linken Seite platzieren. Dies nennt man Sequenzentpacken, aber ich verstehe die Verwendung und Bedeutung des Wortes "entpacken" nicht ganz ... \ (^ o ^) /

Gleiche Anzahl von Etagen

Ich bin nicht sicher ... \ (^ o ^) /

Referenzinformationen

• http://note.crohaco.net/2016/python-iterator-generator-and-tshirt-me/