Die Wettbewerbsprogrammierungsseite AtCoder enthält das einführende Programmiermaterial "AtCoder-Programmierhandbuch für Anfänger (APG4b)". Es gibt. Es ist ein sehr vollständiges einführendes Programmiermaterial und verwendet C ++, die Hauptsprache der wettbewerbsfähigen Programmierung. In diesem Artikel habe ich eine darauf basierende Python-Version von APG4b geschrieben. Grundsätzlich lesen Sie bitte APG4b und lesen Sie in diesem Artikel die Teile, die nur für Python gelten.
Das meiste davon basiert auf APG4b. Wenn Sie diesen Artikel als problematisch empfinden, entfernen Sie ihn sofort.
Die Überschrift jedes Abschnitts ist ein Link zur Kopffamilie. Da der Abschnittstitel auf die ursprüngliche Familie zugeschnitten ist, gibt es einige Unterschiede zur Python-Terminologie.
1.00. Einführung [1.01. Ausgabe und Kommentare](https://qiita.com/saba/items/b9418d7b54cce4b106e4#101%E5%87%BA%E5%8A%9B%E3%81%A8%E3%82%B3%E3% 83% A1% E3% 83% B3% E3% 83% 88) [1.02. So schreiben Sie ein Programm und Fehler](https://qiita.com/saba/items/b9418d7b54cce4b106e4#102%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9% E3% 83% A0% E3% 81% AE% E6% 9B% B8% E3% 81% 8D% E6% 96% B9% E3% 81% A8% E3% 82% A8% E3% 83% A9% E3% 83% v. Chr.) [1.03. Vier Regeln und Priorität](https://qiita.com/saba/items/b9418d7b54cce4b106e4#103%E5%9B%9B%E5%89%87%E6%BC%94%E7%AE%97% E3% 81% A8% E5% 84% AA% E5% 85% 88% E9% A0% 86% E4% BD% 8D) 1.04. Variablen und Typen [1.05. Ausführungsreihenfolge und Eingabe](https://qiita.com/saba/items/b9418d7b54cce4b106e4#105%E5%AE%9F%E8%A1%8C%E9%A0%86%E5%BA%8F%E3 % 81% A8% E5% 85% A5% E5% 8A% 9B) [1.06.if-Anweisung / Vergleichsoperator / logischer Operator](https://qiita.com/saba/items/b9418d7b54cce4b106e4#106if%E6%96%87%E6%AF%94%E8%BC%83%E6 % BC% 94% E7% AE% 97% E5% AD% 90% E8% AB% 96% E7% 90% 86% E6% BC% 94% E7% AE% 97% E5% AD% 90) [1.07. Ergebnis des bedingten Ausdrucks und Bool-Typ](https://qiita.com/saba/items/b9418d7b54cce4b106e4#107%E6%9D%A1%E4%BB%B6%E5%BC%8F%E3%81% AE% E7% B5% 90% E6% 9E% 9C% E3% 81% A8bool% E5% 9E% 8B) [1.08. Umfang der Variablen](https://qiita.com/saba/items/b9418d7b54cce4b106e4#108%E5%A4%89%E6%95%B0%E3%81%AE%E3%82%B9%E3% 82% B3% E3% 83% BC% E3% 83% 97) [1.09. Composite Assignment Operator](https://qiita.com/saba/items/b9418d7b54cce4b106e4#109%E8%A4%87%E5%90%88%E4%BB%A3%E5%85%A5%E6 % BC% 94% E7% AE% 97% E5% AD% 90) 1.10.while-Anweisung 1.11.für Satz / Pause / Fortsetzung [1.12. Zeichenfolge (und Zeichen)](https://qiita.com/saba/items/b9418d7b54cce4b106e4#112%E6%96%87%E5%AD%97%E5%88%97%E3%81%A8 % E6% 96% 87% E5% AD% 97) [1.13. Liste (Sequenz)](https://qiita.com/saba/items/b9418d7b54cce4b106e4#113%E3%83%AA%E3%82%B9%E3%83%88%E9%85%8D%E5 % 88% 97) [1.14. Integrierte Standardbibliotheksfunktionen (STL-Funktionen)](https://qiita.com/saba/items/b9418d7b54cce4b106e4#114%E6%A8%99%E6%BA%96%E3%83%A9%E3 % 82% A4% E3% 83% 96% E3% 83% A9% E3% 83% AA% E3% 81% AE% E7% B5% 84% E3% 81% BF% E8% BE% BC% E3% 81 % BF% E9% 96% A2% E6% 95% B0stl% E3% 81% AE% E9% 96% A2% E6% 95% B0) 1.15. Funktionen Schlussfolgerung
Kapitel 1 beschreibt die grundlegende Grammatik.
Das ursprüngliche APG4b befasst sich mit einer Programmiersprache namens C ++. Dieser Artikel befasst sich mit einer Programmiersprache namens Python.
Es ist gut, eine Python-Umgebung zur Hand zu haben, aber mit AtCoder-Code-Tests können Sie genug schreiben.
Dieser Artikel enthält die Python-Version des Codes. Bitte verwenden Sie den ursprünglichen Übermittlungsabschnitt, um Ihre Fragen einzureichen. Das Übermittlungsfeld befindet sich unten auf der Startseite.
Ändern Sie zunächst die "Sprache" im Übermittlungsfeld in "Python3 (3.4.3)". Versuchen Sie nach dem Vornehmen von Änderungen, den folgenden Code zu kopieren und einzufügen.
print("Hello, world!")
Klicken Sie nach dem Einfügen auf die Schaltfläche "Senden". Wenn die Seite gewechselt wird und die Ergebnisspalte grün "AC" ist, ist die Übermittlung erfolgreich.
Das folgende Programm ist ein Programm, das nichts tut.
Mit anderen Worten, im Gegensatz zu C ++ muss die Hauptfunktion nicht geschrieben werden. Das Programm arbeitet nur durch direktes Schreiben des Verarbeitungsinhalts. Sie können die Hauptfunktion schreiben, müssen sie jedoch nicht für kleine Programme wie Wettbewerbsprogramme schreiben.
Werfen wir einen Blick auf das Programm, das wir zuerst eingereicht haben. Dieses Programm gibt die Zeichenfolge "Hallo Welt!" Aus.
print("Hello, world!")
Ausführungsergebnis
Hello, world!
print()
Verwenden Sie print (), um eine Zeichenfolge in Python zu drucken.
Der Teil, der die auszugebende Zeichenfolge angibt, ist der Teil von "Hallo Welt!". Sie können eine Zeichenfolge drucken, indem Sie sie in () von print () schreiben.
Wenn Sie mit Zeichenfolgen in Python-Programmen arbeiten, müssen diese in "" "eingeschlossen sein. Zusätzlich wird am Ende des Satzes automatisch ein Zeilenumbruch hinzugefügt.
C ++ erfordert ein ; am Ende der Zeile, aber für Python müssen Sie nichts schreiben. (Auch wenn Sie es schreiben, wird es ohne Probleme funktionieren)
Wenn Sie eine andere Zeichenfolge ausgeben möchten, ändern Sie den Inhalt von "" "wie folgt.
print("Hallo Welt")
Ausgabeergebnis
Hallo Welt
Sie können auch mehrmals ausgeben.
print("a")
print("b")
print("c", "d")
Ausführungsergebnis
a
b
c d
Wie bereits erwähnt, wird Pythons print () am Ende eines Satzes automatisch unterbrochen. Daher wird "b" in der Zeile nach "a" ausgegeben.
Wenn Sie als nächstes mehrere Trennzeichen mit "," schreiben, wird die Ausgabe durch Leerzeichen wie "c d" begrenzt.
Wenn Sie einen numerischen Wert ausgeben, können Sie ihn auch ausgeben, indem Sie ihn direkt schreiben, ohne " " zu verwenden.
print(2525)
Ausführungsergebnis
2525
Kommentare dienen dazu, Notizen zu hinterlassen, um die Funktionsweise des Programms zu erläutern, und das Schreiben hat keine Auswirkungen auf die Funktionsweise des Programms. Schauen wir uns ein Beispiel für einen Kommentar in Python an.
print("Hello, world!") # Hello, world!Angezeigt als
#Auch hier kommentieren
Ausführungsergebnis
Hello, world!
Wenn Sie "#" schreiben, steht der Kommentar in dieser Zeile nach "#".
In Python funktioniert es im Gegensatz zu C ++ grundsätzlich problemlos, selbst wenn "Zeichen voller Breite" im Programm enthalten sind. Es ist jedoch schwer zu lesen, daher wird empfohlen, in "Zeichen halber Breite" zu schreiben.
Sie finden die Problemstellung unter dem folgenden Link. EX1. Code-Test- und Ausgabepraxis
Beispielprogramm
print("Hello, world!")
print("Hello, AtCoder!")
print("Hello, Python!")
Ausführungsergebnis des Beispielprogramms
Hello, world!
Hello, AtCoder!
Hello, Python!
** Probieren Sie das Problem unbedingt selbst aus, bevor Sie es sehen. ** ** ** Antwortbeispiel
Beschreibt Leerzeichen, Zeilenumbrüche und Einrückungen in Ihrem Programm. Es beschreibt auch PEP8, die Python-Codierungskonvention.
In Python können Leerzeichen weggelassen werden, Zeilenumbrüche sind jedoch sinnvoll und können nicht weggelassen werden.
In C ++ bedeutet ; das Zeilenende, in Python bedeutet der Zeilenumbruch das Zeilenende.
In C ++ erfolgt das Einrücken aus Gründen der Lesbarkeit, in Python ist das Einrücken jedoch auch sinnvoll.
Schauen wir uns den Unterschied zwischen C ++ und Python anhand der unten beschriebenen if-Anweisung als Beispiel an.
C++(Mit Einrückung)
#include <bits/stdc++.h>
using namespace std;
int main() {
if (Bedingter Ausdruck) {
wird bearbeitet
}
}
C++(Keine Einrückung)
#include <bits/stdc++.h>
using namespace std;
int main() {
if (Bedingter Ausdruck) {
wird bearbeitet
}
}
In C ++ gibt es keinen Unterschied im Verhalten mit oder ohne Einzug innerhalb von {}}, wie oben beschrieben.
Python
wenn bedingter Ausdruck:
wird bearbeitet
Einrückung ist erforderlich, da Python : und Einrückung anstelle von {} verwendet, um anzuzeigen, dass es sich um eine if-Anweisung handelt.
PEP8 PEP8 ist ein Python-Codierungsstandard. Codierungskonventionen sind Regeln, die für die Lesbarkeit definiert sind.
Das Programm funktioniert einwandfrei, wenn Sie PEP8 nicht befolgen, aber Sie können ein Programm schreiben, das leicht zu lesen ist.
Es würde lange dauern, sie alle vorzustellen. Hier sind einige davon.
--Indent ist 4 Leerzeichen halber Breite
Details finden Sie unter https://pep8-ja.readthedocs.io/ja/latest/.
Grundsätzlich ist es wie im ursprünglichen APG4b geschrieben, aber da Python eine interpretierte Sprache ist, tritt kein Kompilierungsfehler auf.
Eine interpretierte Sprache wird nicht wie C ++ kompiliert, sondern Satz für Satz ausgeführt. Wenn daher ein Grammatikfehler vorliegt, wird anstelle eines ** Kompilierungsfehlers ** ein ** Laufzeitfehler ** angezeigt.
Sie finden die Problemstellung unter dem folgenden Link. EX2. Fehler korrigieren
Programm geschrieben von Herrn A.
print("Immer)
print("2525"
print(AtCoder)
Standardfehlerausgabe
File "./Main.py", line 1
print("Immer)
^
SyntaxError: EOL while scanning string literal
** Probieren Sie das Problem unbedingt selbst aus, bevor Sie es sehen. ** ** ** Antwortbeispiel
| Operator | Berechnungsinhalt |
|---|---|
| + | Zusatz |
| - | Subtraktion |
| * | Multiplikation |
| / | Teilung |
| // | Kürzungsteilung |
| % | Rest |
| ** | Reiten |
Mal sehen, wie man mit einem Python-Programm eine einfache Berechnung durchführt. Die folgenden Programme führen "Addition", "Subtraktion", "Multiplikation", "Division" und "Kürzungsdivision" in der Reihenfolge von oben aus.
print(1 + 1) # 2
print(3 - 4) # -1
print(2 * 3) # 6
print(7 / 3) # 2.3333333333333335
print(7 // 3) # 2
Ausführungsergebnis
2
-1
6
2.3333333333333335
2
Diese Symbole +, -,*,/heißen ** arithmetische Operatoren **.
Negative Werte können auch berechnet werden, da "3-4" zu "-1" wird.
* ** ist Multiplikation und ** / ** ist "Division". ** ** **
In Python ist / eine normale Division und das Ergebnis ist ein Bruch. Verwenden Sie // für Unterteilungen, die nach dem Dezimalpunkt abgeschnitten werden.
Außerdem wird "//" immer auf ** minus unendlich ** gerundet. C ++ / wird ebenfalls abgeschnitten, aber C ++ / wird immer auf 0 gerundet, sodass ** C ++ / und Python // unterschiedlich sind **. Wenn Sie in Python immer auf 0 runden möchten, schreiben Sie etwas wie "int (a / b)".
print(10 // 3, -10 // 3)
print(int(10 / 3), int(-10 / 3))
Ausführungsergebnis
3 -4
3 -3
% berechnet den "Rest beim Teilen".
print(7 % 3) # 1
print(4 % 5) # 4
Ausführungsergebnis
1
4
$ 7 ÷ 3 = 2 $ Nicht viel $ 1 $ $ 4 ÷ 5 = 0 $ Zu viel $ 4 $ Daher ist die Ausgabe dieses Programms "1" und "4".
Python bietet auch einen Power Operator. Die Potenz ist eine Zahl, ausgedrückt als $ a ^ b $.
print(3 ** 4) # 81
print(25 ** 0.5) # 5.0
print(1.5 ** 2) # 2.25
Ausführungsergebnis
81
5.0
2.25
Wie oben erwähnt, kann "a ** b" verwendet werden, um $ a ^ b $ zu berechnen. Sie können auch Brüche wie "25 ** 0,5" und "1,5 ** 2" berechnen.
Die Priorität der vier Regeln entspricht der von C ++. Beziehen Sie sich daher auf das ursprüngliche Home.
Sie finden die Problemstellung unter dem folgenden Link. EX3. Berechnungsproblem
Beispielprogramm
print("""Schreiben Sie hier die Formel""")
** Probieren Sie das Problem unbedingt selbst aus, bevor Sie es sehen. ** ** ** Antwortbeispiel
--Variationen sind Memos
--=ist eine Aufgabe
—— „Datentyp“ wird als Typ bezeichnet
| Schimmel | Art der zu schreibenden Daten |
|---|---|
| int | ganze Zahl |
| float | Fraktion |
| str | String |
Werfen wir einen Blick auf eine Funktion namens ** Variablen **. Stellen Sie sich eine Variable als "Memo" vor.
Schauen wir uns ein Beispiel an.
name = 10
print(name) # 10
print(name + 2) # 10 + 2 → 12
print(name * 3) # 10 * 3 → 30
Ausführungsergebnis
10
12
30
In Python werden Deklaration und Zuweisung gleichzeitig ausgeführt. Es kann genauer sein zu sagen, dass keine Erklärung erforderlich ist.
name = 10
In diesem Teil deklarieren wir eine Variable namens "name" und weisen ihr "10" zu.
Beachten Sie, dass das Symbol = "zuweisen (schreiben)" und nicht "gleich" bedeutet.
Die Erläuterungen zu "Typ" und "Wert" finden Sie in der Kopffamilie.
Im Fall von C ++ muss "int" geschrieben werden, um anzugeben, dass der Typ der Variablen "Ganzzahl" ist. Im Fall von Python wird die zugewiesene "10" jedoch automatisch als "Name" bezeichnet, da die zugewiesene "10" eine Ganzzahl ist. Es macht den Typ int.
Der in der Variablen angegebene Wert wird in den letzten 3 Zeilen des Programms gelesen und ausgegeben.
print(name) # 10
print(name + 2) # 10 + 2 → 12
print(name * 3) # 10 * 3 → 30
Wenn Sie "Variable 1 = Variable 2" schreiben, wird der Wert der Variablen selbst kopiert. Nachfolgende Änderungen des Werts einer der Variablen wirken sich nicht auf die andere aus.
a = 10
b = a
a = 5
print(a) # 5
print(b) # 10
Ausführungsergebnis
5
10
Beachten Sie, dass die Variable "b" bei 10 bleibt. Die Verarbeitungsdetails werden in einem Diagramm erläutert, das für die Kopffamilie leicht verständlich ist. In Python werden Deklarationen und Zuweisungen gleichzeitig vorgenommen, sodass die b-Deklaration im Teil b = a erfolgt.
Sie können mehrere Variablen in einer Zeile zuweisen, indem Sie beim Zuweisen von Variablen "," dazwischen einfügen.
a, b = 10, 5
print(a)
print(b)
Ausführungsergebnis
10
5
Das obige Programm hat die gleiche Bedeutung, als ob Sie geschrieben hätten:
a = 10
b = 5
Sie können grundsätzlich einen beliebigen Variablennamen angeben. Wenn Sie jedoch versuchen, einige Namen als Variablennamen zu verwenden, tritt ein Fehler auf.
Namen, die die folgenden Bedingungen erfüllen, können keine Variablennamen sein.
_Das folgende Beispiel zeigt einen Namen, der nicht als Variablenname verwendet werden kann. Das im ursprünglichen Beispiel verwendete int kann in Python als Variablenname verwendet werden (... nicht empfohlen).
100hello = 10 #Kann kein Name sein, der mit einer Zahl beginnt
na+me = "AtCoder" #Im Variablennamen+Kann nicht verwendet werden
not = 100 #kann kein Variablenname sein, da es sich um ein Schlüsselwort handelt
Die folgenden Namen können Variablennamen sein.
hello10 = 10 #Das zweite und nachfolgende Zeichen können Zahlen sein
hello_world = "Hello, world" # _Kann für Variablennamen verwendet werden
Variable 1= 1 #chinesische Charaktere
Hensu 2= 2 #Hiragana
Im Fall von Python können im Gegensatz zu C ++ Kanji und Hiragana auch für Variablennamen verwendet werden. Bei der Suche nach Python-Schlüsselwörtern wird eine Liste angezeigt.
Neben int gibt es verschiedene Arten von Python. Hier werden nur drei wichtige Typen vorgestellt.
In C ++ ist der Bruch "double", in Python "float". Ebenso ist die Zeichenfolge "str".
| Schimmel | Art der zu schreibenden Daten |
|---|---|
| int | ganze Zahl |
| float | Bruch (reelle Zahl) |
| str | String |
i = 10 #10 ist eine ganze Zahl
f = 0.5 # 0.5 ist ein Bruchteil
s = "Hello" # "Hello"Ist eine Zeichenfolge
print(i, type(i)) # type(Variable) でVariableの型がわかる
print(f, type(f))
print(s, type(s))
Ausführungsergebnis
10 <class 'int'>
0.5 <class 'float'>
Hello <class 'str'>
** Typkonvertierung ** wird für Berechnungen zwischen verschiedenen Typen durchgeführt. Das Ergebnis der Berechnung von int-Typ und float-Typ ist beispielsweise float-Typ.
** Berechnungen zwischen Typen, die nicht konvertiert werden können, führen jedoch zu einem Fehler **.
i = 30
d = 1.5
s = "Hello"
print(i + d, type(i + d)) # 31.5
print(i * d, type(i * d)) # 45.0
"""
Die folgende Verarbeitung ist ein Fehler
print(s + i) #Hinzufügen von str type und int type
print(s + d) #Hinzufügen von str-Typ und float-Typ
"""
Ausführungsergebnis
31.5 <class 'float'>
45.0 <class 'float'>
Im Fall von Python ist es möglich, "str type * int type" zu berechnen.
i = 5
s = "Hello"
print(s * i) # "Hello" * 5 → ???
Was sind die Ergebnisse des oben genannten Programms? Sehen wir uns das Ausführungsergebnis an.
Ausführungsergebnis
HelloHelloHelloHelloHello
"Hallo" ist eine Zeichenfolge, die fünfmal wiederholt wird.
In Python hängt der Variablentyp davon ab, was sich darin befindet. Daher funktioniert das folgende Programm normal.
i = 10
s = "Hello"
i = s
print(i)
print(type(i))
Ausführungsergebnis
Hello
<class 'str'>
Sie finden die Problemstellung unter dem folgenden Link. EX4. ◯ Wie viele Sekunden ist das Jahr?
Beispielprogramm
#Anzahl der Sekunden pro Jahr
seconds = 365 * 24 * 60 * 60
#Die folgenden Kommentare""" """Löschen und hinzufügen
print("""Wie viele Sekunden pro Jahr""")
print("""2 Jahre sind ein paar Sekunden""")
print("""Wie viele Sekunden sind 5 Jahre""")
print("""Wie viele Sekunden sind 10 Jahre""")
** Probieren Sie das Problem unbedingt selbst aus, bevor Sie es sehen. ** **. Antwortbeispiel
variable = input () empfangenGrundsätzlich werden ** Programme in der Reihenfolge von oben nach unten ausgeführt **.
Schauen Sie sich das folgende Programm an.
name = 10
print(name) # 10
name = 5
print(name) # 5
Ausführungsergebnis
10
5
Die Grundstruktur ist die gleiche wie die der Kopffamilie. Informationen zur Ausführung finden Sie auf der Folie der Kopffamilie.
Mal sehen, wie man Dateneingaben empfängt, wenn das Programm ausgeführt wird. Mit der "Eingabefunktion" können Sie verschiedene Berechnungen durchführen, ohne das Programm neu zu schreiben.
Verwenden Sie input (), um Eingaben zu erhalten.
Das folgende Programm ist ein Programm, das den als Eingabe empfangenen numerischen Wert mit 10 multipliziert und ausgibt.
a = int(input())
print(a * 10)
Eingang
5
Ausführungsergebnis
50
input () nimmt eine Eingabezeile als Zeichenfolge. Um es als int-Typ zu empfangen, muss es daher von int () in einen int-Typ konvertiert werden.
a = input()
print(a, type(a))
a = int(a) #In int-Typ konvertieren
print(a, type(a))
Eingang
5
Ausführungsergebnis
5 <class 'str'>
5 <class 'int'>
Wenn Sie nicht ganzzahlige Daten empfangen möchten, müssen Sie diese ebenfalls in den erforderlichen Typ konvertieren.
text = input()
f = float(input())
print(text, f)
Eingang
Hello
1.5
Ausführungsergebnis
Hello 1.5
Wie bereits erwähnt, verwendet "input ()" eine einzelne Eingabezeile als Zeichenfolge.
a = input()
print(a)
print(type(a))
Eingang
10 20 30
Ausführungsergebnis
10 20 30
<class 'str'>
Wenn Sie also nur eine durch Leerzeichen getrennte Eingabe erhalten, wird diese der Variablen "a" als Zeichenfolge "10 20 30" zugewiesen, wie oben gezeigt.
Daher müssen Sie nach. Input () .split () hinzufügen, um die Zeichenfolge zu zerlegen.
a, b, c = input().split()
print(a)
print(type(a))
Eingang
10 20 30
Ausführungsergebnis
10
<class 'str'>
Auf diese Weise wurde "10 20 30" in drei Teile unterteilt: "10", "20" und "30".
Wenn Sie es danach wie zuvor mit int () in eine Ganzzahl konvertieren, können Sie die durch Leerzeichen getrennte Eingabe als Ganzzahl empfangen.
a, b, c = input().split()
a = int(a)
b = int(b)
c = int(c)
print(a)
print(type(a))
Eingang
10 20 30
Ausführungsergebnis
10
<class 'int'>
Im obigen Programm wurde die Konvertierung in den Typ int jedes Mal für die Anzahl der Variablen geschrieben, dies kann jedoch auch in einer Zeile geschrieben werden.
a, b, c = map(int, input().split())
print(a)
print(type(a))
Eingang
10 20 30
Ausführungsergebnis
10
<class 'int'>
Durch Schreiben von "map (type, input (). Split ())" können Sie alle geteilten Zeichenfolgen gleichzeitig in den angegebenen Typ konvertieren.
input () empfängt eine Eingabezeile. Wenn also mehrere Eingabezeilen vorhanden sind, müssen Sie so viele Zeilen schreiben, wie Zeilen vorhanden sind.
s = input()
a = int(input())
print(s, a)
Eingang
Hello
10
Ausführungsergebnis
Hello 10
Sie finden die Problemstellung unter dem folgenden Link. EX5.A Addition B Problem
Beispielprogramm
#Fügen Sie das Programm hier hinzu
** Probieren Sie das Problem unbedingt selbst aus, bevor Sie es sehen. ** **. Antwortbeispiel
wenn bedingter Ausdruck 1:
Prozess 1
elif bedingter Ausdruck 2:
Prozess 2
else:
Prozess 3
| Operator | Bedeutung |
|---|---|
x == y |
x und y sind gleich |
x != y |
x und y sind nicht gleich |
x > y |
x ist größer als y |
x < y |
x ist kleiner als y |
x >= y |
x ist größer oder gleich y |
x <= y |
x ist kleiner oder gleich y |
| Operator | Bedeutung | Wann soll man wahr sein? |
|---|---|---|
kein bedingter Ausdruck |
Inversion des Ergebnisses des bedingten Ausdrucks | Der bedingte Ausdruck ist falsch |
Bedingter Ausdruck 1 und bedingter Ausdruck 2 |
Der bedingte Ausdruck 1 ist wahr und der bedingte Ausdruck 2 ist wahr | Sowohl der bedingte Ausdruck 1 als auch der bedingte Ausdruck sind wahr |
Bedingter Ausdruck oder bedingter Ausdruck 2 |
Der bedingte Ausdruck 1 ist wahr oder der bedingte Ausdruck 2 ist wahr | Mindestens einer der bedingten Ausdrücke 1 und der bedingten Ausdrücke 2 ist wahr |
Mit der ** if-Anweisung ** können Sie ein Programm namens ** schreiben, das nur verarbeitet, wenn bestimmte Bedingungen korrekt sind. Die Schreibmethode ist wie folgt.
wenn bedingter Ausdruck:
wird bearbeitet
Wenn der bedingte Ausdruck ** korrekt ist, wird die Verarbeitung des Teils ausgeführt, in dem der Einzug nach : um eins verringert wird, und wenn der bedingte Ausdruck falsch ist, wird die Verarbeitung übersprungen.
Wenn im folgenden Beispiel der Eingabewert kleiner als 10 ist, wird "x ist kleiner als 10" ausgegeben und dann "end" ausgegeben. Wenn der Eingabewert nicht kleiner als 10 ist, wird nur "Ende" ausgegeben.
x = int(input())
if x < 10:
print("x ist kleiner als 10")
print("Ende")
Eingabe 1
5
Ausführungsergebnis 1
x ist kleiner als 10
Ende
Eingabe 2
15
Ausführungsergebnis 2
Ende
In diesem Beispiel geben wir zuerst ganzzahlige Daten in die Variable x ein.
x = int(input())
Dann ist es wichtig.
if x < 10:
print("x ist kleiner als 10")
Dieser Teil bedeutet "wenn" x <10 "(x ist kleiner als 10), wird" x als weniger als 10 "ausgegeben". Führen Sie abschließend "print (" end ")" aus, um "end" zu drucken, und das Programm wird beendet.
Wenn x nicht kleiner als 10 ist
print("x ist kleiner als 10")
Die Verarbeitung wird übersprungen. Daher wird im zweiten Ausführungsbeispiel nur "Ende" ausgegeben.
Ausführung der Verarbeitung unter bestimmten Bedingungen wie der if-Anweisung heißt ** bedingter Zweig **. Außerdem heißt "der bedingte Ausdruck ist korrekt" ** der bedingte Ausdruck ist wahr ** und "der bedingte Ausdruck ist falsch" heißt ** der bedingte Ausdruck ist falsch **.
Die Vergleichsoperatoren von Python sind mit C ++ identisch. Weitere Informationen finden Sie im Originalabschnitt für diesen Abschnitt.
| Operator | Bedeutung |
|---|---|
x == y |
x und y sind gleich |
x != y |
x und y sind nicht gleich |
x > y |
x ist größer als y |
x < y |
x ist kleiner als y |
x >= y |
x ist größer oder gleich y |
x <= y |
x ist kleiner oder gleich y |
Das folgende Programm gibt aus, welche Bedingungen der eingegebene ganzzahlige Wert erfüllt.
x = int(input())
if x < 10:
print("x ist kleiner als 10")
if x >= 20:
print("x ist 20 oder mehr")
if x == 5:
print("x ist 5")
if x != 100:
print("x ist nicht 100")
print("Ende")
Eingabe 1
5
Ausführungsergebnis 1
x ist kleiner als 10
x ist 5
x ist nicht 100
Ende
Eingabe 2
100
Ausführungsergebnis 2
x ist 20 oder mehr
Ende
Sie können auch komplexere Bedingungen in den bedingten Ausdruck schreiben. Verwenden Sie dazu den logischen Operator **.
| Operator | Bedeutung | Wann soll man wahr sein? |
|---|---|---|
kein bedingter Ausdruck |
Inversion des Ergebnisses des bedingten Ausdrucks | Der bedingte Ausdruck ist falsch |
Bedingter Ausdruck 1 und bedingter Ausdruck 2 |
Bedingter Ausdruck 1 ist wahrUndDer bedingte Ausdruck 2 ist wahr | Sowohl der bedingte Ausdruck 1 als auch der bedingte Ausdruck sind wahr |
Bedingter Ausdruck oder bedingter Ausdruck 2 |
Bedingter Ausdruck 1 ist wahrOderDer bedingte Ausdruck 2 ist wahr | Mindestens einer der bedingten Ausdrücke 1 und der bedingten Ausdrücke 2 ist wahr |
x, y = map(int, input().split())
if not x == y:
print("x und y sind nicht gleich")
if x == 10 and y == 10:
print("x und y sind 10")
if x == 0 or y == 0:
print("x oder y ist 0")
print("Ende")
Eingabe 1
2 3
Ausführungsergebnis 1
x und y sind nicht gleich
Ende
Eingabe 2
10 10
Ausführungsergebnis 2
x und y sind 10
Ende
Eingabe 3
0 8
Ausführungsergebnis 3
x und y sind nicht gleich
x oder y ist 0
Ende
Durch Schreiben der ** else-Klausel ** nach der if-Anweisung kann die Verarbeitung durchgeführt werden, "wenn die Bedingung der if-Anweisung falsch ist". Die Schreibmethode ist wie folgt.
wenn bedingter Ausdruck 1:
Prozess 1
else:
Prozess 2
Das folgende Programm gibt "x ist kleiner als 10" aus, wenn der Eingabewert kleiner als 10 ist, andernfalls "x ist nicht kleiner als 10".
x = int(input())
if x < 10:
print("x ist kleiner als 10")
else:
print("x ist nicht kleiner als 10")
Eingabe 1
5
Ausführungsergebnis 1
x ist kleiner als 10
Eingabe 2
15
Ausführungsergebnis 2
x ist nicht kleiner als 10
elif In "elif" wird die Verarbeitung ausgeführt, wenn "die Bedingung der vorherigen if-Anweisung falsch ist" und "die Bedingung von elif wahr ist". Die Schreibmethode ist wie folgt.
wenn bedingter Ausdruck 1:
Prozess 1
elif bedingter Ausdruck 2:
Prozess 2
Prozess 2 wird ausgeführt, wenn "der bedingte Ausdruck 1 falsch und der bedingte Ausdruck 2 wahr ist". Schauen wir uns ein Beispiel an.
x = int(input())
if x < 10:
print("x ist kleiner als 10")
elif x > 20:
print("x ist nicht kleiner als 10, aber größer als 20")
elif x == 15:
print("x ist nicht kleiner als 10 und nicht größer als 20 und ist 15.")
else:
print("x ist nicht kleiner als 10, nicht größer als 20, nicht 15.")
Eingabe 1
5
Ausführungsergebnis 1
x ist kleiner als 10
Eingabe 2
30
Ausführungsergebnis 2
x ist nicht kleiner als 10, aber größer als 20
Eingabe 3
15
Ausführungsergebnis 3
x ist nicht kleiner als 10 und nicht größer als 20 und ist 15.
Eingabe 4
13
Ausführungsergebnis 4
x ist nicht kleiner als 10, nicht größer als 20, nicht 15.
Sie können auch elif oder nach elif schreiben, wie in diesem Beispiel.
Sie finden die Problemstellung unter dem folgenden Link. EX6. Machen wir einen Taschenrechner
Beispielprogramm
a, op, b = input().split()
a = int(a)
b = int(b)
if op == "+":
print(a + b)
#Fügen Sie das Programm hier hinzu
** Probieren Sie das Problem unbedingt selbst aus, bevor Sie es sehen. ** **. Antwortbeispiel
| int Typ Darstellung | Bool-Typ-Darstellung | |
|---|---|---|
| wahr | 1 | True |
| falsch | 0 | False |
In Python wird die Wahrheit durch "Wahr" und das Falsche durch "Falsch" dargestellt. Beachten Sie, dass der Anfang im Gegensatz zu C ++ in Großbuchstaben geschrieben ist. Das "Berechnungsergebnis" des bedingten Ausdrucks ist auch "Wahr", wenn es wahr ist, und "Falsch", wenn es falsch ist.
Das folgende Programm gibt das Ergebnis des bedingten Ausdrucks unverändert aus und prüft, welchen Wert er annimmt, wenn er wahr und wenn er falsch ist.
print(5 < 10)
print(5 > 10)
Ausführungsergebnis
True
False
Wenn Sie sich die Ausgabe ansehen, können Sie sehen, dass sie "True" ist, wenn die Bedingung wahr ist, und "False", wenn sie falsch ist.
Im Fall von Python werden wahr und falsch normalerweise durch "wahr" und "falsch" dargestellt, sodass dieser Titel möglicherweise nicht korrekt ist, aber zum Original passt.
Sie können auch True oder False direkt in den Teil mit bedingten Ausdrücken schreiben. Das folgende Programm ist ein Beispiel.
#True steht für true und wird daher als Hallo ausgegeben
if True:
print("hello")
#False steht für false, daher wird dies nicht ausgeführt
if False:
print("world")
Ausführungsergebnis
hello
Im int-Typ wird "True" durch "1" und "False" durch "0" dargestellt.
print(int(True))
print(int(False))
Ausführungsergebnis
1
0
Es gibt einen Datentyp namens ** Bool-Typ **. Variablen dieses Typs können nur "True" oder "False" enthalten.
x = int(input())
a = True
b = x < 10 #Richtig, wenn x kleiner als 10 ist
c = False
if a and b:
print("hello")
if c:
print("world")
Eingang
3
Ausführungsergebnis
hello
Verwenden Sie auf diese Weise den Bool-Typ, wenn Sie Wahrheitsdaten als Variablen behandeln möchten, z. B. das Ergebnis eines bedingten Ausdrucks. Bisher wurde es als "wenn bedingter Ausdruck" geschrieben, aber im Grunde ist es ein Wert vom Typ "wenn bool".
Die folgende Tabelle fasst die bisherige Geschichte zusammen.
| int Typ Darstellung | Bool-Typ-Darstellung | |
|---|---|---|
| wahr | 1 | True |
| falsch | 0 | False |
Bitte beziehen Sie sich auf die Oberfamilie.
Sie finden die Problemstellung unter dem folgenden Link. EX7.bool-Wert-Puzzle
Beispielprogramm
#Variable a, b,Ersetzen Sie c durch True oder False, damit es als AtCoder ausgegeben wird
a = #Richtig oder falsch
b = #Richtig oder falsch
c = #Richtig oder falsch
#Von hier an nicht ändern
if a:
print("At", end="") # end=""Wird das Ende nicht brechen
else:
print("Yo", end="")
if (not a) and b:
print("Bo", end="")
elif (not b) and c:
print("Co", end="")
if a and b and c:
print("foo!")
elif True and False:
print("yeah!")
elif (not a) or c:
print("der")
** Probieren Sie das Problem unbedingt selbst aus, bevor Sie es sehen. ** **. Antwortbeispiel
Bis jetzt habe ich nach der if-Anweisung : geschrieben und in die folgende Zeile eingerückt. Der Teil mit diesem Einzug heißt ** Block **.
Die Oberfamilie sagt "
Schauen wir uns ein konkretes Beispiel an.
x = 5
if x == 5:
y = 10
print(x + y)
print(x)
print(y)
Ausführungsergebnis
15
5
10
Dies ist der gleiche Inhalt wie das Programm, das in der ursprünglichen Familie aufgeführt ist. Da ich zu Hause mit C ++ zu tun habe, wird dies als Beispiel für das Abrufen eines Fehlers gezeigt. In Python tritt der Fehler jedoch nicht wie oben beschrieben auf und funktioniert einwandfrei.
Weitere Informationen zum Umfang finden Sie in der Kopffamilie.
Sie finden die Problemstellung unter dem folgenden Link. EX8. Takoyaki-Set
Programm geschrieben von Herrn A.
p = int(input())
#Muster 1
if p == 1:
price = int(input())
#Muster 2
if p == 2:
text = input()
price = int(input())
n = int(input())
print(text + "!")
print(price * n)
** Probieren Sie das Problem unbedingt selbst aus, bevor Sie es sehen. ** **. Antwortbeispiel
--x = x + y kann so kurz wie x + = y geschrieben werden
Zuweisungsanweisungen, bei denen derselbe Variablenname zweimal vorkommt, z. B. "x = x + 1", können mit dem ** zusammengesetzten Zuweisungsoperator ** kürzer geschrieben werden.
Das folgende Programm fügt der Variablen x einfach "(1 + 2)" hinzu und gibt sie aus.
x = 5
x += 1 + 2
print(x) # 8
Ausführungsergebnis
8
x += 1 + 2
Ist
x = x + (1 + 2)
Hat die gleiche Bedeutung wie.
Sie können dasselbe für andere arithmetische Operatoren tun.
a = 5
a -= 2
print(a) # 3
b = 3
b *= 1 + 2
print(b) # 9
c = 5
c /= 2
print(c) # 2.5
d = 5
d //= 2
print(d) # 2
e = 5
e %= 2
print(e) # 1
f = 3
f **= 4
print(f) # 81
Ausführungsergebnis
3
9
2.5
2
1
81
C ++ hat Inkremente und Dekremente, Python jedoch nicht. Wenn Sie mehr über Inkremente erfahren möchten, beziehen Sie sich bitte auf das ursprüngliche Haus.
Sie finden die Problemstellung unter dem folgenden Link. EX9. Verwenden wir den zusammengesetzten Zuweisungsoperator
Beispielprogramm
x, a, b = map(int, input().split())
# 1.Ausgabe von
x += 1
print(x)
#Fügen Sie das Programm hier hinzu
** Probieren Sie das Problem unbedingt selbst aus, bevor Sie es sehen. ** ** ** Antwortbeispiel
während bedingter Ausdruck:
wird bearbeitet
i = 0 #Zählervariable
while i < N:
wird bearbeitet
i += 1
Die ** while-Anweisung ** kann verwendet werden, um eine "repetitive Verarbeitung" (Schleifenverarbeitung) durchzuführen, was für die Funktionen des Programms sehr wichtig ist.
Das folgende Programm ist ein Programm, das den Vorgang des Ausgebens von "Hallo" wiederholt, das Unterbrechen einer Zeile und das anschließende Ausgeben von "AtCoder" auf unbestimmte Zeit wiederholt.
while True:
print("Hello")
print("AtCoder")
Ausführungsergebnis
Hello
AtCoder
Hello
AtCoder
Hello
AtCoder
Hello
AtCoder
Hello
AtCoder
...(Unendlich)
Die while-Anweisung wird wie folgt geschrieben und der Vorgang wird wiederholt, wenn der bedingte Ausdruck wahr ist.
während bedingter Ausdruck:
wird bearbeitet
Im vorherigen Programm wurde "True" in den Teil des bedingten Ausdrucks geschrieben, sodass der Prozess unbegrenzt fortgesetzt wird. Diese Art der Endloswiederholung wird als ** Endlosschleife ** bezeichnet.
Das folgende Programm gibt weiterhin Ganzzahlen ab 1 aus.
i = 1
while True:
print(i)
i += 1 #Erhöhen Sie für jede Schleife um 1
Ausführungsergebnis
1
2
3
4
5
6
7
8
...(Unendlich um 1 erhöht)
Gehen Sie wie folgt vor, um das Programm, das um 1 zählt, in "ein Programm, das Zahlen von 1 bis 5 ausgibt" zu ändern.
i = 1
#Schleife nur, wenn ich 5 oder weniger bin
while i <= 5:
print(i)
i += 1
Ausführungsergebnis
1
2
3
4
5
Stellen Sie sich ein Programm vor, das fünfmal "Hallo" ausgibt. Zuerst werde ich den ungewöhnlichen Schreibstil (den Schreibstil, der gestoppt werden sollte) und dann den allgemeinen Schreibstil (empfohlener Schreibstil) vorstellen.
#starte ich von 1
i = 1
#Schleife nur, wenn ich 5 oder weniger bin
while i <= 5:
print("Hello")
i += 1
Ausführungsergebnis
Hello
Hello
Hello
Hello
Hello
Wenn Sie ein Programm schreiben, das "$ N $ mal" mit einer while-Anweisung verarbeitet, wurde es im Format "Start i von 1 und Schleife für weniger als $ N $" geschrieben.
i = 1
while i <= N:
wird bearbeitet
i += 1
Dieses Format mag auf den ersten Blick unkompliziert erscheinen. Dieser Schreibstil ist jedoch nicht sehr verbreitet und sollte wie folgt geschrieben werden.
#starte i von 0
i = 0
#Schleife nur, wenn ich kleiner als 5 ist
while i < 5:
print("Hello")
i += 1
Ausführungsergebnis
Hello
Hello
Hello
Hello
Hello
Wenn Sie ein Programm schreiben, das "$ N $ mal verarbeitet", ist es üblich, im folgenden Format zu schreiben ** "Start i von 0 und Schleife, wenn i kleiner als $ N $ ist " Es ist **.
i = 0
while i < N:
wird bearbeitet
i += 1
Es mag zunächst verwirrend erscheinen, aber es wird später einfacher sein, das Programm zu schreiben, also gewöhnen wir uns daran.
Beachten Sie, dass Variablen, die die "Anzahl der Schleifen" verwalten, wie die Variable "i" in diesem Programm, manchmal als ** Zählervariablen ** bezeichnet werden. Es ist üblich, "i" für Zählervariablen zu verwenden und sie "j", "k", "l", ... zu nennen, wenn "i" nicht verwendet werden kann.
Lassen Sie uns ein Programm erstellen, um die Gesamtpunktzahl von $ N $ Personen zu ermitteln.
Das folgende Programm empfängt "Anzahl der Eingaben $ N
n = int(input())
sum = 0 #Variable, die die Gesamtpunktzahl darstellt
i = 0 #Zählervariable
while i < n:
x = int(input())
sum += x
i += 1
print(sum)
Eingang
3
1
10
100
Ausführungsergebnis
111
Ich habe eine Variable "sum" erstellt, die die Gesamtpunktzahl darstellt, sie bei jeder Schleife in die Eingabevariable "x" eingefügt und zu "sum" hinzugefügt. Es gibt eine Folie, die der Kopffamilie den Verarbeitungsinhalt erklärt.
Sie finden die Problemstellung unter dem folgenden Link. EX10. Ausgabe des Balkendiagramms
Wenn Sie nur print () verwenden, wird am Ende automatisch ein Zeilenumbruch eingefügt, sodass Sie print (Ausgabeinhalt, end =" ") verwenden können, um den Zeilenumbruch am Ende zu verhindern.
Beispielprogramm
a, b = map(int, input().split())
#Fügen Sie das Programm hier hinzu
** Probieren Sie das Problem unbedingt selbst aus, bevor Sie es sehen. ** **. Antwortbeispiel
für Zählervariable in Spalte:
wird bearbeitet
for i in range(N):
wird bearbeitet
** for-Anweisung ** ist eine Syntax zum Schreiben von Mustern, die in der iterativen Verarbeitung häufig vorkommen, z. B. "$ N $ mal verarbeiten", die kürzer als die while-Anweisung sind.
Wenn Sie ein Programm schreiben, das dreimal mit einer while-Anweisung und einer for-Anweisung wiederholt wird, ist dies wie folgt.
j = 0
while j < 3:
print("Hello while:", j)
j += 1
for i in range(3):
print("Hello for:", i)
Ausführungsergebnis
Hello while: 0
Hello while: 1
Hello while: 2
Hello for: 0
Hello for: 1
Hello for: 2
Die for-Anweisung ist wie folgt geschrieben.
für Zählervariable in Spalte:
wird bearbeitet
Wir werden in einem späteren Abschnitt mehr über Spalten sprechen, aber es gibt Zahlen (Listen) wie "[3, 1, 4, 1, 5]" und Zeichenfolgen wie "abcdef". Schauen wir uns das folgende Programm an.
for i in [3, 1, 4, 1, 5]:
print("i:", i)
Ausführungsergebnis
i: 3
i: 1
i: 4
i: 1
i: 5
Sie können sehen, dass der Inhalt der Liste "[3, 1, 4, 1, 5]" von Anfang an abgerufen und "i" zugewiesen wird.
Wenn Sie eine iterative Verarbeitung durchführen möchten, z. B. "$ N $ mal verarbeiten", ist es einfacher, "range ()" zu verwenden. Das Schreiben von "range (a, b)" erzeugt eine Folge von "[a, a + 1, a + 2, ..., b-1]".
for i in range(0, 5): # [0, 1, 2, 3, 4]
print(i)
Ausführungsergebnis
0
1
2
3
4
Das "a" von "Bereich (a, b)" kann weggelassen werden, wenn es 0 ist, und kann als "Bereich (b)" geschrieben werden. Daher haben die folgenden beiden Schreibstile dieselbe Bedeutung.
for i in range(0, 5):
print(i)
for i in range(5):
print(i)
Ausführungsergebnis
0
1
2
3
4
0
1
2
3
4
Mit anderen Worten, wenn Sie "$ N $ mal iterieren" schreiben möchten, können Sie wie folgt schreiben. Beginnen wir zunächst mit dem Erlernen dieser einfachen Schreibweise.
for i in range(N):
wird bearbeitet
Denken Sie bei der Verwendung der for-Anweisung von "Iterate $ N $ times" nicht an die detaillierte Operation "Zuweisen der Zählervariablen in der Reihenfolge vom Anfang der Spalte an". Grob gesagt ist es einfacher, ein Programm zu schreiben, das die for-Anweisung verwendet, wenn Sie sich die ** for-Anweisung als eine Funktion vorstellen, die die Verarbeitung von $ N $ -mal wiederholt und $ i $ um 1 erhöht.
Es gibt ** break ** und ** continue ** als Anweisungen zur Steuerung der while- und for-Anweisungen.
break break ist eine Anweisung zum Unterbrechen der Schleife in der Mitte. Dies ist ein Beispiel für ein Programm, das break verwendet.
#Ohne Unterbrechung wäre diese Schleife i==Wiederholen Sie bis zu 4
for i in range(5):
if i == 3:
print("Geh raus")
break # i ==Bei 3 aus der Schleife ausbrechen
print(i)
print("Ende")
Ausführungsergebnis
0
1
2
Geh raus
Ende
Wenn "i == 3" in der if-Anweisung wahr wird, wird die for-Schleife durch Ausführen der Anweisung "break" beendet und "end" wird angezeigt.
continue continue ist eine Anweisung, die nachfolgende Verarbeitung zu überspringen und zur nächsten Schleife zu wechseln. Dies ist ein Beispiel für ein Programm, das continue verwendet.
for i in range(5):
if i == 3:
print("Überspringen")
continue # i ==Wenn es 3 ist, überspringen Sie die Verarbeitung danach
print(i)
print("Ende")
Ausführungsergebnis
0
1
2
Überspringen
4
Ende
Wenn im obigen Programm "i == 3" in der if-Anweisung wahr wird, wird der folgende Teil "continue" durch Ausführen der Anweisung "continue" übersprungen und die nächste Schleife wird eingegeben.
Sie finden die Problemstellung unter dem folgenden Link. EX11. Machen wir einen Taschenrechner 2
Wenn Sie "print (" {} ". Format (variable))" wie folgt schreiben, wird der Inhalt der Variablen in den Teil von "{}" eingebettet.
a = 1
b = "Hello"
print("{}:{}".format(a, b)) #Zuerst{}Auf eine Sekunde{}Zu b
Ausführungsergebnis
1:Hello
Beispielprogramm
n = int(input())
a = int(input())
#Fügen Sie das Programm hier hinzu
** Probieren Sie das Problem unbedingt selbst aus, bevor Sie es sehen. ** ** ** Antwortbeispiel
i ofstring variable [i]heißt ** tiefgestellt **
--Skripte beginnen bei 0Zeichenketten wie "abc" und "hallo" sind solche, in denen die Zeichen in der richtigen Reihenfolge angeordnet sind. C ++ unterscheidet zwischen Zeichenfolgen und Zeichen (Länge 1), Python jedoch nicht und behandelt beide als Zeichenfolgen (Typ str).
str1 = input()
str2 = ", world!"
print(str1 + str2)
Eingang
Hello
Ausführungsergebnis
Hello, world!
Die Länge (Anzahl der Zeichen) der Zeichenfolge kann mit "len (Zeichenfolgenvariable)" ermittelt werden.
s = "Hello"
print(len(s))
Ausführungsergebnis
5
Sie können das Zeichen $ i $ erhalten, indem Sie wie folgt schreiben.
String[i]
Dieses "i" heißt ** tiefgestellt **.
Beachten Sie, dass die Indizes bei 0 beginnen.
s = "hello"
print(s[0]) # h
print(s[4]) # o
Ausführungsergebnis
h
o
s [0] erhält das erste Zeichen und s [4] erhält das fünfte Zeichen.
Für die Zeichenfolge "Hallo" wird die Entsprechung zwischen Indizes und Zeichen in der folgenden Tabelle gezeigt.
| Index | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| Brief | h | e | l | l | o |
Gewöhnen wir uns an den Index ab 0, genauso wie wir die Zählervariable der Schleife bei 0 starten.
Durch Kombinieren der Zeichenkette mit der Schleifensyntax können verschiedene Prozesse beschrieben werden. Das folgende Programm zählt, wie viele Zeichen "O" in den eingegebenen Zeichen enthalten sind.
s = input()
count = 0
for i in range(len(s)):
if s[i] == "O":
count += 1
print(count)
Eingang
LOOOOL
Ausführungsergebnis
4
Sie können in Python auch wie folgt schreiben: Da die for-Anweisung den Anfang der Spalte in der angegebenen Reihenfolge betrachtet, unterstützt sie auch Zeichenfolgen, und im Fall einer Zeichenfolge werden alle Zeichen in der Reihenfolge vom ersten Zeichen an angezeigt.
s = input()
count = 0
for i in s:
if i == "O":
count += 1
print(count)
Eingang
LOOOOL
Ausführungsergebnis
4
Wenn der Indexwert nicht im richtigen Bereich liegt, tritt ein Laufzeitfehler auf. Das folgende Programm verursacht einen Fehler, weil es versucht, auf eine 5-stellige Zeichenfolge mit dem Namen "Hallo" (gültige Indizes sind "0" bis "4") in der Anzahl der nicht vorhandenen Zeichen in "[10]" zuzugreifen. Machen.
x = "hello"
print(x[10])
Laufzeit Fehler
Traceback (most recent call last):
File "./Main.py", line 2, in <module>
print(x[10])
IndexError: string index out of range
Code beenden
256
Ein Fehler, wenn der Index außerhalb des Bereichs liegt, wird durch die Fehlermeldung "Zeichenfolgenindex außerhalb des Bereichs" in Zeile 4 gekennzeichnet.
Im Gegensatz zu C ++ kann Python Zeichen in voller Breite verarbeiten.
s = "Hallo"
print(s[0])
print(s[2])
Ausführungsergebnis
Dies
Zu
Sie finden die Problemstellung unter dem folgenden Link. EX12. Addieren oder subtrahieren
Beispielprogramm
s = input()
#Fügen Sie das Programm hier hinzu
** Probieren Sie das Problem unbedingt selbst aus, bevor Sie es sehen. ** **. Antwortbeispiel
list variable name = [Element 1, Element 2, ...] erstellenZeichenketten waren eine Funktion zur Behandlung von "Zeichenketten". ** Liste ** ist eine sehr wichtige Funktion, die nicht nur Zeichen, sondern auch verschiedene Datenspalten verarbeiten kann.
C ++ behandelt Arrays (Vektoren), während Python Listen (Listen) behandelt. Die Hauptunterschiede sind wie folgt.
| der Unterschied | |
|---|---|
| C++Vektor | In einem Array kann sich nur ein Typ befinden |
| Python-Liste | Sie können verschiedene Datentypen in eine Liste aufnehmen |
Zeichenfolgen und Listen werden zum Teil auf die gleiche Weise verwendet. Das folgende Programm hat eine Folge von Buchstaben "a", "b", "c", "d" und "25", "100", "64". Wir haben es mit einer Spalte von ganzen Zahlen zu tun.
#String
s = "abcd" # "a", "b", "c", "d"Geben Sie die Zeichenfolge ein
print(s[0]) #Der Erste"a"Ausgabe
print(len(s)) #Ausgabe 4, die der Länge der Zeichenfolge entspricht
#aufführen
a = [25, 100, 64] # 25, 100,Ersetzen Sie eine Spalte mit ganzen Zahlen (int) mit dem Namen 64
print(a[0]) #Geben Sie die ersten 25 aus
print(len(a)) #Geben Sie die Listenlänge 3 aus
Ausführungsergebnis
a
4
25
3
Die Listenvariable wird wie folgt generiert.
Variablenname auflisten= [Element 1,Element 2, ...]
Jedes Datenelement in der Liste wird als ** Element ** bezeichnet. Wenn Sie "a = [25, 100, 64]" schreiben, wird der Listenvariablen "a" die Datenzeichenfolge "25, 100, 64" zugewiesen.
Wie Strings können Listen "[i]" verwenden, um auf das $ i $ -te Element zuzugreifen.
Listenvariable[i]
Indizes beginnen ebenfalls bei 0 in der Liste. Im Fall der Listenvariablen "a" mit "a = [25, 100, 64]" ist die Entsprechungstabelle zwischen dem Indexwert und dem Zeichen wie folgt.
| Index | 0 | 1 | 2 |
|---|---|---|---|
| Element | 25 | 100 | 64 |
Wie Strings können Listen mit len () die Anzahl der Elemente (Länge) ermitteln.
len(Listenvariable)
Für die Listenvariable "a" mit "a = [25, 100, 64]" ist der Wert von "len (a)" "3".
Ich habe "input (). Split ()" beim Empfang von durch Leerzeichen getrennten Eingaben behandelt, aber ich empfange sie tatsächlich als Liste.
a = input().split()
print(a)
Eingang
3 1 4 1 5
Ausführungsergebnis
['3', '1', '4', '1', '5']
Wenn dies das einzige ist, wird es als str-Typ empfangen. Verwenden Sie also map (), um es als int-Typ zu empfangen. Sie können map () verwenden, um eine Typkonvertierung für alle Elemente der Liste durchzuführen.
a = list(map(int, input().split()))
print(a)
Eingang
3 1 4 1 5
Ausführungsergebnis
[3, 1, 4, 1, 5]
Wenn nur "map ()" verwendet wird, handelt es sich um ein Kartenobjekt. Daher wird es in eine Liste konvertiert, indem es in "list ()" eingeschlossen wird.
Möglicherweise möchten Sie auch die folgende durch Zeilenumbrüche getrennte Eingabe erhalten:
3
1
4
1
5
Erstellen Sie in diesem Fall zuerst eine leere Liste und fügen Sie die Elemente der Reihe nach hinzu. Eine leere Liste kann erstellt werden, indem keine Elemente geschrieben werden.
Listenvariable= [] #Leere Liste
Verwenden Sie .append, um der Liste ein Element hinzuzufügen.
Listenvariable.append(Elemente zum Hinzufügen)
Wenn Sie diese mit der for-Anweisung kombinieren, können Sie Eingaben erhalten, die durch Zeilenumbrüche getrennt sind.
n = int(input()) #Wenn die erste Eingabezeile die Anzahl der Elemente ist
a = []
for i in range(n):
a.append(int(input()))
print(a)
Eingabe (1. Zeile ist die Anzahl der Elemente)
5
3
1
4
1
5
Ausführungsergebnis
[3, 1, 4, 1, 5]
Durch Kombinieren der Liste und der for-Anweisung können Sie ein Programm schreiben, das eine große Datenmenge verarbeitet. Siehe folgendes Beispiel.
Die Problemstellung entnehmen Sie bitte der Hauptfamilie.
Wenn $ N $ klein ist, ist es möglich, dieses Problem nur mit Variablen vom Typ int zu lösen, ohne eine Liste zu verwenden. Wenn $ N $ jedoch groß ist, kann das Schreiben ohne Liste sehr schwierig sein. Wenn beispielsweise $ N = 1000 $ ist, müssen Sie 1000 Variablen deklarieren.
Mit Listen und for-Anweisungen können Sie Prozesse unabhängig von der Größe von $ N $ präzise schreiben.
n = int(input())
#Erhalten Sie mathematische und englische Score-Daten
math = list(map(int, input().split()))
english = list(map(int, input().split()))
#Gesamtpunktzahl ausgeben
for i in range(n):
print(math[i] + english[i])
Listen führen wie Zeichenfolgen zu einem Fehler, wenn die tiefgestellten Werte nicht im richtigen Bereich liegen.
Das folgende Programm versucht, mit "[10]" auf ein nicht vorhandenes Element mit einer Liste von drei Elementen "[1, 2, 3]" zuzugreifen (gültige Indizes sind "0" bis "2"). Ein Fehler wird auftreten.
a = [1, 2, 3]
print(a[10])
Laufzeit Fehler
Traceback (most recent call last):
File "./Main.py", line 2, in <module>
print(a[10])
IndexError: list index out of range
Code beenden
256
Wie bei der Zeichenfolge wird in der vierten Zeile die Fehlermeldung "IndexError: Listenindex außerhalb des Bereichs" angezeigt.
Es ist eine kleine Geschichte, also können Sie sie überspringen und das Problem lösen.
In Python können Sie es von hinten sehen, indem Sie im Index ein Minus verwenden.
a = [1, 2, 3, 4, 5]
print(a[-1]) #Zuerst von hinten
print(a[-3]) #Dritter von hinten
Ausführungsergebnis
5
3
Von hinten betrachtet zählen Sie den Rücken als "-1", den zweiten von hinten als "-2" und den dritten als "-3".
In Python-Listen gibt es eine Operation namens ** Slice **, um einen Teil der Liste abzurufen. Scheiben werden wie folgt verwendet.
Listenvariable[Index des Startpunktes:Index des Endpunktes]
Ausgehend vom Index des Startpunkts wird die Liste bis zu dem vor dem Index des Endpunkts abgerufen. Für die Listenvariable "a" mit "a = [1, 2, 3, 4, 5]" wird "a [1: 3]" zu "[2, 3]". Wenn Sie den Index weglassen, erhalten Sie vom Anfang für den Startpunkt bis zum Ende für den Endpunkt.
Sie können auch die Schritte angeben (wie oft Sie das Slice sehen möchten).
Listenvariable[Index des Startpunktes:Index des Endpunktes:Schritt]
Wenn Sie beispielsweise "2" für den Schritt angeben, können Sie das Element erhalten, indem Sie ein Element überspringen.
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a[::2]) #Überspringen Sie eine von Anfang an → gerade Zahl
print(a[1::2]) #Seltsame th
Ausführungsergebnis
[0, 2, 4, 6, 8]
[1, 3, 5, 7, 9]
Sie finden die Problemstellung unter dem folgenden Link. EX13. Unterschied zur Durchschnittspunktzahl
Beispielprogramm
n = int(input())
#Fügen Sie das Programm hier hinzu
** Probieren Sie das Problem unbedingt selbst aus, bevor Sie es sehen. ** ** ** Antwortbeispiel
() an die Funktion übergebene Wert heißt ** argument **| Funktion | min(a, b) | max(a, b) |
|---|---|---|
| Funktion | Gibt den kleineren Wert von a und b zurück(3 oder mehr möglich) | Gibt den größeren Wert von a und b zurück(3 oder mehr möglich) |
| Funktion | sorted(list) | reversed(list) |
|---|---|---|
| Funktion | Sortieren Sie die Liste (sortieren Sie die Elemente in aufsteigender Reihenfolge) | Kehren Sie die Reihenfolge der Elemente in der Liste um |
** Funktionen ** erleichtern die Verwendung der Funktionen eines Programms.
Nehmen wir als Beispiel "ein Programm, das den kleineren der Werte zweier Variablen ausgibt".
Wenn Sie ohne Verwendung einer Funktion schreiben, sieht es folgendermaßen aus:
a = 10
b = 5
if a < b:
answer = a
else:
answer = b
print(answer)
Ausführungsergebnis
5
Wenn Sie die "min-Funktion" verwenden, können Sie wie folgt schreiben.
a = 10
b = 5
answer = min(a, b) #min Funktion
print(answer)
Ausführungsergebnis
5
Das im Programm angezeigte min ist eine Funktion, die den kleineren der beiden Werte findet.
Da der kleinere Wert von "a" und "b" als "Berechnungsergebnis" von "min (a, b)" erhalten werden kann, wird er der Variablen "Antwort" zugewiesen.
Zusätzlich zu min hat Python verschiedene Funktionen, und Sie können viele Funktionen verwenden, ohne ein eigenes Programm zu schreiben.
Eine von Python bereitgestellte Sammlung von Funktionen usw. wird als ** Standardbibliothek ** bezeichnet. Die in der Standardbibliothek bereitgestellten Funktionen werden als ** integrierte Funktionen ** bezeichnet.
Sie können auch eigene Funktionen erstellen. Dies wird in "1.15. Funktionen" erläutert.
Die Verwendung einer Funktion wird als ** Funktionsaufruf ** bezeichnet.
Die Notation des Funktionsaufrufs lautet wie folgt.
Funktionsname(Argument 1,Argument 2, ...)
** Argument ** ist der an die Funktion übergebene Wert. In "min (a, b)" entsprechen die Variable a und die Variable b ihr. Die min-Funktion hatte zwei Argumente, aber die Anzahl der Argumente hängt von der Funktion ab.
Der Wert des Berechnungsergebnisses der Funktion heißt ** Rückgabewert (Rückgabewert) ** oder ** Rückgabewert (Rückgabewert) **.
In answer = min (a, b) wird der Rückgabewert der Funktion min der Variablen antwort zugewiesen.
Die Typregeln für Argumente und Rückgabewerte werden von der Funktion festgelegt. Wenn Sie einen Fehler machen, tritt ein Fehler auf.
Das folgende Programm versucht, int- und string-Typen als Argumente an die min-Funktion zu übergeben, und es wird eine Fehlermeldung angezeigt.
s = "hello"
a = min(10, s)
print(a)
Error
Traceback (most recent call last):
File "./Main.py", line 3, in <module>
a = min(10, s)
TypeError: unorderable types: str() < int()
Ich werde zwei der eingebauten Funktionen vorstellen. ** Sie müssen sich diese nicht merken **, aber es ist wichtig, sich zu erinnern und nachzuschlagen: "Ich glaube, dieser Prozess wurde mit einer eingebauten Funktion durchgeführt."
Die min-Funktion gibt das kleinste der Argumente zurück. Es werden auch 3 oder mehr Argumente unterstützt.
answer = min(10, 5)
print(answer) # 5
Ausführungsergebnis
5
Der Typ des Arguments und der Rückgabewert können ein beliebiger numerischer Typ (oder ein Typ, dessen Größe verglichen werden kann) sein, z. B. "int" oder "float". Sie können auch eine Liste als Argument verwenden.
answer = min(1.5, 3.1)
print(answer) # 1.5
Ausführungsergebnis
1.5
Sie können auch den Int-Typ und den Float-Typ vergleichen.
a = 1.5
print("a:", type(a))
b = 10
print("b:", type(b))
answer = min(a, b)
print(answer) # 1.5
Ausführungsergebnis
a: <class 'float'>
b: <class 'int'>
1.5
Die Funktion max gibt das größte der Argumente zurück. Es werden auch 3 oder mehr Argumente unterstützt.
answer = max(10, 5)
print(answer) # 10
Ausführungsergebnis
10
Die Arten von Argumenten und Rückgabewerten sind die gleichen wie min.
Hier sind zwei integrierte Funktionen, die eine Liste als Argument übergeben.
Mit der Umkehrfunktion können Sie die Reihenfolge der Elemente in der Liste umkehren.
a = [1, 5, 3]
a = list(reversed(a)) # [3, 5, 1]
print(a)
Ausführungsergebnis
[3, 5, 1]
Da der Iterator zurückgegeben wird, konvertiere ich ihn mit list () in eine Liste.
Sie können eine Liste auch in umgekehrter Reihenfolge erhalten, indem Sie Slices verwenden.
a = [1, 5, 3]
a = a[::-1]
print(a)
Ausführungsergebnis
[3, 5, 1]
Das Sortieren der Datenspalten in der Reihenfolge wird als ** Sortieren ** bezeichnet. Mit der sortierten Funktion können Sie die Elemente der Liste in aufsteigender Reihenfolge sortieren.
a = [2, 5, 2, 1]
a = sorted(a) # [1, 2, 2, 5]
print(a)
Ausführungsergebnis
[1, 2, 2, 5]
Die sortierte Funktion kann auch in absteigender Reihenfolge sortiert werden, indem als zweites Argument "reverse = True" angegeben wird.
a = [2, 5, 2, 1]
a = sorted(a, reverse=True) # [5, 2, 2, 1]
print(a)
Ausführungsergebnis
[5, 2, 2, 1]
Die Summenfunktion gibt die Summe aller Elemente in der Liste der Argumente zurück.
a = [2, 5, 2, 1]
print(sum(a))
Ausführungsergebnis
10
Sie finden die Problemstellung unter dem folgenden Link. EX14. Höhenunterschied zwischen den drei Brüdern
Beispielprogramm
a, b, c = map(int, input().split())
#Fügen Sie das Programm hier hinzu
** Probieren Sie das Problem unbedingt selbst aus, bevor Sie es sehen. ** **. Antwortbeispiel
def Funktionsname(Name des Arguments 1,Name des Arguments 2, ...):
wird bearbeitet
() in die Definition und rufe auf, wenn keine Funktionsargumente benötigt werdenDas Erstellen einer Funktion wird als ** Definieren ** einer Funktion bezeichnet.
Das folgende Beispiel definiert eine Funktion my_min, die eine ähnliche Funktionalität wie die integrierte min-Funktion hat.
#Funktionsdefinition
def my_min(x, y):
if x < y:
return x
else:
return y
answer = my_min(10, 5)
print(answer)
Ausführungsergebnis
5
In der Kopffamilie befindet sich eine Folie, die die Funktionsweise des gesamten Programms erklärt.
Die Funktion wird vor der Zeile definiert, die die Funktion aufruft.
Die Notation der Funktionsdefinition lautet wie folgt.
def Funktionsname(Name des Arguments 1,Name des Arguments 2, ...):
wird bearbeitet
Wie wir im vorherigen Abschnitt gesehen haben, ist das Argument der "an die Funktion zu übergebende Wert" und der Rückgabewert der "Wert des Ergebnisses der Funktion".
Die Funktion my_min akzeptiert zwei Argumente, daher sieht die Definition folgendermaßen aus:
def my_min(x, y):
Die aufrufende Methode ist dieselbe wie die integrierte Funktion. Wenn Sie es wie folgt aufrufen, wird dem Argument "x" "10" und dem Argument "y" "5" zugewiesen.
my_min(10, 5)
Der Rückgabewert der Funktion wird durch die ** return-Anweisung ** angegeben.
return Rückgabewert
Die Funktion my_min gibt das kleinere der beiden Argumente "x" und "y" zurück. Schreiben Sie also:
if x < y:
return x
else:
return y
Möglicherweise gibt es keinen Rückgabewert für die Funktion. In diesem Fall muss keine return-Anweisung geschrieben werden.
def hello(text):
print("Hello, " + text)
hello("Tom")
hello("Python")
Ausführungsergebnis
Hello, Tom
Hello, Python
Wenn Sie keine Funktionsargumente benötigen, schreiben Sie einfach () in die Definition und rufen Sie auf.
def int_input():
x = int(input())
return x
num = int_input()
print(num, type(num))
Eingang
10
Ausführungsergebnis
10 <class 'int'>
Bitte beziehen Sie sich auf die Oberfamilie.
Die Verarbeitung der Funktion endet, wenn die Verarbeitung die return-Anweisung erreicht.
Es spielt keine Rolle, ob eine Funktion mehrere return-Anweisungen enthält. Beachten Sie jedoch, dass die nach der return-Anweisung geschriebene Verarbeitung nicht ausgeführt wird.
Im folgenden Programm wird "return" in die Zeile nach der Ausgabe von "Hello" geschrieben, sodass keine weitere Verarbeitung durchgeführt wird.
def hello():
print("Hello, ", end="")
return #Laufen Sie nur bis zu dieser Linie
print("world!")
return
hello()
Ausführungsergebnis
Hello,
Wie beim Zuweisen von Werten zu anderen Variablen wird der an das Argument übergebene Wert grundsätzlich kopiert.
Die Funktion add5 im folgenden Programm fügt dem Argument in der Funktion "5" hinzu, aber der Wert der aufrufenden Variablen num ändert sich nicht.
def add5(x):
x += 5
print(x)
num = 10
add5(num)
print(num)
Ausführungsergebnis
15
10
Funktionen können nur nach der deklarierten Zeile aufgerufen werden.
Im folgenden Programm tritt der Fehler auf, weil die Hallo-Funktion vor der Zeile aufgerufen wird, die die Hallo-Funktion definiert.
hello()
def hello():
print("hello!")
Error
Traceback (most recent call last):
File "./Main.py", line 1, in <module>
hello()
NameError: name 'hello' is not defined
Da es in der Reihenfolge von oben gelesen und ausgeführt wird, wird zum Zeitpunkt der ersten Zeile der Fehler "Hallo-Funktion ist noch nicht definiert" angezeigt.
Sie finden die Problemstellung unter dem folgenden Link. EX15. Geschenk für drei Brüder
Programm geschrieben von Herrn A.
#Eine Funktion, die die Gesamtpunktzahl aus einer Liste berechnet und zurückgibt, die die Punktzahl eines Tests darstellt
#Argument punktet: scores[i]Enthält die Punktzahl des i-ten Tests
#Rückgabewert:Gesamtpunktzahl eines Tests
def sum_scores(scores):
#Fügen Sie das Programm hier hinzu
#Eine Funktion, die das Geschenkbudget aus den Gesamtpunkten von drei Personen berechnet und ausgibt
#Argument Summe_a:Gesamtpunktzahl des Tests von Herrn A.
#Argument Summe_b:Gesamtpunktzahl des Tests von Herrn B.
#Argument Summe_c:Gesamtpunktzahl des Tests von Herrn C.
#Rückgabewert:Keiner
def output(sum_a, sum_b, sum_c):
#Fügen Sie das Programm hier hinzu
# ---------------------
#Ändern Sie nicht von hier
# ---------------------
#Eine Funktion, die Eingaben mit einer durch Leerzeichen getrennten Ganzzahlzeile entgegennimmt, diese in eine Liste einfügt und zurückgibt.
#Argumente:Einzeilige, durch Leerzeichen getrennte Eingabe
#Rückgabewert:Liste der empfangenen Eingaben
def list_int_input(s):
a = list(map(int, s.split()))
return a
#Erhalte N Fächer
n = int(input())
#Erhalten Sie Punkte für jeden Test
a = list_int_input(input())
b = list_int_input(input())
c = list_int_input(input())
#Geschenkbudget ausgeben
output(sum_scores(a), sum_scores(b), sum_scores(c))
** Probieren Sie das Problem unbedingt selbst aus, bevor Sie es sehen. ** **. Antwortbeispiel
Dies ist das Ende von Kapitel 1. Dieser Artikel hat nur Kapitel 1 von APG4b behandelt. Wenn ich Lust dazu habe, werde ich über Kapitel 2 und darüber hinaus schreiben.
Wie ich am Anfang geschrieben habe, werde ich diesen Artikel löschen, wenn es ein Problem gibt.
Recommended Posts