Einführung:
In diesem Artikel besprechen wir Python-Operatoren. Der Operator ist ein Symbol, das gemäß einer Definition eine bestimmte Operation zwischen zwei Operanden ausführt. Operatoren dienen als Grundlage für den Aufbau der Logik in einem Programm in einer bestimmten Programmiersprache. In jeder Programmiersprache führen einige Operatoren mehrere Aufgaben aus. Wie andere Sprachen verfügt auch Python über einige Operatoren, die im Folgenden aufgeführt sind:
- Rechenzeichen
- Vergleichsoperatoren
- Zuweisungsoperatoren
- Logische Operatoren
- Bitweise Operatoren
- Mitgliedschaftsbetreiber
- Identitätsoperatoren
- Rechenzeichen
Rechenzeichen
Arithmetische Operatoren, die zwischen zwei Operanden für eine bestimmte Operation verwendet werden. Es gibt viele arithmetische Operatoren. Es umfasst den Exponentenoperator (**) sowie die Operatoren + (Addition), - (Subtraktion), * (Multiplikation), / (Division), % (Erinnerung) und // (Bodendivision).
Betrachten Sie die folgende Tabelle für eine detaillierte Erläuterung der arithmetischen Operatoren.
| Operator | Beschreibung |
|---|---|
| + (Ergänzung) | Es wird verwendet, um zwei Operanden hinzuzufügen. Wenn zum Beispiel a = 10, b = 10 => a+b = 20 |
| - (Subtraktion) | Es wird verwendet, um den zweiten Operanden vom ersten Operanden zu subtrahieren. Ist der erste Operand kleiner als der zweite Operand, ergibt sich ein negativer Wert. Wenn zum Beispiel a = 20, b = 5 => a - b = 15 |
| / (teilen) | Es gibt den Quotienten zurück, nachdem der erste Operand durch den zweiten Operanden dividiert wurde. Wenn zum Beispiel a = 20, b = 10 => a/b = 2,0 |
| * (Multiplikation) | Es wird verwendet, um einen Operanden mit dem anderen zu multiplizieren. Wenn zum Beispiel a = 20, b = 4 => a * b = 80 |
| % (Erinnerung) | Die Erinnerung wird zurückgegeben, nachdem der erste Operand durch den zweiten Operanden dividiert wurde. Wenn beispielsweise a = 20, b = 10 => a%b = 0 |
| ** (Exponent) | Da er die Potenz des ersten Operanden zum zweiten Operanden berechnet, handelt es sich um einen Exponentenoperator. |
| // (Etagenaufteilung) | Es liefert den Mindestwert des Quotienten, der durch Division der beiden Operanden erhalten wird. |
Programmcode:
Jetzt geben wir Codebeispiele für arithmetische Operatoren in Python. Der Code ist unten angegeben:
a = 32 # Initialize the value of a b = 6 # Initialize the value of b print('Addition of two numbers:',a+b) print('Subtraction of two numbers:',a-b) print('Multiplication of two numbers:',a*b) print('Division of two numbers:',a/b) print('Reminder of two numbers:',a%b) print('Exponent of two numbers:',a**b) print('Floor division of two numbers:',a//b)
Ausgabe:
Jetzt kompilieren wir den obigen Code in Python und führen ihn nach erfolgreicher Kompilierung aus. Dann ist die Ausgabe unten angegeben:
Wie man aus einer While-Schleife in Java ausbricht
Addition of two numbers: 38 Subtraction of two numbers: 26 Multiplication of two numbers: 192 Division of two numbers: 5.333333333333333 Reminder of two numbers: 2 Exponent of two numbers: 1073741824 Floor division of two numbers: 5
Vergleichsoperator
Vergleichsoperatoren werden hauptsächlich zu Vergleichszwecken verwendet. Vergleichsoperatoren vergleichen die Werte der beiden Operanden und geben entsprechend einen wahren oder falschen booleschen Wert zurück. Beispiele für Vergleichsoperatoren sind ==, !=, =, >,<. in the below table, we explain works of operators.< p>
| Operator | Beschreibung |
|---|---|
| == | Wenn der Wert zweier Operanden gleich ist, wird die Bedingung wahr. |
| != | Wenn der Wert zweier Operanden nicht gleich ist, wird die Bedingung wahr. |
| <=< td> | Die Bedingung ist erfüllt, wenn der erste Operand kleiner oder gleich dem zweiten Operanden ist. |
| >= | Die Bedingung ist erfüllt, wenn der erste Operand größer oder gleich dem zweiten Operanden ist. |
| > | Wenn der erste Operand größer als der zweite Operand ist, wird die Bedingung wahr. |
| < | Wenn der erste Operand kleiner als der zweite Operand ist, wird die Bedingung wahr. |
Programmcode:
Jetzt geben wir Codebeispiele für Vergleichsoperatoren in Python. Der Code ist unten angegeben:
a = 32 # Initialize the value of a b = 6 # Initialize the value of b print('Two numbers are equal or not:',a==b) print('Two numbers are not equal or not:',a!=b) print('a is less than or equal to b:',a=b) print('a is greater b:',a>b) print('a is less than b:',a <b) < pre> <p> <strong>Output:</strong> </p> <p>Now we compile the above code in Python, and after successful compilation, we run it. Then the output is given below -</p> <pre> Two numbers are equal or not: False Two numbers are not equal or not: True a is less than or equal to b: False a is greater than or equal to b: True a is greater b: True a is less than b: False </pre> <h2>Assignment Operators</h2> <p>Using the assignment operators, the right expression's value is assigned to the left operand. There are some examples of assignment operators like =, +=, -=, *=, %=, **=, //=. In the below table, we explain the works of the operators.</p> <table class="table"> <tr> <th>Operator</th> <th>Description</th> </tr> <tr> <td>=</td> <td>It assigns the value of the right expression to the left operand.</td> </tr> <tr> <td>+= </td> <td>By multiplying the value of the right operand by the value of the left operand, the left operand receives a changed value. For example, if a = 10, b = 20 => a+ = b will be equal to a = a+ b and therefore, a = 30.</td> </tr> <tr> <td>-=</td> <td>It decreases the value of the left operand by the value of the right operand and assigns the modified value back to left operand. For example, if a = 20, b = 10 => a- = b will be equal to a = a- b and therefore, a = 10.</td> </tr> <tr> <td>*=</td> <td>It multiplies the value of the left operand by the value of the right operand and assigns the modified value back to then the left operand. For example, if a = 10, b = 20 => a* = b will be equal to a = a* b and therefore, a = 200.</td> </tr> <tr> <td>%=</td> <td>It divides the value of the left operand by the value of the right operand and assigns the reminder back to the left operand. For example, if a = 20, b = 10 => a % = b will be equal to a = a % b and therefore, a = 0.</td> </tr> <tr> <td>**=</td> <td>a**=b will be equal to a=a**b, for example, if a = 4, b =2, a**=b will assign 4**2 = 16 to a.</td> </tr> <tr> <td>//=</td> <td>A//=b will be equal to a = a// b, for example, if a = 4, b = 3, a//=b will assign 4//3 = 1 to a.</td> </tr> </table> <p> <strong>Program Code:</strong> </p> <p>Now we give code examples of Assignment operators in Python. The code is given below -</p> <pre> a = 32 # Initialize the value of a b = 6 # Initialize the value of b print('a=b:', a==b) print('a+=b:', a+b) print('a-=b:', a-b) print('a*=b:', a*b) print('a%=b:', a%b) print('a**=b:', a**b) print('a//=b:', a//b) </pre> <p> <strong>Output:</strong> </p> <p>Now we compile the above code in Python, and after successful compilation, we run it. Then the output is given below -</p> <pre> a=b: False a+=b: 38 a-=b: 26 a*=b: 192 a%=b: 2 a**=b: 1073741824 a//=b: 5 </pre> <h2>Bitwise Operators</h2> <p>The two operands' values are processed bit by bit by the bitwise operators. The examples of Bitwise operators are bitwise OR (|), bitwise AND (&), bitwise XOR (^), negation (~), Left shift (<>). Consider the case below.</p> <p> <strong>For example,</strong> </p> <pre> if a = 7 b = 6 then, binary (a) = 0111 binary (b) = 0110 hence, a & b = 0011 a | b = 0111 a ^ b = 0100 ~ a = 1000 Let, Binary of x = 0101 Binary of y = 1000 Bitwise OR = 1101 8 4 2 1 1 1 0 1 = 8 + 4 + 1 = 13 Bitwise AND = 0000 0000 = 0 Bitwise XOR = 1101 8 4 2 1 1 1 0 1 = 8 + 4 + 1 = 13 Negation of x = ~x = (-x) - 1 = (-5) - 1 = -6 ~x = -6 </pre> <p>In the below table, we are explaining the works of the bitwise operators.</p> <table class="table"> <tr> <th>Operator</th> <th>Description</th> </tr> <tr> <td>& (binary and)</td> <td>A 1 is copied to the result if both bits in two operands at the same location are 1. If not, 0 is copied.</td> </tr> <tr> <td>| (binary or)</td> <td>The resulting bit will be 0 if both the bits are zero; otherwise, the resulting bit will be 1.</td> </tr> <tr> <td>^ (binary xor)</td> <td>If the two bits are different, the outcome bit will be 1, else it will be 0.</td> </tr> <tr> <td>~ (negation) </td> <td>The operand's bits are calculated as their negations, so if one bit is 0, the next bit will be 1, and vice versa.</td> </tr> <tr> <td><< (left shift)</td> <td>The number of bits in the right operand is multiplied by the leftward shift of the value of the left operand.</td> </tr> <tr> <td>>> (right shift)</td> <td>The left operand is moved right by the number of bits present in the right operand.</td> </tr> </table> <p> <strong>Program Code:</strong> </p> <p>Now we give code examples of Bitwise operators in Python. The code is given below -</p> <pre> a = 5 # initialize the value of a b = 6 # initialize the value of b print('a&b:', a&b) print('a|b:', a|b) print('a^b:', a^b) print('~a:', ~a) print('a< <b:', a<>b:', a>>b) </b:',></pre> <p> <strong>Output:</strong> </p> <p>Now we compile the above code in Python, and after successful compilation, we run it. Then the output is given below -</p> <pre> a&b: 4 a|b: 7 a^b: 3 ~a: -6 a< <b: 320 a>>b: 0 </b:></pre> <h2>Logical Operators</h2> <p>The assessment of expressions to make decisions typically uses logical operators. The examples of logical operators are and, or, and not. In the case of logical AND, if the first one is 0, it does not depend upon the second one. In the case of logical OR, if the first one is 1, it does not depend on the second one. Python supports the following logical operators. In the below table, we explain the works of the logical operators.</p> <table class="table"> <tr> <th>Operator</th> <th>Description</th> </tr> <tr> <td>and</td> <td>The condition will also be true if the expression is true. If the two expressions a and b are the same, then a and b must both be true.</td> </tr> <tr> <td>or</td> <td>The condition will be true if one of the phrases is true. If a and b are the two expressions, then an or b must be true if and is true and b is false.</td> </tr> <tr> <td>not</td> <td>If an expression <strong>a</strong> is true, then not (a) will be false and vice versa.</td> </tr> </table> <p> <strong>Program Code:</strong> </p> <p>Now we give code examples of arithmetic operators in Python. The code is given below -</p> <pre> a = 5 # initialize the value of a print(Is this statement true?:',a > 3 and a 3 or a 3 and a <5))) < pre> <p> <strong>Output:</strong> </p> <p>Now we give code examples of Bitwise operators in Python. The code is given below -</p> <pre> Is this statement true?: False Any one statement is true?: True Each statement is true then return False and vice-versa: True </pre> <h2>Membership Operators</h2> <p>The membership of a value inside a Python data structure can be verified using Python membership operators. The result is true if the value is in the data structure; otherwise, it returns false.</p> <table class="table"> <tr> <th>Operator</th> <th>Description</th> </tr> <tr> <td>in</td> <td>If the first operand cannot be found in the second operand, it is evaluated to be true (list, tuple, or dictionary).</td> </tr> <tr> <td>not in</td> <td>If the first operand is not present in the second operand, the evaluation is true (list, tuple, or dictionary).</td> </tr> </table> <p> <strong>Program Code:</strong> </p> <p>Now we give code examples of Membership operators in Python. The code is given below -</p> <pre> x = ['Rose', 'Lotus'] print(' Is value Present?', 'Rose' in x) print(' Is value not Present?', 'Riya' not in x) </pre> <p> <strong>Output:</strong> </p> <p>Now we compile the above code in Python, and after successful compilation, we run it. Then the output is given below -</p> <pre> Is value Present? True Is value not Present? True </pre> <h2>Identity Operators</h2> <table class="table"> <tr> <th>Operator</th> <th>Description</th> </tr> <tr> <td>is</td> <td>If the references on both sides point to the same object, it is determined to be true.</td> </tr> <tr> <td>is not</td> <td>If the references on both sides do not point at the same object, it is determined to be true.</td> </tr> </table> <p> <strong>Program Code:</strong> </p> <p>Now we give code examples of Identity operators in Python. The code is given below -</p> <pre> a = ['Rose', 'Lotus'] b = ['Rose', 'Lotus'] c = a print(a is c) print(a is not c) print(a is b) print(a is not b) print(a == b) print(a != b) </pre> <p> <strong>Output:</strong> </p> <p>Now we compile the above code in python, and after successful compilation, we run it. Then the output is given below -</p> <pre> True False False True True False </pre> <h2>Operator Precedence</h2> <p>The order in which the operators are examined is crucial to understand since it tells us which operator needs to be considered first. Below is a list of the Python operators' precedence tables.</p> <table class="table"> <tr> <th>Operator</th> <th>Description</th> </tr> <tr> <td>**</td> <td>Overall other operators employed in the expression, the exponent operator is given precedence.</td> </tr> <tr> <td>~ + -</td> <td>the minus, unary plus, and negation. </td> </tr> <tr> <td>* / % //</td> <td>the division of the floor, the modules, the division, and the multiplication.</td> </tr> <tr> <td>+ -</td> <td>Binary plus, and minus</td> </tr> <tr> <td>>> <<</td> <td>Left shift. and right shift</td> </tr> <tr> <td>&</td> <td>Binary and.</td> </tr> <tr> <td>^ |</td> <td>Binary xor, and or</td> </tr> <tr> <td><=>=</=></td> <td>Comparison operators (less than, less than equal to, greater than, greater then equal to).</td> </tr> <tr> <td> == !=</td> <td>Equality operators.</td> </tr> <tr> <td>= %= /= //= -= += <br> *= **=</td> <td>Assignment operators</td> </tr> <tr> <td>is is not</td> <td>Identity operators</td> </tr> <tr> <td>in not in</td> <td>Membership operators</td> </tr> <tr> <td>not or and</td> <td>Logical operators</td> </tr> </table> <h2>Conclusion:</h2> <p>So, in this article, we are discussing all the Python Operators. We briefly discuss how they work and share the program code using each operator in Python.</p> <hr></5)))></pre></b)>
Zuweisungsoperatoren
Mithilfe der Zuweisungsoperatoren wird der Wert des rechten Ausdrucks dem linken Operanden zugewiesen. Es gibt einige Beispiele für Zuweisungsoperatoren wie =, +=, -=, *=, %=, **=, //=. In der folgenden Tabelle erläutern wir die Arbeit der Operatoren.
künstliche neuronale Netz
| Operator | Beschreibung |
|---|---|
| = | Es weist dem linken Operanden den Wert des rechten Ausdrucks zu. |
| += | Durch Multiplikation des Wertes des rechten Operanden mit dem Wert des linken Operanden erhält der linke Operand einen geänderten Wert. Wenn zum Beispiel a = 10, b = 20 => a+ = b ist gleich a = a+ b und daher a = 30. |
| -= | Es verringert den Wert des linken Operanden um den Wert des rechten Operanden und weist den geänderten Wert wieder dem linken Operanden zu. Wenn beispielsweise a = 20, b = 10 => a- = b ist gleich a = a- b und daher a = 10. |
| *= | Es multipliziert den Wert des linken Operanden mit dem Wert des rechten Operanden und weist den geänderten Wert dann dem linken Operanden zurück. Wenn beispielsweise a = 10, b = 20 => a* = b ist gleich a = a* b und daher a = 200. |
| %= | Es dividiert den Wert des linken Operanden durch den Wert des rechten Operanden und weist die Erinnerung wieder dem linken Operanden zu. Wenn zum Beispiel a = 20, b = 10 => a % = b ist gleich a = a % b und daher ist a = 0. |
| **= | a**=b ist gleich a=a**b. Wenn beispielsweise a = 4, b =2 ist, weist a**=b a 4**2 = 16 zu. |
| //= | A//=b ist gleich a = a// b. Wenn beispielsweise a = 4, b = 3 ist, weist a//=b a 4//3 = 1 zu. |
Programmcode:
Jetzt geben wir Codebeispiele für Zuweisungsoperatoren in Python. Der Code ist unten angegeben:
a = 32 # Initialize the value of a b = 6 # Initialize the value of b print('a=b:', a==b) print('a+=b:', a+b) print('a-=b:', a-b) print('a*=b:', a*b) print('a%=b:', a%b) print('a**=b:', a**b) print('a//=b:', a//b)
Ausgabe:
Jetzt kompilieren wir den obigen Code in Python und führen ihn nach erfolgreicher Kompilierung aus. Dann ist die Ausgabe unten angegeben:
a=b: False a+=b: 38 a-=b: 26 a*=b: 192 a%=b: 2 a**=b: 1073741824 a//=b: 5
Bitweise Operatoren
Die Werte der beiden Operanden werden von den bitweisen Operatoren Stück für Stück verarbeitet. Beispiele für bitweise Operatoren sind bitweises ODER (|), bitweises UND (&), bitweises XOR (^), Negation (~), Linksverschiebung (<>). Betrachten Sie den folgenden Fall.
Zum Beispiel,
if a = 7 b = 6 then, binary (a) = 0111 binary (b) = 0110 hence, a & b = 0011 a | b = 0111 a ^ b = 0100 ~ a = 1000 Let, Binary of x = 0101 Binary of y = 1000 Bitwise OR = 1101 8 4 2 1 1 1 0 1 = 8 + 4 + 1 = 13 Bitwise AND = 0000 0000 = 0 Bitwise XOR = 1101 8 4 2 1 1 1 0 1 = 8 + 4 + 1 = 13 Negation of x = ~x = (-x) - 1 = (-5) - 1 = -6 ~x = -6
In der folgenden Tabelle erklären wir die Funktionsweise der bitweisen Operatoren.
| Operator | Beschreibung |
|---|---|
| & (binär und) | Eine 1 wird in das Ergebnis kopiert, wenn beide Bits in zwei Operanden an derselben Stelle 1 sind. Wenn nicht, wird 0 kopiert. |
| | (binär oder) | Das resultierende Bit ist 0, wenn beide Bits Null sind; andernfalls ist das resultierende Bit 1. |
| ^ (binäres xor) | Wenn die beiden Bits unterschiedlich sind, ist das Ergebnisbit 1, andernfalls ist es 0. |
| ~ (Verneinung) | Die Bits des Operanden werden als ihre Negationen berechnet. Wenn also ein Bit 0 ist, ist das nächste Bit 1 und umgekehrt. |
| << (Linksverschiebung) | Die Anzahl der Bits im rechten Operanden wird mit der Linksverschiebung des Werts des linken Operanden multipliziert. |
| >> (Rechtsverschiebung) | Der linke Operand wird um die Anzahl der im rechten Operanden vorhandenen Bits nach rechts verschoben. |
Programmcode:
Apache
Jetzt geben wir Codebeispiele für bitweise Operatoren in Python. Der Code ist unten angegeben:
a = 5 # initialize the value of a b = 6 # initialize the value of b print('a&b:', a&b) print('a|b:', a|b) print('a^b:', a^b) print('~a:', ~a) print('a< <b:\', a<>b:', a>>b) </b:\',>
Ausgabe:
Jetzt kompilieren wir den obigen Code in Python und führen ihn nach erfolgreicher Kompilierung aus. Dann ist die Ausgabe unten angegeben:
a&b: 4 a|b: 7 a^b: 3 ~a: -6 a< <b: 320 a>>b: 0 </b:>
Logische Operatoren
Bei der Bewertung von Ausdrücken zur Entscheidungsfindung werden typischerweise logische Operatoren verwendet. Beispiele für logische Operatoren sind und, oder und nicht. Wenn beim logischen UND das erste 0 ist, hängt es nicht vom zweiten ab. Wenn beim logischen ODER das erste 1 ist, hängt es nicht vom zweiten ab. Python unterstützt die folgenden logischen Operatoren. In der folgenden Tabelle erklären wir die Funktionsweise der logischen Operatoren.
Auswahl sortieren
| Operator | Beschreibung |
|---|---|
| Und | Die Bedingung ist auch wahr, wenn der Ausdruck wahr ist. Wenn die beiden Ausdrücke a und b gleich sind, müssen a und b beide wahr sein. |
| oder | Die Bedingung ist wahr, wenn einer der Sätze wahr ist. Wenn a und b die beiden Ausdrücke sind, dann muss an oder b wahr sein, wenn und wahr ist und b falsch ist. |
| nicht | Wenn ein Ausdruck A wahr ist, dann wird nicht (a) falsch sein und umgekehrt. |
Programmcode:
Jetzt geben wir Codebeispiele für arithmetische Operatoren in Python. Der Code ist unten angegeben:
a = 5 # initialize the value of a print(Is this statement true?:',a > 3 and a 3 or a 3 and a <5))) < pre> <p> <strong>Output:</strong> </p> <p>Now we give code examples of Bitwise operators in Python. The code is given below -</p> <pre> Is this statement true?: False Any one statement is true?: True Each statement is true then return False and vice-versa: True </pre> <h2>Membership Operators</h2> <p>The membership of a value inside a Python data structure can be verified using Python membership operators. The result is true if the value is in the data structure; otherwise, it returns false.</p> <table class="table"> <tr> <th>Operator</th> <th>Description</th> </tr> <tr> <td>in</td> <td>If the first operand cannot be found in the second operand, it is evaluated to be true (list, tuple, or dictionary).</td> </tr> <tr> <td>not in</td> <td>If the first operand is not present in the second operand, the evaluation is true (list, tuple, or dictionary).</td> </tr> </table> <p> <strong>Program Code:</strong> </p> <p>Now we give code examples of Membership operators in Python. The code is given below -</p> <pre> x = ['Rose', 'Lotus'] print(' Is value Present?', 'Rose' in x) print(' Is value not Present?', 'Riya' not in x) </pre> <p> <strong>Output:</strong> </p> <p>Now we compile the above code in Python, and after successful compilation, we run it. Then the output is given below -</p> <pre> Is value Present? True Is value not Present? True </pre> <h2>Identity Operators</h2> <table class="table"> <tr> <th>Operator</th> <th>Description</th> </tr> <tr> <td>is</td> <td>If the references on both sides point to the same object, it is determined to be true.</td> </tr> <tr> <td>is not</td> <td>If the references on both sides do not point at the same object, it is determined to be true.</td> </tr> </table> <p> <strong>Program Code:</strong> </p> <p>Now we give code examples of Identity operators in Python. The code is given below -</p> <pre> a = ['Rose', 'Lotus'] b = ['Rose', 'Lotus'] c = a print(a is c) print(a is not c) print(a is b) print(a is not b) print(a == b) print(a != b) </pre> <p> <strong>Output:</strong> </p> <p>Now we compile the above code in python, and after successful compilation, we run it. Then the output is given below -</p> <pre> True False False True True False </pre> <h2>Operator Precedence</h2> <p>The order in which the operators are examined is crucial to understand since it tells us which operator needs to be considered first. Below is a list of the Python operators' precedence tables.</p> <table class="table"> <tr> <th>Operator</th> <th>Description</th> </tr> <tr> <td>**</td> <td>Overall other operators employed in the expression, the exponent operator is given precedence.</td> </tr> <tr> <td>~ + -</td> <td>the minus, unary plus, and negation. </td> </tr> <tr> <td>* / % //</td> <td>the division of the floor, the modules, the division, and the multiplication.</td> </tr> <tr> <td>+ -</td> <td>Binary plus, and minus</td> </tr> <tr> <td>>> <<</td> <td>Left shift. and right shift</td> </tr> <tr> <td>&</td> <td>Binary and.</td> </tr> <tr> <td>^ |</td> <td>Binary xor, and or</td> </tr> <tr> <td><=>=</=></td> <td>Comparison operators (less than, less than equal to, greater than, greater then equal to).</td> </tr> <tr> <td> == !=</td> <td>Equality operators.</td> </tr> <tr> <td>= %= /= //= -= += <br> *= **=</td> <td>Assignment operators</td> </tr> <tr> <td>is is not</td> <td>Identity operators</td> </tr> <tr> <td>in not in</td> <td>Membership operators</td> </tr> <tr> <td>not or and</td> <td>Logical operators</td> </tr> </table> <h2>Conclusion:</h2> <p>So, in this article, we are discussing all the Python Operators. We briefly discuss how they work and share the program code using each operator in Python.</p> <hr></5)))>
Mitgliedschaftsbetreiber
Die Zugehörigkeit eines Werts innerhalb einer Python-Datenstruktur kann mithilfe von Python-Zugehörigkeitsoperatoren überprüft werden. Das Ergebnis ist wahr, wenn sich der Wert in der Datenstruktur befindet; andernfalls wird false zurückgegeben.
| Operator | Beschreibung |
|---|---|
| In | Wenn der erste Operand im zweiten Operanden nicht gefunden werden kann, wird er als wahr ausgewertet (Liste, Tupel oder Wörterbuch). |
| nicht in | Wenn der erste Operand im zweiten Operanden nicht vorhanden ist, ist die Auswertung wahr (Liste, Tupel oder Wörterbuch). |
Programmcode:
Jetzt geben wir Codebeispiele für Mitgliedschaftsoperatoren in Python. Der Code ist unten angegeben:
x = ['Rose', 'Lotus'] print(' Is value Present?', 'Rose' in x) print(' Is value not Present?', 'Riya' not in x)
Ausgabe:
Jetzt kompilieren wir den obigen Code in Python und führen ihn nach erfolgreicher Kompilierung aus. Dann ist die Ausgabe unten angegeben:
Is value Present? True Is value not Present? True
Identitätsoperatoren
| Operator | Beschreibung |
|---|---|
| Ist | Wenn die Referenzen auf beiden Seiten auf dasselbe Objekt verweisen, wird es als wahr bestimmt. |
| ist nicht | Wenn die Referenzen auf beiden Seiten nicht auf dasselbe Objekt zeigen, wird es als wahr bestimmt. |
Programmcode:
Jetzt geben wir Codebeispiele für Identitätsoperatoren in Python. Der Code ist unten angegeben:
a = ['Rose', 'Lotus'] b = ['Rose', 'Lotus'] c = a print(a is c) print(a is not c) print(a is b) print(a is not b) print(a == b) print(a != b)
Ausgabe:
Jetzt kompilieren wir den obigen Code in Python und führen ihn nach erfolgreicher Kompilierung aus. Dann ist die Ausgabe unten angegeben:
s in Python
True False False True True False
Vorrang des Operators
Es ist wichtig zu verstehen, in welcher Reihenfolge die Operatoren untersucht werden, da sie uns sagt, welcher Operator zuerst berücksichtigt werden muss. Nachfolgend finden Sie eine Liste der Prioritätstabellen der Python-Operatoren.
| Operator | Beschreibung |
|---|---|
| ** | Bei allen anderen im Ausdruck verwendeten Operatoren hat der Exponentenoperator Vorrang. |
| ~ + - | das Minus, das unäre Plus und die Negation. |
| */% // | die Teilung des Bodens, die Module, die Teilung und die Multiplikation. |
| + - | Binäres Plus und Minus |
| >> << | Linksverschiebung. und Rechtsverschiebung |
| & | Binär und. |
| ^ | | Binäres xor und oder |
| <=>= | Vergleichsoperatoren (kleiner als, kleiner gleich, größer als, größer gleich). |
| == != | Gleichheitsoperatoren. |
| = %= /= //= -= += *= **= | Zuweisungsoperatoren |
| ist ist nicht | Identitätsoperatoren |
| in nicht in | Mitgliedschaftsbetreiber |
| nicht oder und | Logische Operatoren |
Abschluss:
In diesem Artikel besprechen wir daher alle Python-Operatoren. Wir diskutieren kurz, wie sie funktionieren, und teilen den Programmcode mit jedem Operator in Python.