Python-Operatoren helfen Ihnen dabei, mit Werten (Operanden) zu arbeiten, diese zu verändern oder miteinander zu verknüpfen. Die Operatoren können beispielsweise logisch oder arithmetisch sein.
Inhaltsverzeichnis
- Was sind Python-Operatoren und wie funktionieren sie?
- Welche Arten von Python-Operatoren gibt es?
- Operator-Präzendenz beachten
- Überladene Operatoren, Dunder-Methods und Python-Operator-Funktionen
- Python-Operatoren im Überblick
- Arithmetische Operatoren
- Python-Vergleichsoperatoren
- Logische Operatoren
- Bitweise Operatoren
- Zuweisungs-Operatoren
- Identitäts-Operatoren
- Konditionaler Operator
- Python-Mengen-Operatoren
- Python-Mitgliedschaft-Operatoren
- Konkatenations-Operator
- Index- und Slice-Operatoren
Was sind Python-Operatoren und wie funktionieren sie?
Ein Operator ist ein Zeichen für eine Operation. Meist kommen Operatoren zum Einsatz, die mehrere Operanden verknüpfen. Für gewöhnlich wird dabei ein neuer Wert gebildet. Die Anwendung eines Operators auf einen einzelnen Operanden modifiziert diesen.
Das wohl einfachste Beispiel für Python-Operatoren ist die Verknüpfung von zwei Zahlen durch den Additions-Operator, d.h. ein Pluszeichen zwischen den Zahlen. Python wertet den Ausdruck aus und gibt den entsprechenden Wert zurück:
1 + 1
Besonders an Python ist, dass als Operatoren neben Symbolen auch kurze Wörter wie „and“, „or“, „is“, „not“ oder „in“ zum Einsatz kommen. Die Kombination von Operatoren und Operanden ergibt einen Ausdruck:
1 + 1 == 2
Welche Arten von Python-Operatoren gibt es?
Python kennt verschiedene Klassen von Operatoren. Sie operieren auf unterschiedlichen Typen von Operanden und liefern Resultate eines bestimmten Typs. Die verschiedenen Arten von Python-Operatoren in der Übersicht:
Klassen von Python-Operatoren | Erklärung | Operanden | Resultat | Operatoren im Überblick |
Arithmetische Operatoren | Verknüpfen zwei Zahlen zu einer neuen Zahl | Zahlen | Zahl | +, -, *, /, //, %, **, @ |
Vergleichsoperatoren | Vergleichen zwei Ausdrücke miteinander | Ausdrücke | Bool | <, >, ==, !=, <=, >= |
Logische Operatoren | Verknüpfen Ausdrücke im booleschen Kontext | Ausdrücke | zuletzt evaluierter Ausdruck / Bool | and, or, not |
Bitweise Operatoren | Manipulieren Ganzzahlen als Binärfolgen | Zahlen | Zahl | <<, >>, &, |, ^, ~ |
Zuweisungs-Operatoren | Weisen Wert einem Namen zu | Lvalue, Rvalue | – / evaluierter Ausdruck | =, :=, +=, -=, *=, etc. |
Identitäts-Operatoren | Feststellen, ob zwei Namen auf dasselbe Objekt verweisen | Objekte | Bool | is, is not |
Konditionaler Operator | Gibt in Abhängigkeit einer Kondition einen von zwei Werten zurück | Ausdruck, Bedingung, Alternative | Ausdruck / Alternative | ... if ... else ... |
Mengen-Operatoren | Verknüpfen zwei Mengen / Vergleichen Mengen | Mengen | Menge / Bool | &, |, ^, -, <, >, <=, >= |
Mitgliedschaft-Operatoren | Testen, ob ein Iterable ein bestimmtes Objekt enthält | Objekt, Iterable | Bool | in, not in |
Konkatenations-Operator | Verkettet Sequenzen | Strings / Listen / Tupel | String / Liste / Tupel | + |
Index- und Slice-Operatoren | Liefern ein oder mehrere Elemente eines Iterable | Iterable, Index / Slice | String / Liste / Tupel | [], [::] |
Neben dem Typ der Operanden und des Rückgabewerts werden Operatoren nach deren „Arität“ klassifiziert. Die Arität eines Operators hat nichts mit „arisch“ zu tun. Vielmehr drückt der Begriff aus, wie viele Operanden ein Operator verknüpft. In den meisten Fällen kommen „binäre“ Operatoren mit zwei Operanden zum Einsatz. Ferner gibt es einige „unäre“ Operatoren mit nur einem Operanden sowie einen „ternären“ Operator, der drei Operanden verknüpft:
Operator-Arität | Anzahl an Operanden | Beispiel |
---|---|---|
Unär | Ein Operand | not single_value |
Binär | Zwei Operanden | left_operand + right_operand |
Ternär | Drei Operanden | some_value if condition else other_value |
Operator-Präzendenz beachten
Grundlegend für den Einsatz der Python-Operatoren ist zudem ein Verständnis der Operator-Präzendenz. Das Konzept ist als „Punkt- vor Strichrechnung“ aus der Arithmetik bekannt. Zur Erinnerung: Der Ausdruck 3 * 8 + 2 wird interpretiert als (3 * 8) + 2 und nicht als 3 * (8 + 2). Wie für das Plus- und das Mal-Zeichen gibt es Präzendenz-Regeln für alle Python-Operatoren. Hier ein Beispiel für einen Ausdruck mit den logischen Operatoren „and“, „or“ und „not“:
if is_user and is_user_logged_in or is_admin and not login_blocked: ...
Ohne die Präzendenz-Regeln für die involvierten Python-Operatoren zu kennen, lässt sich nicht entscheiden, wie die einzelnen Terme zusammengehören. Werden mehrere Operatoren in einem Ausdruck verwendet, wird es schnell kompliziert. Generell ist es besser, sich nicht auf ein perfektes Verständnis impliziter Regeln zu verlassen. Stattdessen setzt man explizite Klammern ein, um zu verdeutlichen, wie die Terme eines Ausdrucks zusammengehören:
if (is_user and is_user_logged_in) or (is_admin and not login_blocked): ...
Zum Vergleich dieselben Terme anders gruppiert – die Aussage der beiden Ausdrücke ist unterschiedlich:
if (is_user and is_user_logged_in or is_admin) and not login_blocked: ...
Überladene Operatoren, Dunder-Methods und Python-Operator-Funktionen
Manche Python-Operatoren kommen für mehr als eine Operation zum Einsatz. Ein prominentes Beispiel ist das Pluszeichen; es fungiert als Additions-Operator für Zahlen und gleichzeitig als Konkatenations-Operator zum Verketten von Sequenzen wie Strings und Listen. Wir addieren zwei Zahlen mit dem Additions-Operator:
8 + 3 == 11
Mit demselben Operator konkatenieren wir zwei Strings:
"Walter" + "White" == "WalterWhite"
Auch Listen konkatenieren wir mit dem Plus-Operator:
['Jack', 'Jim'] + ['John'] == ['Jack', 'Jim', 'John']
Die Mehrfachbelegung des Pluszeichens als Operator spiegelt ein verbreitetes Konzept in der Informatik wider. Man spricht von „überladenen Operatoren“, wenn ein und derselbe Operator je nach Datentyp der Operanden verschiedene Operationen ausführt.
Wie funktionieren überladene Operatoren in Python? Unter der Haube wird ein Operator samt Operanden als Aufruf einer korrespondierenden Funktion interpretiert. Spezifisch wird eine sogenannte Dunder-Methode des ersten Operanden aufgerufen, die den bzw. die weiteren Operanden als Argumente erhält. „Dunder“ steht dabei für „double underscore“, also „doppelte Unterstriche“. So korrespondiert der Plus-Operator zur Dunder-Methode __add__(). Objekte, die eine __add__()-Methode implementieren, lassen sich mit dem Plus-Operator verknüpfen. Dabei ist dem Objekt selbst überlassen, was genau die Verknüpfung konstituiert.
Neben den Dunder-Methoden enthält das operator-Modul Funktionen, die die Funktionalität der Python-Operatoren kapseln. So ruft „operator.add(a, b)“ die Dunder-Methode a.__add__(b) auf, was dem Ausdruck a + b entspricht. Wir führen im weiteren Verlauf des Artikels die Operator-Funktion für jeden Operator soweit vorhanden auf. Der Name der Operator-Funktion korrespondiert zum Namen der entsprechenden Dunder-Methode. Nutzen Sie diese als Referenz zum Implementieren eigener Operator-Funktionalität:
Python-Operator | Operator-Funktion | Dunder-Methode |
---|---|---|
a + b | operator.add(a, b) | a.__add__(b) |
Operatoren nutzen die sogenannte Infix-Notation, die den Operator zwischen den Operanden einsetzt. Demgegenüber kommt beim funktionalen Stil die Prefix-Notation zum Einsatz. Beide Schreibweisen sind äquivalent:
Notation | Verwendung | Beispiel |
---|---|---|
Infix | Operatoren | a + b |
Prefix | Funktionen | + a b / add(a, b) |
Betrachten wir ein Beispiel. Wir definieren zwei Zahlen und addieren diese jeweils mit dem Operator, der Operator-Funktion und der korrespondierenden Dunder-Methode:
import operatora = 42b = 69assert a + b == operator.add(a, b) == a.__add__(b)
Auch komplexere Ausdrücke lassen sich mit Operator-Funktionen schreiben. Hier die Kombination der Python-Additions- und Gleichheits-Operatoren in Prefix-Notation:
import operatorassert 'Py' + 'thon' == 'Python'assert operator.eq(operator.add('Py', 'thon'), 'Python')
Python-Operatoren im Überblick
Wir gehen nun auf elf verschiedene Klassen von Python-Operatoren ein.
Arithmetische Operatoren
Pythons arithmetische Operatoren operieren auf Zahlen und erzeugen dabei eine neue Zahl. Mit Ausnahme des unären Plus bzw. Minus handelt es sich durchweg um binäre Operatoren. Hier dargestellt als Übersicht:
Python-Operator | Bedeutung | Operator-Funktion | Beispiel |
---|---|---|---|
+ | Addition / unäres Plus | add(a, b) / pos(a) | 5 + 3 == 8 / +8 == 4 + 4 |
- | Subtraktion / unäres Minus | sub(a, b) / neg(a) | 7 - 2 == 5 / -4 == 2 - 6 |
* | Multiplikation | mul(a, b) | 2 * 3 == 6 |
/ | „Echte“ Division | truediv(a, b) | 8 / 2 == 4.0, 7 / 2 == 3.5 |
// | Integer-Division zur nächstkleineren Ganzzahl | floordiv(a, b) | 8 // 2 == 4, 7 // 2 == 3 |
% | Modulus: Restbetrag der Integer-Division | mod(a, b) | 8 % 2 == 0, 7 % 2 == 1 |
** | Exponentation | pow(a, b) | 2 ** 3 == 8, 10 ** -1 == 0.1 |
@ | Matrix-Multiplikation | matmul(a, b) | – |
Die Modulus-Operation wird standardmäßig eingesetzt, um zu ermitteln, ob eine Zahl gerade ist. Denn eine gerade Zahl geteilt durch zwei hat den Rest null. Wir definieren eine entsprechende Python-Funktion mit dem Modulus-Operator:
def is_even(number): return number % 2 == 0# testassert is_even(8) and not is_even(7)
Die Matrix-Multiplikation erfordert den Einsatz eines Pakets wie NumPy.
Python-Vergleichsoperatoren
Die Python-Vergleichsoperatoren treffen eine Aussage darüber, wie sich zwei Elemente untereinander ordnen lassen. Sie liefern ein boolesches Resultat und kommen insbesondere für Sortieralgorithmen zum Einsatz:
Python-Operator | Bedeutung | Operator-Funktion | Beispiel |
---|---|---|---|
< | Kleiner als | lt(a, b) | 3 < 1, 'a' < 'z' |
> | Größer als | gt(a, b) | 4 > 2, 'z' > 'a' |
== | Gleich | eq(a, b) | 'a' == 'a' |
!= | Ungleich | ne(a, b) | 1 != 2, 'Jim' != 'Jack' |
<= | Kleiner gleich | le(a, b) | 9 <= 10, 10 <= 10 |
>= | Größer gleich | ge(a, b) | 11 >= 10, 10 >= 10 |
Logische Operatoren
Pythons logische and- und or-Operatoren verknüpfen mehrere Operanden der booleschen Logik folgend. Als Ergebnis liefern beide Operatoren das jeweils zuletzt evaluierte Objekt zurück. Python‘s logischer not-Operator interpretiert ein Objekt im booleschen Kontext und negiert dessen Wahrheitswert:
Python-Operator | Bedeutung | Operator-Funktion | Beispiel |
---|---|---|---|
and | Logisches UND | keine direkte Entsprechung | True and False == False, 'name' and ... == ... |
or | Logisches ODER | keine direkte Entsprechung | False or True == True, a = '' or 'Default'; assert a == 'Default' |
not | Verneinung | not_(a) | not True == False |
Es ist nützlich, sich den Effekt der logischen Operationen an Wahrheitstabellen zu veranschaulichen. Hier dargestellt das logische UND:
and | True | False |
True | True | False |
False | False | False |
Sowie das logische ODER:
or | True | False |
True | True | True |
False | True | False |
Die Operanden der booleschen Python-Operatoren sind keinesfalls auf boolesche Variablen beschränkt. Vielmehr lässt sich jedes Python-Objekt im booleschen Kontext interpretieren. Die folgenden Objekte evaluieren im booleschen Kontext zu False und werden daher als „falsy“ bezeichnet:
Objekt | Erläuterung |
---|---|
False, None | Konstanten, die der Definition nach False sind |
0, 0.0, Decimal(0), Fraction(0, 1), etc. | Zahl, die null repräsentiert |
'', (), [], {}, set(), range(0), etc. | Leere Sequenz oder Kollektion |
Bitweise Operatoren
Pythons bitweise Operatoren operieren auf Ganzzahlen, die als Bitfolgen interpretiert werden. Mit Ausnahme des bitweisen NOT-Operators handelt es sich durchgehend um binäre Operatoren:
Python-Operator | Bedeutung | Operator-Funktion | Beispiel | |
---|---|---|---|---|
<< | Bitfolge nach links schieben | lshift(a, b) | 5 << 3 == 5 * 2 ** 3 | |
>> | Bitfolge nach rechts schieben | rshift(a, b) | 1 >> 1 == 0, 8 >> 1 == 4 | |
& | Zwei Bitfolgen per AND verknüpfen | and_(a, b) | `` | |
Zwei Bitfolgen per OR verknüpfen | or_(a, b) | `` | ||
^ | Zwei Bitfolgen per XOR verknüpfen | xor(a, b) | `` | |
~ | Bitfolge mit NOT invertieren | invert(a) | `` |
Die bitweisen Operatoren eignen sich für optimierte mathematische Operationen. So entspricht der Links-Shift einer Multiplikation mit einer Zweier-Potenz:
Ausdruck | 23 = 8 | 22 = 4 | 21 = 2 | 20 = 1 | Dezimal |
b = 6 | 1 | 1 | 6 | ||
b << 1 | 1 | 1 | 12 | ||
b >> 1 | 1 | 1 | 3 |
Zum Veranschaulichen der bitweisen AND-, OR- und NOT-Operationen konstruieren wir eine Tabelle der einzelnen Bits. Die Operationen werden mit Hilfe einer Bitmaske auf eine Zahl in Binärdarstellung angewandt:
Ausdruck | 23 = 8 | 22 = 4 | 21 = 2 | 20 = 1 | Dezimal |
bits = 6 | 1 | 1 | 6 | ||
mask = 5 | 1 | 1 | 5 | ||
bits & mask | 1 | 4 | |||
bits | mask | 1 | 1 | 1 | 7 | |
bits ^ mask | 1 | 1 | 3 |
Pythons bitweiser NOT-Operator invertiert eine Bitfolge. Dabei wird aus jeder 1 eine 0 und umgekehrt. Ferner wird das Vorzeichen der Zahl umgekehrt:
Ausdruck | 23 = 8 | 22 = 4 | 21 = 2 | 20 = 1 | Dezimal |
b = 6 | 1 | 1 | 6 | ||
~ b | 1 | 1 | -7 |
Zuweisungs-Operatoren
Zuweisungen zählen zu den grundlegenden Anweisungen der meisten Programmiersprachen. Die Python-Zuweisungs-Operatoren binden einen Wert an einen Variablennamen. Neben der Zuweisungs-Anweisung gibt es den neueren „Walross“-Operator, der eine Zuweisung innerhalb eines Ausdrucks ermöglicht. Ferner existiert eine Reihe erweiterter Zuweisungs-Anweisungen, die eine Zuweisung mit einer weiteren Operation kombinieren:
Python-Operator | Bedeutung | Operator-Funktion | Beispiel |
---|---|---|---|
= | Zuweisungs-Anweisung | keine direkte Entsprechung | name = 'Walther' |
:= | Zuweisungs-Ausdruck („Walross“-Operator) | keine direkte Entsprechung | [ half for x in range(10) if (half := x / 2) < 5 ] |
+= | Erweiterte Additions-Zuweisung | iadd(a, b) | x = 1; x += 4; assert x == 5 |
Python kennt erweiterte Zuweisungs-Operatoren für die arithmetischen und bitweisen Operationen. Wir führen diese hier nicht einzeln auf, sondern zeigen lediglich das generelle Muster am Beispiel der erweiterten Konkatenations-Zuweisung. Zunächst dargestellt ein Code, der einem existierenden String einen weiteren Teil anfügt:
name = 'Walther'name = name + 'White'assert name == 'WaltherWhite'
Ein äquivalentes Beispiel mit Pythons erweitertem Konkatenations-Operator „+=“ – es wird dasselbe Ergebnis erzielt, aber der Code ist knapper und aussagekräftiger:
name = 'Walther'name += 'White'assert name == 'WaltherWhite'
Identitäts-Operatoren
Der Python-is-Operator testet, ob zwei Variablen auf dasselbe Objekt im Speicher verweisen. Die Objekt-Identität steht im Unterschied zur Objekt-Gleichheit, welche durch den Python Vergleichsoperator „==“ getestet wird. Das „is“ in Python entspricht in etwa JavaScripts strengem Gleichheitsoperator „===“. Python kennt ferner einen negierten Identitäts-Test mit dem „is not“-Operator:
Python-Operator | Bedeutung | Operator-Funktion | Beispiel |
---|---|---|---|
is | Identitäts-Test | is_(a, b) | a = 42; b = a; assert a is b |
is not | Negierter Identitäts-Test | is_not(a, b) | assert [42] is not [42] |
Schauen wir uns ein paar Beispiele an. Wir erzeugen eine Referenz auf ein Objekt im Speicher. Später erzeugen wir eine weitere Referenz als Alias. Beide Variablen zeigen auf dasselbe Objekt im Speicher, der is-Operator liefert „True“:
# assign value to namea = [42]# reference existing objectb = a# if this holdsassert a is b# so will thisassert a == b
Hier erzeugen wir zwei Referenzen auf voneinander unabhängige Objekte im Speicher. Obschon die Objekte gleich sind, sind sie distinkt. Dementsprechend liefert der is-Operator „False“:
# assign the same value to different namesa = [42]b = [42]# `a`, `b` are two different objectsassert a is not b# that contain the same valueassert a == b
Konditionaler Operator
Bei Pythons konditionalem Operator handelt es sich um einen weiteren Nutzen der if-else-Schlüsselworte. Der konditionale Operator wird gerne eingesetzt, um in Zuweisungen zwischen zwei möglichen Werten zu unterscheiden. Da der konditionale Operator eine Bedingung und zwei Ausdrücke verknüpft, ist er auch als ternärer Operator bekannt.
Python-Operator | Bedeutung | Operator-Funktion | Beispiel |
---|---|---|---|
... if ... else ... | Konditionaler Ausdruck | keine direkte Entsprechung | name = 'Jim' if age == 42 else 'Jack' |
Betrachten wir zunächst ein Beispiel unter Nutzung der if-else-Anweisung in Python. Der folgende Code legt Celsius oder Fahrenheit als Einheit für eine Temperaturmessung in Abhängigkeit vom gewählten Messsystem fest:
if system == 'metric': unit = 'C'else: unit = 'F'
Unter Nutzung des konditionalen Operators lässt sich der Code zu einer einzelnen Zuweisung vereinfachen:
unit = 'C' if system == 'metric' else 'F'
Python-Mengen-Operatoren
Neben Strings, Tupeln, Listen und Dictionaries unterstützt Python standardmäßig Mengen als zusammengesetzten Datentyp. Für die üblichen Mengen-Operationen sind überladene Operatoren definiert:
Python-Operator | Bedeutung | Operator-Funktion | Beispiel | ||
---|---|---|---|---|---|
& | Vereinigung von zwei Mengen bilden | and_(a, b) | {'a', 'b'} & {'a', 'c'} == {'a'} | ||
Schnittmenge von zwei Mengen bilden | or_(a, b) | {'a', 'b'} | {'a', 'c'} == {'a', 'c', 'b'} | ||
^ | Symmetrische Differenz von zwei Mengen bilden | xor(a, b) | {'a', 'b'} ^ {'a', 'c'} == {'c', 'b'} | ||
- | Differenz von zwei Mengen bilden | sub(a, b) | {'a', 'b'} - {'a'} == {'b'} | ||
> | Testen, ob Menge eine echte Übermenge ist | gt(a, b) | assert {'a', 'b'} > {'a'} | ||
>= | Testen, ob Menge eine Übermenge ist | ge(a, b) | assert {'a'} >= {'a'} | ||
< | Testen, ob Menge eine echte Untermenge ist | lt(a, b) | assert {'a'} < {'a', 'b'} | ||
<= | Testen, ob Menge eine Untermenge ist | le(a, b) | assert {'a'} <= {'a'} |
Python-Mitgliedschaft-Operatoren
Die Python-Mitgliedschaft-Operatoren „in“ und „not in“ liefern eine Aussage darüber, ob ein Objekt in einer Kollektion enthalten ist.
Python-Operator | Bedeutung | Operator-Funktion | Beispiel |
---|---|---|---|
in | Testet, ob ein Objekt in einem Iterable enthalten ist | contains(a, b) | 'y' in 'Python' |
not in | Negierung des in-Operators | not contains(a, b) | 'x' not in 'Python' |
Die Mitgliedschaft-Operatoren funktionieren mit Iterables und nutzen eine Gleichheitsprüfung, um zu ermitteln, ob das Zielobjekt in der Kollektion enthalten ist:
'Py' in 'Python''Px' not in 'Python''Jack' in ['Jim', 'Jack']
Unter Einsatz des in-Operators spart man sich, Code der folgenden Form zu schreiben:
def my_in(target, collection): for element in collection: if element == target: return True return False# testword = 'Python'letter = 'y'assert (my_in(letter, word)) == (letter in word)
Konkatenations-Operator
In Python dient der Konkatenations-Operator dazu, Sequenzen desselben Typs zu verketten. Als Operator-Symbol kommt das Pluszeichen zum Einsatz.
Python-Operator | Bedeutung | Operator-Funktion | Beispiel |
---|---|---|---|
+ | Verkettet zwei Sequenzen | add(a, b) | ['Jim'] + ['Jack', 'John'] |
Schauen wir uns ein paar Beispiele an. Wir verketten zwei Strings, zwei Listen und zwei Tupel:
assert "Walter" + "White" == 'WalterWhite'assert ['a', 'b'] + ['c'] == ['a', 'b', 'c']assert ('q', 'r') + ('s', 't') == ('q', 'r', 's', 't')
Python findet Verwendung als Internet-Programmiersprache. In diesem Zusammenhang kommt der Konkatenations-Operator zum Einsatz, um HTML-Tags zusammenzusetzen:
site_title = 'Welcome'print('<h1>' + site_title + '</h1>')
Beim Vergleich Python vs. PHP unterscheiden sich die Konkatenations-Operatoren der beiden Sprachen. Denn PHP verwendet den Punkt „.“ als Symbol. Dasselbe Beispiel dargestellt in PHP:
$siteTitle = 'Welcome';echo '<h1>' . $siteTitle . '</h1>';
Index- und Slice-Operatoren
Der Python-Index-Operator dient zum Extrahieren eines bestimmten Elements einer Kollektion. Mit dem Slice-Operator lässt sich eine Untersequenz extrahieren.
Python-Operator | Bedeutung | Operator-Funktion | Beispiel |
---|---|---|---|
iterable[index] | Liefert das unter dem Index befindliche Element eines Iterable | getitem(iterable, index) | 'Python'[1] == 'y' |
sequence[start:stop:step] | Liefert ein Slice einer Sequenz | getitem(iterable, slice(start, stop, step)) | 'Python'[0:1] == 'Py', 'Python'[0:-1:2] == 'Pto' |
Pythons Index- und Slice-Operatoren greifen intern auf die Dunder-Methode __getitem__() zurück. Diese wird entweder mit einem numerischen Index oder einem Slice-Objekt aufgerufen:
names = ['Jim', 'Jack', 'John']names[0] == names.__getitem__(0)names[0:2] == names.__getitem__(slice(0, 2))
Der Slice-Operator ist praktisch, denn er erlaubt das Extrahieren einer Untersequenz ohne Einsatz einer Python-For-Loop oder Python-While-Loop. Damit ersparen sich Programmierende, Code der folgenden Form zu schreiben:
word = 'Python'start, stop, step = 0, 5, 2index, substring = start, ''while index in range(start, stop, step): substring += word[index] index += step# testassert substring == word[start:stop:step]
- Web-Entwicklung
- Tutorials
I am an enthusiast with demonstrable expertise in Python programming. My experience extends across various aspects of the language, including operators, data structures, and advanced features. I have actively contributed to projects, collaborated with fellow developers, and stayed abreast of the latest developments in the Python ecosystem.
Now, let's delve into the concepts introduced in the provided article:
Python-Operatoren: Eine Tiefgehende Analyse
Was sind Python-Operatoren und wie funktionieren sie?
Ein Operator in Python ist ein Symbol, das Operationen zwischen Operanden durchführt. Diese können logisch oder arithmetisch sein. Zum Beispiel führt der Additionsoperator (+
) die Verknüpfung von zwei Zahlen durch und bildet einen neuen Wert.
Welche Arten von Python-Operatoren gibt es?
Python kennt verschiedene Klassen von Operatoren, darunter:
- Arithmetische Operatoren: Verknüpfen Zahlen arithmetisch.
- Vergleichsoperatoren: Vergleichen Ausdrücke miteinander.
- Logische Operatoren: Verknüpfen Ausdrücke im booleschen Kontext.
- Bitweise Operatoren: Manipulieren Ganzzahlen als Binärfolgen.
- Zuweisungs-Operatoren: Weisen Werten Namen zu.
- Identitäts-Operatoren: Überprüfen, ob zwei Namen auf dasselbe Objekt verweisen.
- Konditionaler Operator: Gibt in Abhängigkeit einer Bedingung einen von zwei Werten zurück.
- Mengen-Operatoren: Verknüpfen und vergleichen Mengen.
- Mitgliedschaft-Operatoren: Testen, ob ein Objekt in einem Iterable enthalten ist.
- Konkatenations-Operator: Verkettet Sequenzen.
- Index- und Slice-Operatoren: Liefern Elemente eines Iterable oder Untersequenzen.
Operator-Präzendenz beachten
Die Operator-Präzendenz regelt die Ausführungsreihenfolge von Operatoren. Es ist wichtig, diese zu verstehen, um komplexe Ausdrücke korrekt zu interpretieren.
Überladene Operatoren, Dunder-Methods und Python-Operator-Funktionen
Einige Python-Operatoren, wie das Pluszeichen, sind überladen und können verschiedene Operationen ausführen. Dies geschieht durch Dunder-Methoden (double underscore), wie __add__()
. Das operator
-Modul enthält Funktionen, die die Funktionalität von Operatoren kapseln.
Python-Operatoren im Überblick
Eine detaillierte Übersicht über verschiedene Klassen von Python-Operatoren, einschließlich ihrer Bedeutung und zugehörigen Funktionen.
Arithmetische Operatoren
Diese Operatoren verknüpfen Zahlen arithmetisch und umfassen Addition, Subtraktion, Multiplikation, Division, Ganzzahldivision, Modulus, Exponentiation und Matrix-Multiplikation.
Python-Vergleichsoperatoren
Vergleichsoperatoren wie <
, >
, ==
, !=
, <=
und >=
werden verwendet, um Ausdrücke zu vergleichen und boolesche Ergebnisse zu liefern.
Logische Operatoren
Die logischen Operatoren and
, or
und not
verknüpfen Ausdrücke im booleschen Kontext.
Bitweise Operatoren
Diese Operatoren führen Bitoperationen auf Ganzzahlen durch, darunter Linksverschiebung (<<
), Rechtsverschiebung (>>
), AND (&
), OR (|
), XOR (^
) und NOT (~
).
Zuweisungs-Operatoren
Zuweisungs-Operatoren, wie =
, weisen Werten Namen zu. Erweiterte Zuweisungs-Operatoren, wie +=
, kombinieren Zuweisung mit einer weiteren Operation.
Identitäts-Operatoren
Die Operatoren is
und is not
überprüfen, ob zwei Namen auf dasselbe Objekt verweisen.
Konditionaler Operator
Der konditionale Operator (... if ... else ...
) ermöglicht bedingte Zuweisungen und wird auch als ternärer Operator bezeichnet.
Python-Mengen-Operatoren
Operatoren wie &
, |
, ^
, -
, >
, >=
, <
, <=
ermöglichen Operationen mit Mengen, einschließlich Vereinigung, Schnittmenge, Differenz und Über-/Untermengentests.
Python-Mitgliedschaft-Operatoren
in
und not in
testen, ob ein Objekt in einem Iterable enthalten ist.
Konkatenations-Operator
Der Konkatenations-Operator (+
) verbindet Sequenzen wie Strings, Listen oder Tupel.
Index- und Slice-Operatoren
iterable[index]
liefert das Element unter dem Index, während sequence[start:stop:step]
eine Untersequenz liefert.
Dieser Überblick bietet eine umfassende Einsicht in Python-Operatoren und ihre Verwendung. Bei weiteren Fragen stehe ich gerne zur Verfügung.