Liste der Python-Schlüsselwörter und Beispiele

Dieses Tutorial bietet eine kurze Information über alle Schlüsselwörter, die in Python verwendet werden.

Schlüsselwörter sind reservierte Wörter in Python. Wir können Schlüsselwörter nicht als Variablenname, Funktionsname oder jedes andere Identifikator verwenden.

Dies ist die Liste aller Schlüsselwörter in der Programmiersprache Python

Diese Schlüsselwörter könnten in verschiedenen Versionen von Python geändert werden. Es könnten zusätzliche Inhalte hinzugefügt oder einige Inhalte entfernt werden. Sie können immer mit dem folgenden Verfahren die Liste der Schlüsselwörter der aktuellen Version erhalten.

>>> import keyword
>>> print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally',
　'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'

Beispiel zur Erklärung der Schlüsselwörter in Python

True, False

True und False sind die Wahrheitswerte in Python. Sie sind das Ergebnis von Vergleichsoperationen oder logischen (booleschen) Operationen in Python. Zum Beispiel:

>>>　1　==　1
True
>>>　5　>　3
True
>>> True or False
True
>>>　10　<=　1
False
>>>　3　>　7
False
>>> True and False
False

Hier können wir sehen, dass die ersten drei Anweisungen korrekt sind, daher gibt der Interpreter True zurück, die anderen drei Anweisungen geben False zurück. True und False in Python sind mit1und 0 sind gleich. Dies kann durch den folgenden Beispiel nachgewiesen werden:

>>> True ==　1
True
>>> False == 0
True
>>> True　+　True
2

None

None ist ein spezieller Konstante in Python, der einen nicht existierenden oder leeren Wert darstellt.

Es ist ein Objekt des eigenen Datentyps NoneType. Wir können keine mehrere None-Objekte erstellen, aber wir können es einer Variable zuweisen. Diese Variablen sind gleich.

Wir müssen besonders darauf achten, dass None nicht False, 0 oder irgendeine leere Liste, ein Dictionary, ein String usw. bedeutet. Zum Beispiel:

>>> None == 0
False
>>> None == []
False
>>> None == False
False
>>> x = None
>>> y = None
>>> x == y
True

Funktionen, die nichts zurückgeben, geben automatisch ein None-Objekt zurück. Funktionen, die keine return-Anweisung haben, geben ebenfalls None zurück. Zum Beispiel:

def a_void_function():
　　　　a =　1
　　　　b =　2
　　　　c = a　+　b
x = a_void_function()
print(x)

Ausgaberesultat

None

Dieser Programmcode führt intern einige Operationen aus, gibt jedoch keine Werte zurück. Daher erhalten wir, wenn wir x ausgeben, automatisch (implizit) zurückgegebenen None. Ebenso ist dies ein weiteres Beispiel:

def improper_return_function(a):
　　　　if (a %　2) == 0:
　　　　　　　　return True
x = improper_return_function(3)
print(x)

Ausgaberesultat

None

Obwohl diese Funktion eine return-Anweisung hat, kann sie nicht in jedem Fall realisiert werden. Die Funktion gibt nur True zurück, wenn der Eingabewert eine gerade Zahl ist.

Wenn wir einer Funktion eine ungerade Zahl geben, wird implizit None zurückgegeben.

and, or, not

and, or, not sind logische Operatoren in Python. Und nur wenn beide Operanden True sind, ist das Ergebnis True. Die and-Wertetabelle ist wie folgt:

or Der Wert ist True, wenn mindestens einer der Operanden True ist. Die or-Wertetabelle ist wie folgt:

Der not-Operator wird verwendet, um die Wahrheitswerte umzukehren. Die not-Wertetabelle ist wie folgt:

Nachstehend einige Beispiele der Verwendung:

>>> True and False
False
>>> True or False
True
>>> not False
True

as

as wird verwendet, um bei der Importierung eines Moduls einen Alias zu erstellen. Dies bedeutet, dass dem Modul bei der Importierung ein anderer Name (benutzerdefiniert) gegeben wird.

Zum Beispiel hat Python ein Standardmodul namens math. Angenommen, wir möchten den Kosinus pi mit einem Alias berechnen. Dies können wir auf folgende Weise tun:

>>> import math as myAlias
>>>myAlias.cos(myAlias.pi)
-1.0

Hier, importieren wir das Modul myAlias durch Benennung des Moduls. Jetzt können wir das Modul mit diesem Namen aufrufen. Mit diesem Namen berechnen wir cos(pi) und erhalten-1.0 die Antwort.}

assert

assert wird zu Debugging-Zwecken verwendet.

Bei der Programmierung möchten wir manchmal den internen Zustand verstehen oder überprüfen, ob unsere Annahmen korrekt sind. assert hilft uns dabei und erleichtert es, Fehler zu finden. assert folgt einer Bedingung.

Wenn die Bedingung wahr ist, passiert nichts. Wenn die Bedingung falsch ist, wird AssertionError ausgelöst. Zum Beispiel:

>>> a =　4
>>> assert a <　5
>>> assert a >　5
Traceback (most recent call last):
　　File '<string>', line　301, in runcode
　　File '<interactive input>', line　1, in <module>
AssertionError

Um ein besseres Verständnis zu schaffen, können wir auch eine Nachricht liefern, die zusammen mit AssertionError gedruckt wird.

>>> a =　4
>>> assert a >　5, "The value of a is too small"
Traceback (most recent call last):
　　File '<string>', line　301, in runcode
　　File '<interactive input>', line　1, in <module>
AssertionError: The value of a is too small

In diesem Punkt können wir bemerken,

assert condition, message

entspricht

if not condition:
　　　　raise AssertionError(message)

async, await

Die Bibliothek asyncio in Python bietet die Schlüsselwörter async und await. Sie werden verwendet, um concurrente Code in Python zu schreiben. Zum Beispiel,

import asyncio
async def main():
　　　　print('Hello')
　　　　await asyncio.sleep(1)
　　　　print('world')

Um das Programm auszuführen, verwenden wir

asyncio.run(main())

In diesem Programm spezifiziert das Schlüsselwort async, dass die Funktion asynchron ausgeführt wird.

Hier wird zuerst 'Hello' gedruckt. Der Schlüsselwort 'await' macht das Programm darauf warten1Sekunden. Dann wird 'world' gedruckt.

break, continue

break und continue werden in for- und while-Zyklen verwendet, um ihr normales Verhalten zu ändern.

break beendet den kleinsten Zyklus, in dem es sich befindet, und der Kontrollfluss fließt direkt zu den Anweisungen unter dem Zyklus. continue beendet nur die aktuelle Iteration des Zyklus, nicht den gesamten Zyklus.

Dies kann an zwei Beispielen erläutert werden:

for　i　in　range(1,11)
　　　　if i ==　5:
　　　　　　　　break
　　　　print(i)

Ausgaberesultat

1
2
3
4

Hier will der for-Zyklus von1to10der Zahlen gedruckt. Wenn aber i gleich5 dann wird die Bedingung erfüllt und wir brechen aus dem Zyklus aus. Daher wird nur der Bereich1to4.

for　i　in　range(1,11)
　　　　if i ==　5:
　　　　　　　　continue
　　　　print(i)

Ausgaberesultat

1
2
3
4
6
7
8
9
10

Hier verwenden wir denselben Programmcode wie continue. Daher wird beim Erfüllen der Bedingung die aktuelle Iteration übersprungen, aber der Zyklus wird nicht verlassen. Daher wird außer dem5alle anderen Werte.

Erfahren Sie mehr überPython break und Continue-AnweisungenMehr Informationen.

class

class wird verwendet, um neue benutzerdefinierte Klassen in Python zu definieren.

Klassen sind Sammlungen von relevanten Eigenschaften und Methoden, die realen Situationen entsprechen. Die Idee, Daten und Funktionen in einer Klasse zusammenzufassen, ist für das Konzept der objektorientierten Programmierung (OOP) von entscheidender Bedeutung.

Klassen können an jedem Ort in einem Programm definiert werden. Es ist jedoch eine gute Gewohnheit, eine Klasse in einer Datei zu definieren. Hier ist ein Beispiel für die Verwendung:

class ExampleClass:
　　　　def function1(parameters):
　　　　　　　　...
　　　　def function2(parameters):
　　　　　　　　...

Erfahren Sie mehr überPython-Objekte und KlassenMehr Informationen.

def

def wird verwendet, um benutzerdefinierte Funktionen zu definieren.

Eine Funktion ist eine Gruppe von zusammenhängenden Anweisungen, die gemeinsam eine bestimmte Aufgabe erledigen. Sie hilft uns, den Code in verwaltbare Blöcke zu organisieren und wiederholte Aufgaben zu erledigen.

def wird wie folgt verwendet:

def function_name(parameters):
　　　　...

Erfahren Sie mehr überPython-FunktionenMehr Informationen.

del

del wird verwendet, um Referenzen auf Objekte zu löschen. Alles ist ein Objekt in Python. Wir können Variablen löschen, indem wir del verwenden:

>>> a = b =　5
>>> del a
>>> a
Traceback (most recent call last):
　　File '<string>', line　301, in runcode
　　File '<interactive input>', line　1, in <module>
NameError: name 'a' is not defined
>>> b
5

Hier können wir sehen, dass die Referenz des Variablen a gelöscht wurde. Daher ist sie nicht mehr definiert. Aber b existiert immer noch.

del wird auch verwendet, um Elemente aus Listen oder Dictionaries zu löschen:

>>> a = ['x','y','z']
>>> del a[1]]
>>> a
['x', 'z']

if, else, elif

if, else, elif werden für bedingte Zweige oder Entscheidungen verwendet.

Wenn wir eine Bedingung testen und nur dann einen Block ausführen möchten, wenn die Bedingung wahr ist, verwenden wir if und elif. elif ist eine Abkürzung für else if. else ist der Block, der ausgeführt wird, wenn die Bedingung falsch ist. Dies wird durch den folgenden Beispiel klar:

def if_example(a):
　　　　if a ==　1:
　　　　　　　　print('Eins')
　　　　elif a ==　2:
　　　　　　　　print('Zwei')
　　　　else:
　　　　　　　　print('Etwas anderes')
if_example(2)
if_example(4)
if_example(1)

Ausgaberesultat

Zwei
Etwas anderes
One

Hier überprüft die Funktion den Eingabewert (wenn1oder2），und geben das Ergebnis aus. Andernfalls wird der else-Teil des Codes ausgeführt.

Erfahren Sie mehr überPython if und if ... else-AnweisungenMehr Informationen.

except, raise, try

except, raise, try werden mit Ausnahmen in Python verwendet.

Ausnahmen sind im Allgemeinen Fehler, die darauf hinweisen, dass ein Problem während der Ausführung unseres Programms aufgetreten ist. Einige Beispiele für Python-Ausnahmen sind IOError, ValueError, ZeroDivisionError, ImportError, NameError, TypeError usw. try...except-Blöcke werden verwendet, um Ausnahmen in Python zu fangen.

Wir können den Schlüssel raise explizit eine Ausnahme auslösen. Hier ist ein Beispiel:

def　reciprocal(num):
　　　　try:
　　　　　　　　r　=　1/num
　　　　except:
　　　　　　　　print('Exception　caught')
　　　　　　　　return
　　　　return　r
print(reciprocal(10))
print(reciprocal(0))

Ausgaberesultat

0.1
Exception　caught
None

Hier gibt die Funktion reciprocal() den Bruchteil des Eingabewertes zurück.

Eingabe10wenn, die normale Ausgabe ist 0.1。 Aber wenn wir 0 eingeben, wird ZeroDivisionError automatisch ausgelöst.

Dies wird von unserem try…except-Block erfasst und wir geben None zurück. Wir können ZeroDivisionError auch explizit auslösen, indem wir den Eingang überprüfen und ihn wie folgt anderswo behandeln:

if　num　==　0:
　　　　raise　ZeroDivisionError('cannot　divide')

finally

finally wird zusammen mit try…except-Blöcken verwendet, um Ressourcen oder Dateistreams zu schließen.

Verwenden Sie finally, um sicherzustellen, dass der interne Codeblock ausgeführt wird, selbst wenn es unbehandelte Ausnahmen gibt. Zum Beispiel:

try:
　　　　Try-block
except　exception1:
　　　　Exception1-block
except　exception2:
　　　　Exception2-block
else:
　　　　Else-block
finally:
　　　　Finally-block

Hier, wenn es einen Fehler gibt, Try-block, wird er in der except- oder else-Block verarbeitet. Aber egal in welcher Reihenfolge sie ausgeführt werden, können wir mit einem Fehler sicher Finally ausführen-block. Dies ist sehr nützlich für die Ressourcenfreigabe.

Erfahren Sie mehr überFehlerbehandlung in der Python-ProgrammierungMehr Informationen.

for

for wird zum Durchlaufen verwendet. Normalerweise verwenden wir for, wenn wir die Anzahl der Wiederholungen kennen.

In Python können wir sie mit jeder Art von Sequenz (z.B. Liste oder String) verwenden. Hier ist ein Beispiel, wie man die Liste names mit einem for-Schleife durchläuft：

names = ['John','Monica','Steven','Robin']
for i in names:
　　　　print('Hallo '+i)

Ausgaberesultat

Hallo John
Hallo Monica
Hallo Steven
Hallo Robin

Erfahren Sie mehr überPython for-SchleifeMehr Informationen.

from, import

import-Klausel wird verwendet, um Module in den aktuellen Namensraum zu importieren. from…import wird verwendet, um spezifische Attribute oder Funktionen in den aktuellen Namensraum zu importieren。例如：

import math

将导入math模块。现在我们可以将其中的cos()函数用作math.cos()。但是，如果我们只想导入cos()函数，则可以使用from来完成

from math import cos

现在我们可以简单地使用该函数cos()，无需编写math.cos()。

Erfahren Sie mehr über更多信息关于Python模块和import-Anweisungen.

global

global wird verwendet, um Variablen innerhalb einer Funktion als globale Variablen (außerhalb der Funktion) zu deklarieren.

如果我们需要读取全局变量的值，则不必将其定义为global。这是需要的地方。

如果需要在函数内部修改全局变量的值，则必须使用进行声明global。否则，将创建一个具有该名称的局部变量。

以下示例将帮助我们阐明这一点。

globvar =　10
def read1():
　　　　print(globvar)
def write1():
　　　　global globvar
　　　　globvar =　5
def write2():
　　　　globvar =　15
read1()
write1()
read1()
write2()
read1()

Ausgaberesultat

10
5
5

在这里，read1()函数只是读取globvar的值。因此，我们不需要将其声明为global。但是write1()函数正在修改值，因此我们需要将变量声明为global。

我们可以在输出中看到确实进行了修改（将10更改为5）。write2()还试图修改此值。但我们尚未将其声明为global。

因此，将globvar创建一个新的局部变量，该局部变量在该函数外部不可见。尽管我们将此局部变量修改为15，但全局变量保持不变。这在我们的输出中清晰可见。

in

in wird zur Überprüfung verwendet, ob eine Sequenz (Liste, Tupel, String usw.) einen bestimmten Wert enthält. Wenn der Wert existiert, wird True zurückgegeben,否则返回False。例如：

>>> a = [1,　2,　3,　4,　5]]
>>>　5　in a
True
>>>　10　in a
False

The secondary use of in is to traverse the sequence within the for loop.

for i in 'hello':
　　　　print(i)

Ausgaberesultat

h
e
l
l
o

is

is is used in Python to test the identity of an object. The == operator is used to test whether two variables are equal, while the is operator is used to test whether two variables refer to the same object.

It returns True if the objects are the same, otherwise False.

>>> True is True
True
>>> False is False
True
>>> None is None
True

We know that there is only one instance of True, False, and None in Python, so they are the same.

>>> [] == []
True
>>> [] is []
False
>>> {} == {}
True
>>> {} is {}
False

An empty list or dictionary is equal to another empty list or dictionary, but they are not the same objects because they are located in memory separately. This is because lists and dictionaries are mutable (values can be changed).

>>> '' == ''
True
>>> '' is ''
True
>>> () == ()
True
>>> () is ()
True

Unlike lists and dictionaries, strings and tuples are immutable (values cannot be changed once defined). Therefore, two equal strings or tuples are also the same. They refer to the same storage location.

lambda

lambda is used to create anonymous functions (nameless functions). It is an inline function that does not contain a return statement and consists of an expression that is evaluated and returned. For example:

a = lambda x: x*2
for　i　in　range(1,6)
　　　　print(a(i))

Ausgaberesultat

2
4
6
8
10

Here, we create an inline function using the lambda statement to double the value. We use it to double the values of1to5values in the list are doubled.

Erfahren Sie mehr überPython lamda function'sMehr Informationen.

nonlocal

The usage of the nonlocal keyword is very similar to the global keyword. nonlocal is used to declare that a variable within a nested function (a function within a function) is not a local variable, which means it is located in the outer enclosing function. If you need to modify the value of a nonlocal variable within a nested function, you must use the declaration nonlocal. Otherwise, a local variable with that name will be created within the nested function. The following example will help illustrate this point.

def outer_function():
　　　　a =　5
　　　　def inner_function():
　　　　　　　　nonlocal a
　　　　　　　　a =　10
　　　　　　　　print("Innere Funktion: ", a)
　　　　inner_function()
　　　　print("Außenfunktion: ", a)
outer_function()

Ausgaberesultat

Innere Funktion:　　10
Außenfunktion:　　10

Here, the inner_function() is nested within the outer_function.

Variable a is located within the outer_function(). Therefore, if you want to modify a in the inner_function(), you must declare it as nonlocal. Please note that this a is not a global variable.

Daher sehen wir aus dem Output, dass die Variable erfolgreich im inneren Function() inneren inner_function() geändert wurde. Das Ergebnis ohne den nonlocal-Schlüsselwört ist wie folgt:

def outer_function():
　　　　a =　5
　　　　def inner_function():
　　　　　　　　a =　10
　　　　　　　　print("Innere Funktion: ", a)
　　　　inner_function()
　　　　print("Außenfunktion: ", a)
outer_function()

Ausgaberesultat

Innere Funktion:　　10
Außenfunktion:　　5

Hier erklären wir, dass wir die Variable a in der inneren Funktion nicht als nicht-lokal deklarieren. Daher wird eine neue lokale Variable mit dem gleichen Namen erstellt, die die nicht-lokale Variable a nicht ändert, wie unser Output zeigt.

pass

pass ist ein leeres Statement in Python. Es passiert nichts, wenn es ausgeführt wird. Es wird als Platzhalter verwendet.

Angenommen, wir haben eine Funktion, die wir noch nicht implementiert haben, aber die wir in der Zukunft implementieren möchten. Einfach gesagt,

def function(args):

Indem wir im Mittel der Programmierung IndentationError erhalten, verwenden wir stattdessen das pass-Statement, um einen leeren Körper zu konstruieren.

def function(args):
　　　　pass

Wir können auch eine leere Klasse verwenden, um dasselbe zu tun.

class example:
　　　　pass

return

Das return-Statement wird im Funktionskörper verwendet, um den Rückgabewert abzugeben und die Funktion zu beenden.

Wenn wir keine explizite Rückgabewert angeben, wird automatisch None zurückgegeben. Das folgende Beispiel überprüft dies.

def func_return():
　　　　a =　10
　　　　return a
def no_return():
　　　　a =　10
print(func_return())
print(no_return())

Ausgaberesultat

10
None

while

while wird in Python für Schleifen verwendet.

Der Ausdruck im while-Loop wird so lange ausgeführt, bis die Bedingung des while-Loops False ergibt oder ein break-Ausdruck auftritt. Das folgende Beispiel erläutert dies.

i =　5
while(i):
　　　　print(i)
　　　　i = i –　1

Ausgaberesultat

5
4
3
2
1

Beachten Sie, dass 0 False ist.

Erfahren Sie mehr überDer Python-while-LoopMehr Informationen.

with

Der with-Ausdruck wird verwendet, um den Ausführungskontext eines Blocks zu verpacken, der in den Methoden eines Context-Managers definiert ist.

Der Context-Manager ist eine Klasse, die die Methoden __enter__ und __exit__ implementiert. Mit dem with-Ausdruck kann sichergestellt werden, dass __exit__ am Ende des verknüpften Blocks aufgerufen wird. Dieses Konzept ähnelt der Verwendung von try…finally-Blöcken. Hier ist ein Beispiel.

mit open('example.txt', 'w') as my_file:
　　　　my_file.write('Hello　world!')

In diesem Beispiel wird der Text Hello world! in die Datei example.txt geschrieben. Das Dateiobjekt definiert __enter__ und __exit__-Methoden, daher fungieren sie als eigene Kontextmanager.

Zunächst wird die Methode __enter__ aufgerufen, dann wird der Code im with-Block ausgeführt und schließlich wird die Methode __exit__ aufgerufen. __exit__ wird auch aufgerufen, selbst wenn es Fehler gibt. Es schließt im Grunde genommen den Dateistream.

yield

yield wird in Funktionen wie der return-Anweisung verwendet. Aber yield gibt einen Generator zurück.

Ein Generator ist ein Iterator, der einen Eintrag nach dem anderen generiert. Eine große Anzahl von Werten würde viel Speicherplatz beanspruchen. Ein Generator ist in diesem Fall sehr nützlich, da er nur einen Wert nach dem anderen generiert, anstatt alle Werte im Speicher zu speichern. Zum Beispiel

>> g = (2**x für x in range(100))

Es wird ein Generator g erstellt, der eine2der Potenz, bis die Summe der Generierung hinzugefügt wird99der2der Potenz. Wir können diese Zahlen wie gezeigt mit der Funktion next() generieren.

>> next(g)
1
>> next(g)
2
>> next(g)
4
>> next(g)
8
>> next(g)
16

Nach und nach ... Diese Art von Generator wird durch die Anweisung der yield-Funktion zurückgegeben. Dies ist ein Beispiel.

def　generator():
　　　　for　i　in　range(6)
　　　　　　　　yield　i*i
g　=　generator()
for　i　in　g:
　　　　print(i)

Ausgaberesultat

0
1
4
9
16
25

Hier gibt die Funktion generator() einen Generator zurück, der von 0 bis5Die Quadrat der Zahl. Drucken Sie sie im for-Schleifendurch.