Bevezetés:
Ebben a cikkben a Python-operátorokról beszélünk. Az operátor egy szimbólum, amely egy meghatározott műveletet hajt végre két operandus között, egy definíció szerint. Az operátorok szolgálják az alapot, amelyre a logika egy adott programozási nyelvű programban felépül. Minden programozási nyelvben egyes operátorok több feladatot is végrehajtanak. A többi nyelvhez hasonlóan a Pythonnak is van néhány operátora, amelyeket alább adunk meg -
- Aritmetikai operátorok
- Összehasonlító operátorok
- Hozzárendelési operátorok
- Logikai operátorok
- Bitenkénti operátorok
- Tagsági operátorok
- Identitás operátorok
- Aritmetikai operátorok
Aritmetikai operátorok
Egy adott művelethez két operandus között használt aritmetikai operátorok. Számos aritmetikai operátor létezik. Tartalmazza a kitevő (**) operátort, valamint a + (összeadás), - (kivonás), * (szorzás), / (osztás), % (emlékeztető) és // (szintosztás) operátort.
Tekintse meg az alábbi táblázatot az aritmetikai operátorok részletes magyarázatához.
| Operátor | Leírás |
|---|---|
| + (kiegészítés) | Két operandus hozzáadására szolgál. Például, ha a = 10, b = 10 => a+b = 20 |
| - (Kivonás) | Arra használják, hogy kivonják a második operandust az első operandusból. Ha az első operandus kisebb, mint a második operandus, az érték negatív lesz. Például, ha a = 20, b = 5 => a - b = 15 |
| / (feloszt) | Az első operandust a második operandusszal osztva adja vissza a hányadost. Például, ha a = 20, b = 10 => a/b = 2,0 |
| * (Szorzás) | Az egyik operandus a másikkal való szorzására szolgál. Például, ha a = 20, b = 4 => a * b = 80 |
| % (emlékeztető) | Visszaadja az emlékeztetőt, miután az első operandust elosztja a második operandusszal. Például, ha a = 20, b = 10 => a%b = 0 |
| ** (Kitevő) | Mivel az első operandus hatványát számítja ki a második operandushoz, ez egy kitevő operátor. |
| // (emelet felosztás) | Megadja a hányados alsó értékét, amelyet a két operandus elosztásával kapunk. |
Program kód:
Most példákat adunk a Python aritmetikai operátoraira. A kód alább található -
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)
Kimenet:
Most Pythonban lefordítjuk a fenti kódot, majd a sikeres fordítás után lefuttatjuk. Ezután a kimenet az alábbiakban látható -
java visszatérési tömb
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
Összehasonlító operátor
Az összehasonlító operátorok elsősorban összehasonlítási célokat szolgálnak. Az összehasonlító operátorok összehasonlítják a két operandus értékét, és ennek megfelelően igaz vagy hamis logikai értéket adnak vissza. Az összehasonlító operátorok példái: ==, !=, =, >,<. in the below table, we explain works of operators.< p>
| Operátor | Leírás |
|---|---|
| == | Ha két operandus értéke egyenlő, akkor a feltétel igaz lesz. |
| != | Ha két operandus értéke nem egyenlő, akkor a feltétel igaz lesz. |
| <=< td> | A feltétel teljesül, ha az első operandus kisebb vagy egyenlő, mint a második operandus. |
| >= | A feltétel teljesül, ha az első operandus nagyobb vagy egyenlő, mint a második operandus. |
| > | Ha az első operandus nagyobb, mint a második operandus, akkor a feltétel igaz lesz. |
| < | Ha az első operandus kisebb, mint a második operandus, akkor a feltétel igaz lesz. |
Program kód:
Most példákat adunk a Python összehasonlító operátoraira. A kód alább található -
cout
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)>
Hozzárendelés operátorok
A hozzárendelési operátorok segítségével a jobb oldali kifejezés értéke a bal oldali operandushoz van rendelve. Van néhány példa hozzárendelési operátorokra, például =, +=, -=, *=, %=, **=, //=. Az alábbi táblázatban bemutatjuk az operátorok munkáját.
| Operátor | Leírás |
|---|---|
| = | A jobb oldali kifejezés értékét a bal oldali operandushoz rendeli. |
| += | A jobb oldali operandus értékét a bal oldali operandus értékével megszorozva a bal oldali operandus megváltozott értéket kap. Például, ha a = 10, b = 20 => a+ = b egyenlő lesz a = a+ b-vel, és ezért a = 30. |
| -= | A bal oldali operandus értékét a jobb oldali operandus értékével csökkenti, és a módosított értéket visszarendeli a bal operandushoz. Például, ha a = 20, akkor b = 10 => a- = b egyenlő lesz a = a-b-vel, és ezért a = 10. |
| *= | A bal oldali operandus értékét megszorozza a jobb oldali operandus értékével, és a módosított értéket visszaadja a bal oldali operandusnak. Például, ha a = 10, b = 20 => a* = b egyenlő lesz a = a* b-vel, és ezért a = 200. |
| %= | A bal oldali operandus értékét elosztja a jobb oldali operandus értékével, és visszarendeli az emlékeztetőt a bal oldali operandushoz. Például, ha a = 20, b = 10 => a % = b egyenlő lesz a = a % b-vel, ezért a = 0. |
| **= | a**=b egyenlő lesz a=a**b-vel, például ha a = 4, b =2, akkor a**=b 4**2 = 16-ot rendel a-hoz. |
| //= | A//=b egyenlő lesz a = a// b-vel, például ha a = 4, b = 3, akkor a//=b 4//3 = 1-et rendel a-hoz. |
Program kód:
Most példákat adunk a Python hozzárendelési operátoraira. A kód alább található -
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)
Kimenet:
Most Pythonban lefordítjuk a fenti kódot, majd a sikeres fordítás után lefuttatjuk. Ezután a kimenet az alábbiakban látható -
a=b: False a+=b: 38 a-=b: 26 a*=b: 192 a%=b: 2 a**=b: 1073741824 a//=b: 5
Bitenkénti operátorok
A két operandus értékét a bitenkénti operátorok bitenként dolgozzák fel. A bitenkénti operátorok példái a bitenkénti VAGY (|), bitenkénti ÉS (&), bitenkénti XOR (^), negáció (~), balra eltolás (<>). Tekintsük az alábbi esetet.
Például,
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
Az alábbi táblázatban a bitenkénti operátorok működését mutatjuk be.
| Operátor | Leírás |
|---|---|
| & (bináris és) | Egy 1-et másol a rendszer az eredményre, ha két, ugyanazon a helyen lévő operandus mindkét bitje 1. Ha nem, akkor 0-t másol. |
| | (bináris vagy) | Az eredményül kapott bit 0 lesz, ha mindkét bit nulla; ellenkező esetben a kapott bit 1 lesz. |
| ^ (bináris xor) | Ha a két bit különbözik, az eredménybit 1 lesz, különben 0. |
| ~ (tagadás) | Az operandus bitjeit a negációjukként számítja ki, tehát ha az egyik bit 0, a következő bit 1 lesz, és fordítva. |
| << (bal műszak) | A jobb oldali operandus bitjeinek számát megszorozzuk a bal oldali operandus értékének balra tolásával. |
| >> (jobb váltás) | A bal oldali operandus jobbra kerül a jobb oldali operandusban jelenlévő bitek számával. |
Program kód:
xvideoservicethief ubuntu 14.04 letöltés
Most példákat adunk a Bitwise operátorokra a Pythonban. A kód alább található -
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:\',>
Kimenet:
Most Pythonban lefordítjuk a fenti kódot, majd a sikeres fordítás után lefuttatjuk. Ezután a kimenet az alábbiakban látható -
a&b: 4 a|b: 7 a^b: 3 ~a: -6 a< <b: 320 a>>b: 0 </b:>
Logikai operátorok
A kifejezések értékelése a döntések meghozatalához általában logikai operátorokat használ. A logikai operátorok példái az és, vagy, és nem. A logikai ÉS esetén, ha az első 0, az nem függ a másodiktól. Logikai VAGY esetén, ha az első 1, az nem függ a másodiktól. A Python a következő logikai operátorokat támogatja. Az alábbi táblázatban bemutatjuk a logikai operátorok működését.
| Operátor | Leírás |
|---|---|
| és | A feltétel akkor is igaz, ha a kifejezés igaz. Ha a két a és b kifejezés megegyezik, akkor a-nak és b-nek igaznak kell lennie. |
| vagy | A feltétel akkor lesz igaz, ha valamelyik kifejezés igaz. Ha a és b a két kifejezés, akkor a-nak vagy b-nek igaznak kell lennie, ha és igaz, b pedig hamis. |
| nem | Ha egy kifejezés a igaz, akkor nem (a) lesz hamis, és fordítva. |
Program kód:
Most példákat adunk a Python aritmetikai operátoraira. A kód alább található -
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)))>
Tagsági operátorok
Egy érték Python-adatstruktúrán belüli tagsága Python-tagsági operátorok segítségével ellenőrizhető. Az eredmény igaz, ha az érték az adatstruktúrában van; ellenkező esetben hamis értéket ad vissza.
| Operátor | Leírás |
|---|---|
| ban ben | Ha az első operandus nem található a második operandusban, akkor a rendszer igaznak értékeli (lista, sor vagy szótár). |
| nem bent | Ha az első operandus nem szerepel a második operandusban, a kiértékelés igaz (lista, sor vagy szótár). |
Program kód:
Most példákat adunk a Python tagsági operátoraira. A kód alább található -
java szünet
x = ['Rose', 'Lotus'] print(' Is value Present?', 'Rose' in x) print(' Is value not Present?', 'Riya' not in x)
Kimenet:
Most Pythonban lefordítjuk a fenti kódot, majd a sikeres fordítás után lefuttatjuk. Ezután a kimenet az alábbiakban látható -
Is value Present? True Is value not Present? True
Identitás operátorok
| Operátor | Leírás |
|---|---|
| van | Ha a hivatkozások mindkét oldalon ugyanarra az objektumra mutatnak, akkor az igaz. |
| nem | Ha a hivatkozások mindkét oldalon nem ugyanarra az objektumra mutatnak, akkor az igaz. |
Program kód:
Most példákat adunk a Python Identity operátoraira. A kód alább található -
hasonló karakterlánc
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)
Kimenet:
Most pythonban fordítjuk le a fenti kódot, majd a sikeres fordítás után lefuttatjuk. Ezután a kimenet az alábbiakban látható -
True False False True True False
Üzemeltetői elsőbbség
Az operátorok vizsgálatának sorrendje kulcsfontosságú a megértéshez, mivel ez megmondja, melyik operátort kell először figyelembe venni. Az alábbiakban a Python operátorok precedenciatáblázatainak listája található.
| Operátor | Leírás |
|---|---|
| ** | A kifejezésben használt többi operátort összességében a kitevő operátor élvez elsőbbséget. |
| ~ + - | a mínusz, az unáris plusz és a tagadás. |
| */% // | az emelet felosztása, a modulok, az osztás és a szorzás. |
| + - | Bináris plusz és mínusz |
| >> << | Bal Shift. és jobbra váltó |
| & | Bináris és. |
| ^ | | Bináris xor, és vagy |
| <=>= | Összehasonlító operátorok (kisebb, mint egyenlő, nagyobb, nagyobb, mint egyenlő). |
| == != | Az egyenlőség szereplői. |
| = %= /= //= -= += *= **= | Hozzárendelési operátorok |
| az nem az | Identitás operátorok |
| nem benne | Tagsági szolgáltatók |
| nem vagy és | Logikai operátorok |
Következtetés:
Tehát ebben a cikkben az összes Python-operátort tárgyaljuk. Röviden megbeszéljük, hogyan működnek, és megosztjuk a programkódot a Python egyes operátoraival.