Erste Python ~ Codierung 2 ~

Zielperson

Dies ist eine Fortsetzung des vorherigen Artikels (https://qiita.com/kuroitu/items/8542b88d486d1dbf92a5). In diesem Artikel verschieben wir das Thema in Python-Listen, bedingte Verzweigung und Schleifenverarbeitung basierend auf dem vorherigen Artikel [graph_plot.py](https://qiita.com/kuroitu/items/8542b88d486d1dbf92a5#draw graph). .. Wenn es Ihnen nichts ausmacht, alles zu überspringen, gehen Sie zu [Diskontinuierliche Funktion zeichnen](#Eine diskontinuierliche Funktion zeichnen).

Inhaltsverzeichnis

• [Liste von Python](Liste von #python)
• [Bedingte Verzweigungs- und Schleifenverarbeitung](# Bedingte Verzweigungs- und Schleifenverarbeitung)
• [if-Anweisung](# if-Anweisung)

Liste von Python

Im vorherigen Artikel (https://qiita.com/kuroitu/items/8542b88d486d1dbf92a5#Wie man numpy verwendet) habe ich erwähnt, dass es in Python keine Arrays gibt. Stattdessen wird Python standardmäßig mit einer Datenstruktur geliefert, die als Liste bezeichnet wird. Dieses Mal werde ich ein wenig darauf eingehen.

Was ist eine Liste?

Beginnen wir mit einer kurzen Beschreibung der Liste.

x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x)

x.append(10)
print(x)

#print(x + 3)
#TypeError tritt auf

print(x + [3])
print(x * 3)

x = np.array(x)
print(x)
x = list(x)
print(x)

Listen haben ein ähnliches Konzept wie Arrays und können wie folgt verwendet werden:

list_sample.py

x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x)

Haben Sie bemerkt, dass das Ausgabeergebnis das gleiche ist wie das in diesem x definierte "x", [numpy_calc.py](https://qiita.com/kuroitu/items/8542b88d486d1dbf92a5#numpy use)? Mit anderen Worten, Sie können sehen, dass Listen und Arrays ähnliche Datenstrukturen haben. Der größte Unterschied besteht darin, dass die Datengröße variabel ist.

list_sample.py

x.append(10)
print(x)

10 wurde hinzugefügt. Diese Methode "Anhängen" ist eine Funktion [^ 1], über die die Datenstruktur des Listentyps verfügt, und dient zum Hinzufügen eines Elements. Der Versuch, dasselbe mit einem Numpy-Array zu tun, führt natürlich nur zu einem Fehler. In numpy müssen Sie es irgendwo (intern) kopieren, um die Größe des einmal definierten Arrays zu ändern. Indem Sie der Punkteliste im Voraus eine große Menge an Speicher zuweisen, können Sie die Zeit sparen, die zum Zuweisen von Speicher beim Hinzufügen von Elementen erforderlich ist. ** Kurz gesagt, jeder hat seine Vor- und Nachteile. ** ** ** Es gibt andere Funktionen in der Liste, die Elemente löschen. Außerdem kann die Liste keine Numpy-Arrays senden.

list_sample.py

#print(x + 3)
#TypeError tritt auf

Sie können jedoch Folgendes tun:

list_sample.py

print(x + [3])
print(x * 3)

Wenn es sich um eine Hinzufügung zwischen Listen handelt, wird ein Element hinzugefügt. Das Multiplizieren einer Liste mit natürlichen Zahlen ist eine Liste, die die Liste selbst mit der Anzahl der Zahlen wiederholt. [^ 2] ** Andere Operationen können nicht typeError sein ** Außerdem können numpy Arrays und Listen ineinander konvertiert werden.

list_sample.py

x = np.array(x)
print(x)
x = list(x)
print(x)

Damit ist die Einführung des in diesem Artikel erforderlichen Listenwissens abgeschlossen. Zusammenfassend

• Eine Liste ist wie ein Array mit variabler Datengröße --Numpy und Liste können ineinander konvertiert werden

Dieser Artikel ist in Ordnung, wenn Sie nur wissen.

Bedingte Verzweigung und Schleifenverarbeitung

Bedingte Verzweigung ist der Prozess von ** "○○, wenn bestimmte Bedingungen erfüllt sind, XX andernfalls" **. (Dieser Prozess ähnelt der menschlichen Entscheidungsfindung) Die Schleifenverarbeitung ist ein Prozess, der ** "denselben Prozess wiederholt, bis bestimmte Bedingungen erfüllt sind" **. (Dies ist ein maschinenähnlicher Prozess)

Lassen Sie uns tatsächlich tun, wie der Code konkret geschrieben wird.

if Anweisung

Apropos bedingte Verzweigung in Python: Nur die if-Anweisung lautet [^ 3]. Leute, die C-Sprache usw. gemacht haben, fragen sich vielleicht: "Nun, gibt es keinen" Schalter "?" In Python gibt es keine "switch" -Anweisung. Du musst es eins nach dem anderen schreiben. ~~ Es ist mühsam. ~~ Zum ersten Mal kann es ein Glück sein, sich an weniger zu erinnern. Verwenden wir vorerst diesen bedingten Zweig.

x = 5
if x > 0:
    #Bedingter Ausdruck x>Wenn 0 wahr ist, wird der Prozess hier ausgeführt
    print("x ist größer als 0.")
else:
    #Bedingter Ausdruck x>Wenn 0 falsch ist, wird der Vorgang hier ausgeführt
    #Das heißt, x<=Wenn es 0 ist, ist es der Prozess hier
    if x == 0:
        #Bedingter Ausdruck x==Wenn 0 wahr ist, wird der Prozess hier ausgeführt
        # <note>
        # ==Ist ein bedingter Ausdruck, dass beide Seiten des Ausdrucks gleich sind
        #Im Gegenteil, die Berechnung, ob beide Seiten des Ausdrucks nicht gleich sind!=ist
        print("x ist 0.")
    else:
        #Bedingter Ausdruck x==Wenn 0 falsch ist, wird der Vorgang hier ausgeführt
        #Das heißt, x!=Wenn es 0 ist, ist es der Prozess hier
        print("x ist kleiner als 0.")

if x > 0:
    print("x ist größer als 0.")
elif x == 0:
    print("x ist 0.")
else:
    print("x ist kleiner als 0.")

Diese beiden if-Anweisungen haben genau das gleiche Verhalten. Das obere wird nur mit "if else" geschrieben, und das untere wird mit der Grammatik "if elif else" geschrieben. Wie Sie sehen können, können Sie eine if-Anweisung in eine if-Anweisung schreiben (** Verschachtelung ** genannt). Natürlich können Sie mehr verschachteln, aber das Lesen ist schwierig. Versuchen Sie daher, die Verschachtelung so gering wie möglich zu halten. Mit anderen Worten, der folgende Code ist leichter zu lesen.

Grammatikübersicht

if_grammer_summary.py

if (Bedingter Ausdruck 1):
    # (Bedingter Ausdruck 1)Ist wahr(True)Führen Sie dann den hier beschriebenen Vorgang aus
#-----von hier-----
elif (Bedingter Ausdruck 2):
    # (Bedingter Ausdruck 1)Ist unecht(False)damit(Bedingter Ausdruck 2)Ist wahr(True)Führen Sie dann den hier beschriebenen Vorgang aus
elif (Bedingter Ausdruck 3):
...
else:
    #Alle bedingten Ausdrücke sind falsch(False)Führen Sie dann den hier beschriebenen Vorgang aus
#-----Bisher-----
#Alle sind optional. Mit anderen Worten, nur das erste wenn ist OK.

for und while Anweisungen

Als nächstes folgt die Schleifenverarbeitung. In Python gibt es zwei Arten der Schleifenverarbeitung: "for" und "while". Es gibt zwei Gründe, weil ich sie manchmal richtig verwenden möchte, aber es gefällt mir, weil ich die Anweisung "for" in die Anweisung "while" und die Anweisung "while" in die Anweisung "for" konvertieren kann, damit sie eine gleichwertige Verarbeitung ausführen. Ich würde gerne sagen ... aber ich persönlich empfehle die Verwendung der ** im Grunde for Anweisung. ** ** ** Der Grund wird später sein ...

for Anweisung

Zuerst aus der "for" -Anweisung.

for i in range(10):
    print(i)
print("----------")

for i in range(1, 10):
    print(i, end=" ")
    if i > 5:
        print("\n{} > 5".format(i))
        print("Brechen Sie aus der Schleife aus")
        break
else:
    print("Diese Erklärung wird nicht gedruckt.")

Übrigens wird die obere for-Anweisung vertikal von 0 bis 9 ausgegeben. Unten sollten bis zu 6 nebeneinander ausgegeben werden und mit "6> 5" und "Exit-Schleife" enden. (Da es zufällig ist, verwende ich einige Funktionen, die ich nicht eingeführt habe. Wenn Sie neugierig sind, lassen Sie uns googeln.)

Die for-Anweisung ist leichter zu verstehen, wenn Sie sich die Grammatik ansehen.

for_grammer_summary.py

for (Variablennamen) in (Arrays, Listen usw.):
    (Schreiben Sie hier den Vorgang, den Sie wiederholen möchten)
else:
    (Schreiben Sie hier die Verarbeitung, wenn die Schleife normal endet, und die Verarbeitung, die Sie ausführen möchten, wenn die Schleife nie ausgeführt wird)

Die Funktion range gibt so etwas wie eine Liste bis zu einer bestimmten Zahl zurück [^ 5]. Die Anweisung "break" dient zum gewaltsamen Unterbrechen der Schleife. In der for-Anweisung werden die durch ** (Array, Liste usw.) ** angegebenen numerischen Werte nacheinander ** (Variablenname) ** zugewiesen und verarbeitet.

In der ersten Schleife von for_sample.py

--0 ist der Variablen i zugeordnet

• Die Funktion "Drucken" druckt "0" --1 ist der Variablen i zugeordnet
• Die Funktion "Drucken" druckt "1"
• ...

Der Prozess läuft so ab.

Die zweite Schleife wurde geschrieben, um die Anweisung "for else" einzuführen. Sie können "else" für Schleifen verwenden, was in anderen Sprachen in Python selten vorkommt. Schreiben Sie in else die Verarbeitung, die Sie ausführen möchten, wenn die Schleife normal endet. Mit anderen Worten, wenn die Anweisung ** break die Schleife zwangsweise beendet, wird dieser Prozess nicht ausgeführt. ** ** ** Ich benutze es nicht sehr aggressiv, aber ich kann saubereren Code schreiben, wenn ich alle verschachtelten "for" -Anweisungen entfernen möchte.

#mit sonst
for i in range(10):
    for j in range(10):
        print(i, j)
        if i * j > 10:
            # i = 2, j =Geben Sie hier um 6
            break
    else:
        continue
    break

#ohne sonst
flag = False
for i in range(10):
    for j in range(10):
        print(i, j)
        if i * j > 10:
            # i = 2, j =Geben Sie hier um 6
            flag = True
            break
    if flag:
        break

Die Anweisung "continue" dient zum Durchlaufen der nachfolgenden Verarbeitung und zum Übergang zur nächsten Schleife.

while Anweisung

Als nächstes kommt die while-Anweisung.

i = 0
while i < 10:
    print(i)
    i += 1
print("----------")

i = 0
while i < 10:
    print(i, end=" ")
    if i > 5:
        print("\n{} > 5".format(i))
        break
    i += 1
else:
    print("Diese Erklärung wird nicht gedruckt")

Sie können sehen, dass diese while_sample.py ein Schleifenprozess ist, der for_sample.py entspricht. Die Syntax der while-Anweisung lautet wie folgt:

while_grammer_summary.py

while (Bedingter Ausdruck):
    (Schreiben Sie hier den Vorgang, den Sie wiederholen möchten)
else:
    (Schreiben Sie hier die Verarbeitung, wenn die Schleife normal endet, und die Verarbeitung, die Sie ausführen möchten, wenn die Schleife nie ausgeführt wird)

Das Merkmal der "while" -Anweisung ist, dass die ** Schleifenverarbeitung ausgeführt wird, solange der bedingte Ausdruck erfüllt ist **. ** Der große Unterschied besteht darin, dass die Anweisung "for" die Anzahl der Schleifen im Voraus bestimmt, während die Anweisung "while" unbestimmt sein kann. ** ** ** Dies führt dazu, dass ich persönlich die while-Anweisung nicht verwenden möchte.

Wenn Sie die erste Schleife von while_sample.py wie folgt ändern und ausführen, wird weiterhin eine große Menge von "0" ausgegeben. ** << Achtung >> ** ** Bitte beachten Sie, wie Sie bei der Ausführung aufhören müssen. ** ** **

while_sample.py

i = 0
while i < 10:
    print(i)
    #i += 1

** << So stoppen Sie >> ** Klicken Sie oben auf ■, um den Vorgang zu beenden. Das Jupyter-Notebook ist praktisch, da Sie die Ausführung mit einer einfachen Operation ~ unterbrechen können

Dies geschieht, weil sich der Wert der Variablen "i" nicht ändert, so dass der bedingte Ausdruck "i <10" weiterhin erfüllt ist und die Verarbeitung auf unbestimmte Zeit ausgeführt wird. Diese Situation wird als ** Endlosschleife ** bezeichnet. Diesmal ist der Fehler leicht zu verstehen, da er von der Funktion "Drucken" ausgegeben wird. Was ist jedoch, wenn dies in 1000 Codezeilen ohne Ausgabe durch die Funktion "Drucken" auftritt?

Der Code, den ich so hart geschrieben habe, funktioniert aus irgendeinem Grund aufgrund eines Fehlers nicht! nicht Der Code, den ich so hart geschrieben habe, reagiert nicht, obwohl es keine Fehler gibt!

Es wird die Situation sein. Wenn Sie ein Anfänger sind, bemerken Sie Endlosschleifen nicht so leicht, was Kopfschmerzen verursachen kann. Aus den oben genannten Gründen gibt es nur wenige Schleifen, die nur mit einer while-Anweisung geschrieben werden können. Verwenden wir also grundsätzlich eine for-Anweisung.

Zeichnen wir eine diskontinuierliche Funktion

Es ist lange her, aber schreiben wir eine diskontinuierliche Funktion mit bedingter Verzweigung und Schleifenverarbeitung! Lassen Sie uns den Funktionsteil f von [graph_plot.py](https://qiita.com/kuroitu/items/8542b88d486d1dbf92a5#draw graph) wie folgt ändern.

graph_plot.py

#Listenversion
def f(x):
    result = []
    for i in x:
        if i < 0:
            result.append(i + 3)
        else:
            result.append(i ** 2)
    return result

graph_plot.py

#Version mit numpy Array
def f(x):
    result = np.zeros(len(x))
    for i in range(len(x)):
        if x[i] < 0:
            result[i] = x[i] + 3
        else:
            result[i] = x[i] ** 2
    return result

Es ist in Ordnung, wenn ein Diagramm wie dieses gezeichnet wird.

Problematisch?

Ist es nervig kein Zweifel. Deshalb werde ich auch eine clevere Schreibweise vorstellen.

graph_plot.py

def f(x):
    return np.where(x < 0, x + 3, x ** 2)

Die "where" -Funktion von numpy ist der sogenannte ternäre Operator. Lassen Sie uns für Details googeln. Übrigens, wenn Sie Ihr Bestes geben, wird auch der Standardschreibstil so klug sein, wie er ist.

graph_plot.py

def f(x):
    return [i + 3 if i < 0 else i ** 2 for i in x]

Es ist eine Kombination aus Listeneinschlussnotation und dem ternären Operator der if-Anweisung.

list_comprehension_grammer.py

[(wird bearbeitet) for (Variablennamen) in (Arrays, Listen usw.)]

ternary_operator_grammer.py

(Verarbeitung, wenn der bedingte Ausdruck wahr ist) if (Bedingter Ausdruck) else (Bedingter Ausdruckが偽の時の処理)

Es ist jedoch schwer zu lesen und kompliziert. ** Sie können die Größe des Pakets sehen. ** ** **

Erster Artikel der Python-Serie

• Erste Python ~ Umgebungskonstruktion ~
• First Python ~ Coding ~
• Erste Python ~ Zuweisung ~

[^ 1]: Um genau zu sein, ist es die Methode "Anhängen" der Listentypklasse. [^ 2]: Ganzzahlige Werte kleiner oder gleich 0 geben eine leere Liste zurück. Versuch es. [^ 3]: Die "try" -Anweisung kann als bedingter Zweig bezeichnet werden. [^ 4]: Wenn die linke Grenze und die rechte Grenze an diesem Punkt übereinstimmen und der Wert an diesem Punkt mit dem Grenzwert übereinstimmt, wird gesagt, dass die Funktion kontinuierlich ist. Mit anderen Worten, wenn die Funktionen ordentlich verbunden sind, ist es kontinuierlich. [^ 5]: Gibt tatsächlich ein iteratorisches (loopable) Objekt zurück.