Operatori di appartenenza e controllo dei tipi

1. Introduzione agli operatori di appartenenza

Gli operatori in e not in permettono di verificare se un elemento è presente in una sequenza o in una struttura dati.

Verificare un carattere in una stringa

text = "Python"
print("y" in text)

Verificare una parola in una lista

shopping_list = ["milk", "bread", "eggs"]
print("milk" in shopping_list)

Verificare che un elemento non sia in una lista

blacklist = ["blocked_user", "spam"]
username = "anna"
print(username not in blacklist)

Membership su tuple

categories = ("Dairy", "Bakery", "Produce")
print("Bakery" in categories)

Membership su dizionario: chiavi

L'operatore in su un dizionario controlla le chiavi.

inventory = {"milk": 10, "eggs": 30}
print("milk" in inventory)

Membership su dizionario: valori

Per controllare i valori si può usare dict.values().

print(10 in inventory.values())

2. Confronto di tipo con type()

Usare type() per verificare se una variabile è di tipo int. Il confronto con type(x) == float è possibile, ma meno consigliato nel promemoria.

x = 10
print(type(x) == int)

type() non considera le sottoclassi: per esempio, bool è una sottoclasse di int, ma type(True) == int restituisce False.

print(type(True) == int)

3. Confronto di tipo con isinstance()

isinstance(x, int) è il metodo preferibile per verificare il tipo, anche considerando le sottoclassi. È possibile controllare più tipi contemporaneamente.

x = 3.5
print(isinstance(x, (int, float)))

Il controllo può essere usato anche con oggetti di classi personalizzate, comprese relazioni tra classe base e classe derivata.

4. Combinare membership e controllo del tipo

Verificare che un elemento sia presente in una lista e sia di tipo int.

values = [10, "20", 30]
candidate = 10
if candidate in values and isinstance(candidate, int):
    print("Valid integer found.")

Verificare che una variabile sia una stringa e contenga un carattere specifico.

username = "anna_7"
if isinstance(username, str) and "_" in username:
    print("Username contains an underscore.")

5. not in e controllo del tipo

Verificare che un elemento non appartenga a una lista e che sia del tipo corretto prima di aggiungerlo.

contacts = ["Anna", "Luca"]
candidate = "Marta"
if isinstance(candidate, str) and candidate not in contacts:
    contacts.append(candidate)

6. Membership in strutture complesse

Liste di tuple

products = [("milk", 2.99), ("bread", 1.50)]
print(("milk", 2.99) in products)

Liste di dizionari

L'operatore in su una lista di dizionari cerca un elemento che corrisponda a uno dei dizionari, non una chiave contenuta in uno di essi.

products = [{"id": 1, "name": "milk"}, {"id": 2, "name": "bread"}]
print({"id": 1, "name": "milk"} in products)

Per verificare se un valore di id è presente nei record, si può usare any().

product_id = 2
print(any(product["id"] == product_id for product in products))

7. Controlli utili nella pratica

Verificare che l'input sia una stringa non vuota

user_input = input("Enter a value: ")
if isinstance(user_input, str) and user_input:
    print("Input is a non-empty string.")

Validazione di una password

Esempio di controllo della presenza di un carattere speciale.

password = "hello!"
if isinstance(password, str) and "!" in password:
    print("Password contains !")

Verificare che tutti gli elementi siano numeri

values = [1, 2.5, 3]
print(all(isinstance(value, (int, float)) for value in values))

8. Errori comuni da mostrare

L'operatore in non può essere usato per verificare l'appartenenza di un numero a un altro numero.

# Esempio errato: genera TypeError
# print(3 in 5)

Confrontare type(x) con la stringa "str" è sbagliato: il confronto va fatto con il tipo str.

x = "hello"
print(type(x) == "str")  # False: confronto con una stringa, non con il tipo

Ricorda:

• elemento in dizionario controlla solo le chiavi.
• elemento in dizionario.values() controlla i valori.