Invoering:
In dit artikel bespreken we Python-operators. De operator is een symbool dat volgens één definitie een specifieke bewerking tussen twee operanden uitvoert. Operators dienen als basis waarop logica wordt opgebouwd in een programma in een bepaalde programmeertaal. In elke programmeertaal voeren sommige operators verschillende taken uit. Net als andere talen heeft Python ook enkele operatoren, en deze worden hieronder gegeven:
- Rekenkundige operatoren
- Vergelijkingsoperatoren
- Toewijzingsoperatoren
- Logische operatoren
- Bitwise-operatoren
- Lidmaatschapsexploitanten
- Identiteitsoperatoren
- Rekenkundige operatoren
Rekenkundige operatoren
Rekenkundige operatoren die tussen twee operanden worden gebruikt voor een bepaalde bewerking. Er zijn veel rekenkundige operatoren. Het omvat de operator exponent (**), evenals de operatoren + (optellen), - (aftrekken), * (vermenigvuldigen), / (delen), % (herinnering) en // (vloerdelen).
Bekijk de volgende tabel voor een gedetailleerde uitleg van rekenkundige operatoren.
| Exploitant | Beschrijving |
|---|---|
| + (Toevoeging) | Het wordt gebruikt om twee operanden toe te voegen. Als bijvoorbeeld a = 10, b = 10 => a+b = 20 |
| - (Aftrekken) | Het wordt gebruikt om de tweede operand van de eerste operand af te trekken. Als de eerste operand kleiner is dan de tweede operand, is de waarde negatief. Als bijvoorbeeld a = 20, b = 5 => a - b = 15 |
| / (verdeling) | Het retourneert het quotiënt na het delen van de eerste operand door de tweede operand. Als bijvoorbeeld a = 20, b = 10 => a/b = 2,0 |
| * (Vermenigvuldiging) | Het wordt gebruikt om de ene operand met de andere te vermenigvuldigen. Als bijvoorbeeld a = 20, b = 4 => a * b = 80 |
| % (herinnering) | Het retourneert de herinnering nadat de eerste operand is gedeeld door de tweede operand. Als bijvoorbeeld a = 20, b = 10 => a%b = 0 |
| ** (Exponent) | Omdat het de macht van de eerste operand ten opzichte van de tweede operand berekent, is het een exponentoperator. |
| // (Vloerindeling) | Het geeft de bodemwaarde van het quotiënt weer, die wordt verkregen door de twee operanden te delen. |
Programmacode:
Nu geven we codevoorbeelden van rekenkundige operatoren in Python. De code wordt hieronder gegeven -
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)
Uitgang:
Nu compileren we de bovenstaande code in Python en na een succesvolle compilatie voeren we deze uit. Vervolgens wordt de uitvoer hieronder gegeven -
Google-account uitloggen op Android
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
Vergelijkingsoperator
Vergelijkingsoperatoren gebruiken voornamelijk voor vergelijkingsdoeleinden. Vergelijkingsoperatoren vergelijken de waarden van de twee operanden en retourneren overeenkomstig een True of False Booleaanse waarde. Het voorbeeld van vergelijkingsoperatoren is ==, !=, =, >,<. in the below table, we explain works of operators.< p>
| Exploitant | Beschrijving |
|---|---|
| == | Als de waarde van twee operanden gelijk is, wordt de voorwaarde waar. |
| != | Als de waarde van twee operanden niet gelijk is, wordt de voorwaarde waar. |
| <=< td> | Aan de voorwaarde wordt voldaan als de eerste operand kleiner is dan of gelijk is aan de tweede operand. |
| >= | Aan de voorwaarde wordt voldaan als de eerste operand groter is dan of gelijk is aan de tweede operand. |
| > | Als de eerste operand groter is dan de tweede operand, wordt de voorwaarde waar. |
| < | Als de eerste operand kleiner is dan de tweede operand, wordt de voorwaarde waar. |
Programmacode:
Nu geven we codevoorbeelden van vergelijkingsoperatoren in Python. De code wordt hieronder gegeven -
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)>
Toewijzingsoperatoren
Met behulp van de toewijzingsoperatoren wordt de waarde van de rechterexpressie toegewezen aan de linkeroperand. Er zijn enkele voorbeelden van toewijzingsoperatoren zoals =, +=, -=, *=, %=, **=, //=. In onderstaande tabel leggen wij de werkzaamheden van de operators uit.
| Exploitant | Beschrijving |
|---|---|
| = | Het wijst de waarde van de rechter expressie toe aan de linker operand. |
| += | Door de waarde van de rechter operand te vermenigvuldigen met de waarde van de linker operand, krijgt de linker operand een gewijzigde waarde. Als a = 10 bijvoorbeeld, zal b = 20 => a+ = b gelijk zijn aan a = a+ b en daarom is a = 30. |
| -= | Het verlaagt de waarde van de linker operand met de waarde van de rechter operand en wijst de gewijzigde waarde terug aan de linker operand. Als a = 20 bijvoorbeeld, zal b = 10 => a- = b gelijk zijn aan a = a- b en daarom a = 10. |
| *= | Het vermenigvuldigt de waarde van de linker operand met de waarde van de rechter operand en wijst de gewijzigde waarde terug aan de linker operand. Als a = 10 bijvoorbeeld, zal b = 20 => a* = b gelijk zijn aan a = a* b en daarom is a = 200. |
| %= | Het deelt de waarde van de linker operand door de waarde van de rechter operand en wijst de herinnering terug toe aan de linker operand. Als a = 20 bijvoorbeeld, zal b = 10 => a % = b gelijk zijn aan a = a % b en daarom is a = 0. |
| **= | a**=b zal gelijk zijn aan a=a**b, bijvoorbeeld: als a = 4, b =2, zal a**=b 4**2 = 16 toewijzen aan a. |
| //= | A//=b zal gelijk zijn aan a = a// b. Als a = 4, b = 3, zal a//=b bijvoorbeeld 4//3 = 1 toewijzen aan a. |
Programmacode:
Nu geven we codevoorbeelden van toewijzingsoperatoren in Python. De code wordt hieronder gegeven -
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)
Uitgang:
converteer tekenreeks naar jsonobject Java
Nu compileren we de bovenstaande code in Python en na een succesvolle compilatie voeren we deze uit. Vervolgens wordt de uitvoer hieronder gegeven -
a=b: False a+=b: 38 a-=b: 26 a*=b: 192 a%=b: 2 a**=b: 1073741824 a//=b: 5
Bitwise-operatoren
De waarden van de twee operanden worden beetje bij beetje verwerkt door de bitsgewijze operatoren. De voorbeelden van Bitwise-operatoren zijn bitwise OR (|), bitwise AND (&), bitwise XOR (^), negatie (~), Left shift (<>). Beschouw het onderstaande geval eens.
Bijvoorbeeld,
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 de onderstaande tabel leggen we de werking van de bitwise-operatoren uit.
| Exploitant | Beschrijving |
|---|---|
| & (binair en) | Een 1 wordt naar het resultaat gekopieerd als beide bits in twee operanden op dezelfde locatie 1 zijn. Als dit niet het geval is, wordt 0 gekopieerd. |
| | (binair of) | Het resulterende bit zal 0 zijn als beide bits nul zijn; anders is de resulterende bit 1. |
| ^ (binaire xor) | Als de twee bits verschillend zijn, is de uitkomstbit 1, anders is deze 0. |
| ~ (ontkenning) | De bits van de operand worden berekend als hun negaties, dus als één bit 0 is, zal de volgende bit 1 zijn, en omgekeerd. |
| << (links verschuiven) | Het aantal bits in de rechter operand wordt vermenigvuldigd met de verschuiving naar links van de waarde van de linker operand. |
| >> (verschuiving naar rechts) | De linker operand wordt naar rechts verplaatst met het aantal bits dat in de rechter operand aanwezig is. |
Programmacode:
voorbeelden van dfa-automaten
Nu geven we codevoorbeelden van Bitwise-operatoren in Python. De code wordt hieronder gegeven -
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:\',>
Uitgang:
Nu compileren we de bovenstaande code in Python en na een succesvolle compilatie voeren we deze uit. Vervolgens wordt de uitvoer hieronder gegeven -
a&b: 4 a|b: 7 a^b: 3 ~a: -6 a< <b: 320 a>>b: 0 </b:>
Logische operatoren
Bij de beoordeling van uitdrukkingen om beslissingen te nemen, worden doorgaans logische operatoren gebruikt. De voorbeelden van logische operatoren zijn en, of, en niet. In het geval van logische AND, als de eerste 0 is, is deze niet afhankelijk van de tweede. In het geval van logische OR, als de eerste 1 is, is deze niet afhankelijk van de tweede. Python ondersteunt de volgende logische operatoren. In de onderstaande tabel leggen we de werking van de logische operatoren uit.
| Exploitant | Beschrijving |
|---|---|
| En | De voorwaarde is ook waar als de uitdrukking waar is. Als de twee uitdrukkingen a en b hetzelfde zijn, dan moeten a en b beide waar zijn. |
| of | De voorwaarde is waar als een van de zinsdelen waar is. Als a en b de twee uitdrukkingen zijn, dan moet an of b waar zijn als en waar is en b onwaar is. |
| niet | Als een uitdrukking A waar is, dan zal niet (a) onwaar zijn en omgekeerd. |
Programmacode:
Nu geven we codevoorbeelden van rekenkundige operatoren in Python. De code wordt hieronder gegeven -
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)))>
Lidmaatschapsexploitanten
Het lidmaatschap van een waarde binnen een Python-gegevensstructuur kan worden geverifieerd met behulp van Python-lidmaatschapsoperatoren. Het resultaat is waar als de waarde zich in de datastructuur bevindt; anders retourneert het false.
| Exploitant | Beschrijving |
|---|---|
| in | Als de eerste operand niet kan worden gevonden in de tweede operand, wordt deze geëvalueerd als waar (lijst, tupel of woordenboek). |
| niet in | Als de eerste operand niet aanwezig is in de tweede operand, is de evaluatie waar (lijst, tupel of woordenboek). |
Programmacode:
Nu geven we codevoorbeelden van lidmaatschapsoperatoren in Python. De code wordt hieronder gegeven -
x = ['Rose', 'Lotus'] print(' Is value Present?', 'Rose' in x) print(' Is value not Present?', 'Riya' not in x)
Uitgang:
schakelkast java
Nu compileren we de bovenstaande code in Python en na een succesvolle compilatie voeren we deze uit. Vervolgens wordt de uitvoer hieronder gegeven -
Is value Present? True Is value not Present? True
Identiteitsoperatoren
| Exploitant | Beschrijving |
|---|---|
| is | Als de verwijzingen aan beide kanten naar hetzelfde object verwijzen, wordt vastgesteld dat dit waar is. |
| is niet | Als de verwijzingen aan beide kanten niet naar hetzelfde object wijzen, wordt vastgesteld dat het waar is. |
Programmacode:
Nu geven we codevoorbeelden van identiteitsoperatoren in Python. De code wordt hieronder gegeven -
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)
Uitgang:
Romeinse cijfers 1 100
Nu compileren we de bovenstaande code in Python en na een succesvolle compilatie voeren we deze uit. Vervolgens wordt de uitvoer hieronder gegeven -
True False False True True False
Voorrang van operator
De volgorde waarin de operators worden onderzocht is van cruciaal belang om te begrijpen, omdat deze ons vertelt welke operator als eerste moet worden overwogen. Hieronder vindt u een lijst met de prioriteitstabellen van de Python-operatoren.
| Exploitant | Beschrijving |
|---|---|
| ** | Over het algemeen krijgt de exponentoperator voorrang bij andere operatoren die in de uitdrukking worden gebruikt. |
| ~ + - | de min, unaire plus en negatie. |
| */% // | de verdeling van de vloer, de modules, de verdeling en de vermenigvuldiging. |
| + - | Binair plus en min |
| >> << | Linker shift. en rechts verschuiven |
| & | Binair en. |
| ^ | | Binaire xor, en of |
| <=>= | Vergelijkingsoperatoren (kleiner dan, kleiner dan gelijk aan, groter dan, groter dan gelijk aan). |
| == != | Gelijkheidsoperatoren. |
| = %= /= //= -= += *= **= | Toewijzingsoperatoren |
| het is niet | Identiteitsoperatoren |
| binnen niet binnen | Lidmaatschapsexploitanten |
| niet of en | Logische operatoren |
Conclusie:
In dit artikel bespreken we dus alle Python-operators. We bespreken kort hoe ze werken en delen de programmacode met behulp van elke operator in Python.