Operatori in Python

Questo articolo spiega gli operatori in Python.

YouTube Video

Operatori in Python

Python ha vari operatori, che possono essere ampiamente categorizzati come segue. Spiegheremo gli operatori rappresentativi per ciascuna categoria.

Operatori Aritmetici

Gli operatori aritmetici sono operatori utilizzati per eseguire calcoli sui numeri.

 1a = 10
 2b = 3
 3
 4print(f"{a} + {b} = {a + b}")     # Addition
 5print(f"{a} - {b} = {a - b}")     # Subtraction
 6print(f"{a} * {b} = {a * b}")     # Multiplication
 7print(f"{a} / {b} = {a / b}")     # Division (float)
 8print(f"6 / 3 = {6 / 3}")         # Division (float)
 9print(f"{a} // {b} = {a // b}")   # Floor Division
10print(f"{a} % {b} = {a % b}")     # Modulo (remainder)
11print(f"{a} ** {b} = {a ** b}")   # Exponentiation

• Oltre alle quattro operazioni aritmetiche di base, Python fornisce operatori per la divisione (/), divisione intera (//), modulo (%) ed esponenziazione (**). La divisione restituisce un numero in virgola mobile anche quando si dividono numeri interi.

Operatori di assegnazione

Gli operatori di assegnazione vengono usati per assegnare valori alle variabili.

 1x = 5           # x = 5
 2
 3x += 3          # x = x + 3
 4x -= 2          # x = x - 2
 5x *= 4          # x = x * 4
 6x /= 3          # x = x / 3
 7x //= 2         # x = x // 2
 8x %= 5          # x = x % 5
 9x **= 3         # x = x ** 3
10
11x = 0b1100      # x = 0b1100 (12)
12
13x &= 0b1010     # x = x & 0b1010
14x |= 0b0011     # x = x | 0b0011
15x ^= 0b0101     # x = x ^ 0b0101
16x <<= 2         # x = x << 2
17x >>= 1         # x = x >> 1
18
19print(bin(x))   # Display in binary
20print(x)        # Display in decimal
21
22# Walrus operator
23if (n := len("hello")) > 3:
24    print(f"Length is {n}")

• Gli operatori di assegnazione permettono di combinare l'assegnazione standard con vari operatori per assegnare il risultato.
• L'operatore walrus (:=) è un'espressione di assegnazione disponibile in Python 3.8 e successive.
• Mentre l'assegnazione standard può essere utilizzata solo come istruzione, l'operatore walrus permette l'assegnazione all'interno di un'espressione.

Operatori di Confronto

Gli operatori di confronto confrontano i valori e restituiscono True o False.

 1a = 10
 2b = 20
 3
 4# Equal to (==)
 5print(f"{a} == {b} -> {a == b}")      # False: a and b are not equal
 6print(f"3 == 3.0 -> {3 == 3.0}")      # True: int and float with the same value are equal
 7print(f"3 == '3' -> {3 == '3'}")      # False: different types (int vs str)
 8print(f"True == 1 -> {True == 1}")    # True: True is equivalent to 1
 9print(f"False == 0 -> {False == 0}")  # True: False is equivalent to 0
10print(f"None == 0 -> {None == 0}")    # False: None is not equal to 0
11
12# Not equal to (!=)
13print(f"{a} != {b} -> {a != b}")      # True: a and b are not equal
14
15# Greater than (>)
16print(f"{b} > {a} -> {b > a}")        # True: 20 > 10
17
18# Less than (<)
19print(f"{a} < {b} -> {a < b}")        # True: 10 < 20
20
21# Greater than or equal to (>=)
22print(f"{a} >= 10 -> {a >= 10}")      # True: a is greater than or equal to 10
23
24# Less than or equal to (<=)
25print(f"{a} <= 10 -> {a <= 10}")      # True: a is less than or equal to 10

• Gli operatori di confronto confrontano due valori riguardo all'ordine o all'uguaglianza e restituiscono True o False come risultato.
• In Python, bisogna fare attenzione quando si confrontano tipi di dati diversi. Alcuni tipi possono essere confrontati tra loro, ma i risultati potrebbero non essere intuitivi.

Operatori Logici

Gli operatori logici vengono utilizzati per combinare espressioni logiche.

1x = 10
2print(x > 5 and x < 20)  # True
3print(x < 5 or x > 20)   # False
4print(not x == 10)       # False

• and è un operatore logico che restituisce True solo se entrambe le condizioni, a sinistra e a destra, sono True.
• or è un operatore logico che restituisce True se almeno una delle condizioni, a sinistra o a destra, è True.
• not è un operatore logico che inverte il valore di verità di una condizione. Se è Vero, diventa Falso, e se è Falso, diventa Vero.

Precedenza degli operatori logici

Gli operatori hanno precedenza. Questa è la regola che determina quale operatore viene valutato per primo in un'espressione. Gli operatori logici sono valutati nell'ordine: not, and, poi or.

1result = True or False and False
2print(result)  # True
3
4result = (True or False) and False
5print(result)  # False

たとえば、

Nel primo esempio, and viene valutato per primo, quindi False and False diventa False, e di conseguenza, True or False diventa True. Puoi anche cambiare l'ordine di valutazione usando le parentesi, come mostrato nel secondo esempio.

Operatori bitwise

Gli operatori bit a bit eseguono operazioni a livello di bit.

 1# Sample code for bitwise operators
 2
 3# Define two integers
 4a = 5  # Binary: 0101
 5b = 3  # Binary: 0011
 6
 7# Bitwise AND
 8result_and = a & b  # Binary: 0001 -> Decimal: 1
 9print(f"{a} & {b} = {result_and}")
10
11# Bitwise OR
12result_or = a | b  # Binary: 0111 -> Decimal: 7
13print(f"{a} | {b} = {result_or}")
14
15# Bitwise XOR
16result_xor = a ^ b  # Binary: 0110 -> Decimal: 6
17print(f"{a} ^ {b} = {result_xor}")
18
19# Bitwise NOT (inverting bits)
20result_not = ~a  # Binary: -(0101 + 1) -> Decimal: -6
21print(f"~{a} = {result_not}")
22
23# Left shift
24shift_left = a << 1  # Binary: 1010 -> Decimal: 10
25print(f"{a} << 1 = {shift_left}")
26
27# Right shift
28shift_right = a >> 1  # Binary: 0010 -> Decimal: 2
29print(f"{a} >> 1 = {shift_right}")

• Puoi eseguire operazioni bit a bit AND, OR, XOR, NOT, oltre a operazioni di shift dei bit. Puoi anche combinarli con operatori di assegnazione come &=.

Operatori di appartenenza

Gli operatori di appartenenza vengono utilizzati con collezioni come liste e dizionari.

 1x = [1, 2, 3]
 2y = 2
 3z = 4
 4
 5print("y in x : ", y in x)  # Result is True
 6print("z in x : ", z in x)  # Result is False
 7
 8print("y not in x : ", y not in x)  # Result is False
 9print("z not in x : ", z not in x)  # Result is True
10
11text = "hello world"
12print("'world' in 'hello world' : ",      "world" in text)      # True
13print("'python' not in 'hello world' : ", "python" not in text) # True

• L’operatore in viene utilizzato per determinare se un valore specificato è contenuto in una sequenza come una lista o una stringa, oppure in una collezione come un dizionario.
• L’operatore not in viene utilizzato per determinare se un valore specificato non è contenuto in una sequenza o una collezione.

Operatori di identità

Gli operatori di identità verificano l'identità degli oggetti.

 1x = [1, 2, 3]
 2y = x
 3z = x.copy()
 4
 5print("x is y : ", x is y)  # Result is True
 6print("x is z : ", x is z)  # Result is False
 7
 8print("x is not y : ", x is not y)  # Result is False
 9print("x is not z : ", x is not z)  # Result is True
10
11print("x == y : ", x == y)  # Result is True
12print("x == z : ", x == z)  # Result is True

• L'operatore is verifica se due oggetti sono lo stesso oggetto (cioè fanno riferimento alla stessa posizione di memoria).
• L'operatore is not verifica se due oggetti sono oggetti diversi.
• Ad esempio, x is y si differenzia da x == y perché controlla l'identità dell'oggetto e non l'uguaglianza del valore.

Controllo del tipo

In Python, si usa la funzione isinstance() per verificare se un valore è di un tipo specifico. Puoi anche usare la funzione type() per verificare il tipo esatto di una variabile. Anche se questi non sono operatori, sono meccanismi di base per il controllo del tipo.

 1x = 10
 2print(isinstance(x, int))  # True
 3
 4y = "hello"
 5print(isinstance(y, str))  # True
 6
 7z = [1, 2, 3]
 8print(isinstance(z, list))  # True
 9
10print(type(10))        # <class 'int'>
11print(type("hello"))   # <class 'str'>
12
13print("isinstance(3, int) : ", isinstance(3, int))  # True
14print("type(3) is int : ", type(3) is int)          # True
15print("type(True) is bool : ", type(True) is bool)  # True

• isinstance() è una funzione che verifica se un oggetto è un'istanza di una classe specificata o di una sua sottoclasse.
• type() è una funzione che restituisce il tipo esatto (classe) di un oggetto. Di solito viene usato quando si desidera eseguire un confronto di tipo rigoroso.
• isinstance() considera le relazioni di ereditarietà, mentre type() controlla le corrispondenze esatte.

Riepilogo

Quando usi ogni operatore, devi sceglierlo in modo appropriato in base al suo scopo e al tipo. Poiché Python è un linguaggio a tipizzazione dinamica, il risultato di un'operazione può variare a seconda del tipo di valori calcolati.

Puoi seguire l'articolo sopra utilizzando Visual Studio Code sul nostro canale YouTube. Controlla anche il nostro canale YouTube.

YouTube Video