Introduzione:
In questo articolo parleremo degli operatori Python. L'operatore è un simbolo che esegue un'operazione specifica tra due operandi, secondo una definizione. Gli operatori fungono da base su cui viene costruita la logica in un programma in un particolare linguaggio di programmazione. In ogni linguaggio di programmazione, alcuni operatori svolgono diversi compiti. Come gli altri linguaggi, anche Python ha alcuni operatori, che sono riportati di seguito:
- Operatori aritmetici
- Operatori di confronto
- Operatori di assegnazione
- Operatori logici
- Operatori bit a bit
- Operatori associativi
- Operatori di identità
- Operatori aritmetici
Operatori aritmetici
Operatori aritmetici utilizzati tra due operandi per una particolare operazione. Esistono molti operatori aritmetici. Include l'operatore esponente (**) nonché gli operatori + (addizione), - (sottrazione), * (moltiplicazione), / (divisione), % (promemoria) e // (divisione minima).
Considerare la tabella seguente per una spiegazione dettagliata degli operatori aritmetici.
| Operatore | Descrizione |
|---|---|
| + (Addizione) | Viene utilizzato per sommare due operandi. Ad esempio, se a = 10, b = 10 => a+b = 20 |
| - (Sottrazione) | Viene utilizzato per sottrarre il secondo operando dal primo operando. Se il primo operando è minore del secondo operando il valore risulta negativo. Ad esempio, se a = 20, b = 5 => a - b = 15 |
| / (dividere) | Restituisce il quoziente dopo aver diviso il primo operando per il secondo operando. Ad esempio, se a = 20, b = 10 => a/b = 2,0 |
| * (Moltiplicazione) | Si usa per moltiplicare un operando con l'altro. Ad esempio, se a = 20, b = 4 => a * b = 80 |
| % (promemoria) | Restituisce il promemoria dopo aver diviso il primo operando per il secondo operando. Ad esempio, se a = 20, b = 10 => a%b = 0 |
| ** (Esponente) | Poiché calcola la potenza del primo operando rispetto al secondo operando, è un operatore esponente. |
| // (Divisione del piano) | Fornisce il valore minimo del quoziente, che si ottiene dividendo i due operandi. |
Codice programma:
Ora diamo esempi di codice di operatori aritmetici in Python. Il codice è riportato di seguito:
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)
Produzione:
Ora compiliamo il codice sopra in Python e, dopo averlo compilato con successo, lo eseguiamo. Quindi l'output è riportato di seguito:
oggetto da Java a JSON
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
Operatore di confronto
Gli operatori di confronto vengono utilizzati principalmente a scopo di confronto. Gli operatori di confronto confrontano i valori dei due operandi e restituiscono di conseguenza un valore booleano vero o falso. Gli esempi di operatori di confronto sono ==, !=, =, >,<. in the below table, we explain works of operators.< p>
| Operatore | Descrizione |
|---|---|
| == | Se il valore di due operandi è uguale, la condizione diventa vera. |
| != | Se il valore di due operandi non è uguale, la condizione diventa vera. |
| <=< td> | La condizione è soddisfatta se il primo operando è minore o uguale al secondo operando. |
| >= | La condizione è soddisfatta se il primo operando è maggiore o uguale al secondo operando. |
| > | Se il primo operando è maggiore del secondo operando, la condizione diventa vera. |
| < | Se il primo operando è minore del secondo operando, la condizione diventa vera. |
Codice programma:
programmazione di struct array c
Ora forniamo esempi di codice di operatori di confronto in Python. Il codice è riportato di seguito:
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)>
Operatori di assegnazione
Utilizzando gli operatori di assegnazione, il valore dell'espressione di destra viene assegnato all'operando di sinistra. Esistono alcuni esempi di operatori di assegnazione come =, +=, -=, *=, %=, **=, //=. Nella tabella sottostante spieghiamo il lavoro degli operatori.
| Operatore | Descrizione |
|---|---|
| = | Assegna il valore dell'espressione destra all'operando sinistro. |
| += | Moltiplicando il valore dell'operando di destra per il valore dell'operando di sinistra, l'operando di sinistra riceve un valore modificato. Ad esempio, se a = 10, b = 20 => a+ = b sarà uguale a a = a+ b e quindi a = 30. |
| -= | Diminuisce il valore dell'operando sinistro del valore dell'operando destro e assegna nuovamente il valore modificato all'operando sinistro. Ad esempio, se a = 20, b = 10 => a- = b sarà uguale a a = a- b e quindi a = 10. |
| *= | Moltiplica il valore dell'operando sinistro per il valore dell'operando destro e assegna nuovamente il valore modificato all'operando sinistro. Ad esempio, se a = 10, b = 20 => a* = b sarà uguale a a = a* b e quindi a = 200. |
| %= | Divide il valore dell'operando sinistro per il valore dell'operando destro e assegna nuovamente il promemoria all'operando sinistro. Ad esempio, se a = 20, b = 10 => a % = b sarà uguale a a = a % b e quindi a = 0. |
| **= | a**=b sarà uguale a a=a**b, ad esempio, se a = 4, b =2, a**=b assegnerà 4**2 = 16 ad a. |
| //= | A//=b sarà uguale a a = a// b, ad esempio, se a = 4, b = 3, a//=b assegnerà 4//3 = 1 ad a. |
Codice programma:
Ora forniamo esempi di codice di operatori di assegnazione in Python. Il codice è riportato di seguito:
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)
Produzione:
Ora compiliamo il codice sopra in Python e, dopo averlo compilato con successo, lo eseguiamo. Quindi l'output è riportato di seguito:
a=b: False a+=b: 38 a-=b: 26 a*=b: 192 a%=b: 2 a**=b: 1073741824 a//=b: 5
Operatori bit a bit
I valori dei due operandi vengono elaborati bit a bit dagli operatori bit a bit. Gli esempi di operatori bit per bit sono OR bit per bit (|), AND bit per bit (&), XOR bit per bit (^), negazione (~), spostamento a sinistra (<>). Considera il caso seguente.
Per esempio,
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
Nella tabella seguente spieghiamo il funzionamento degli operatori bit a bit.
| Operatore | Descrizione |
|---|---|
| & (binario e) | Un 1 viene copiato nel risultato se entrambi i bit in due operandi nella stessa posizione sono 1. In caso contrario, viene copiato 0. |
| | (binario o) | Il bit risultante sarà 0 se entrambi i bit sono zero; in caso contrario, il bit risultante sarà 1. |
| ^ (xor binario) | Se i due bit sono diversi, il bit di risultato sarà 1, altrimenti sarà 0. |
| ~ (negazione) | I bit dell'operando vengono calcolati come le loro negazioni, quindi se un bit è 0, il bit successivo sarà 1 e viceversa. |
| << (shift a sinistra) | Il numero di bit nell'operando di destra viene moltiplicato per lo spostamento verso sinistra del valore dell'operando di sinistra. |
| >> (shift a destra) | L'operando di sinistra viene spostato a destra del numero di bit presenti nell'operando di destra. |
Codice programma:
moltiplicazione di matrici in c
Ora diamo esempi di codice di operatori bit a bit in Python. Il codice è riportato di seguito:
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:\',>
Produzione:
Ora compiliamo il codice sopra in Python e, dopo averlo compilato con successo, lo eseguiamo. Quindi l'output è riportato di seguito:
a&b: 4 a|b: 7 a^b: 3 ~a: -6 a< <b: 320 a>>b: 0 </b:>
Operatori logici
La valutazione delle espressioni per prendere decisioni utilizza in genere operatori logici. Gli esempi di operatori logici sono and, or e not. Nel caso dell'AND logico, se il primo è 0, non dipende dal secondo. Nel caso dell'OR logico, se il primo è 1, non dipende dal secondo. Python supporta i seguenti operatori logici. Nella tabella seguente spieghiamo il funzionamento degli operatori logici.
| Operatore | Descrizione |
|---|---|
| E | La condizione sarà vera anche se l'espressione è vera. Se le due espressioni a e b sono uguali, allora a e b devono essere entrambe vere. |
| O | La condizione sarà vera se una delle frasi è vera. Se aeb sono le due espressioni, allora anob deve essere vero se ed è vero e b è falso. |
| non | Se un'espressione UN è vero, allora non (a) sarà falso e viceversa. |
Codice programma:
Ora diamo esempi di codice di operatori aritmetici in Python. Il codice è riportato di seguito:
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)))>
Operatori associativi
L'appartenenza di un valore all'interno di una struttura dati Python può essere verificata utilizzando gli operatori di appartenenza Python. Il risultato è vero se il valore è nella struttura dati; in caso contrario, restituisce false.
carattere per stringa Java
| Operatore | Descrizione |
|---|---|
| In | Se il primo operando non può essere trovato nel secondo operando, viene valutato come vero (lista, tupla o dizionario). |
| Non in | Se il primo operando non è presente nel secondo operando, la valutazione è vera (lista, tupla o dizionario). |
Codice programma:
Ora forniamo esempi di codice di operatori di appartenenza in Python. Il codice è riportato di seguito:
x = ['Rose', 'Lotus'] print(' Is value Present?', 'Rose' in x) print(' Is value not Present?', 'Riya' not in x)
Produzione:
Ora compiliamo il codice sopra in Python e, dopo averlo compilato con successo, lo eseguiamo. Quindi l'output è riportato di seguito:
stringa e sottostringa
Is value Present? True Is value not Present? True
Operatori di identità
| Operatore | Descrizione |
|---|---|
| È | Se i riferimenti su entrambi i lati puntano allo stesso oggetto, si determina che sia vero. |
| non è | Se i riferimenti su entrambi i lati non puntano allo stesso oggetto, viene considerato vero. |
Codice programma:
Ora diamo esempi di codice di operatori di identità in Python. Il codice è riportato di seguito:
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)
Produzione:
Ora compiliamo il codice sopra in Python e, dopo averlo compilato con successo, lo eseguiamo. Quindi l'output è riportato di seguito:
True False False True True False
Precedenza dell'operatore
L'ordine in cui vengono esaminati gli operatori è fondamentale da comprendere poiché ci dice quale operatore deve essere considerato per primo. Di seguito è riportato un elenco delle tabelle di precedenza degli operatori Python.
| Operatore | Descrizione |
|---|---|
| ** | Nel complesso degli altri operatori utilizzati nell'espressione, all'operatore esponente viene data la precedenza. |
| ~+- | il meno, il più unario e la negazione. |
| */% // | la divisione del piano, i moduli, la divisione e la moltiplicazione. |
| + - | Più e meno binario |
| >> << | Tasto maiuscolo di sinistra. e spostamento a destra |
| & | Binario e. |
| ^| | Xor binario e o |
| <=>= | Operatori di confronto (minore di, minore di uguale a, maggiore di, maggiore di uguale a). |
| ==!= | Operatori di uguaglianza. |
| = %= /= //= -= += *= **= | Operatori di assegnazione |
| È non è | Operatori di identità |
| dentro non dentro | Operatori associativi |
| non o e | Operatori logici |
Conclusione:
Quindi, in questo articolo, discuteremo di tutti gli operatori Python. Discutiamo brevemente come funzionano e condividiamo il codice del programma utilizzando ciascun operatore in Python.