in en Python : Opérateur de membreship expliqué

L'opérateur in est l'opérateur de membreship de Python qui vérifie si une valeur existe dans une collection telle qu'une liste, un tuple, une chaîne, un ensemble ou un dictionnaire. Il renvoie True si la valeur est trouvée et False sinon. Cet opérateur rend les tests d'appartenance propres et lisibles.

Que fait l'opérateur in ?

L'opérateur in effectue untest d'appartenance : il recherche une valeur donnée dans une collection et renvoie un résultat booléen. La syntaxe de base est :

value in collection

Ici, value est ce que vous recherchez, et collection peut être n'importe quel objet itérable comme une liste, un tuple, une chaîne, un ensemble ou un dictionnaire (pour les dictionnaires, in vérifie les clés par défaut).

Utiliser in avec les listes et tuples

Les listes et tuples sont les cas d'usage les plus courants pour l'opérateur in.

Exemple 1 : Vérifier l'appartenance dans les listes

numbers = [1, 2, 3, 4, 5]

print(3 in numbers)      # Output: True
print(10 in numbers)     # Output: False
print(3 not in numbers)  # Output: False

True
False
False

Exemple 2 : Vérifier l'appartenance dans les tuples

coordinates = (10, 20, 30)

print(20 in coordinates)      # Output: True
print(50 in coordinates)      # Output: False
print(50 not in coordinates)  # Output: True

True
False
True

Pour les listes et tuples, Python utilise unalgorithme de recherche linéaire, ce qui signifie qu'il vérifie chaque élément un par un jusqu'à trouver une correspondance ou atteindre la fin. La complexité temporelle est O(n), donc les collections plus grandes prennent plus de temps à rechercher.

Utiliser in avec les chaînes

Lorsqu'il est utilisé avec des chaînes, l'opérateur in vérifie l'appartenance de sous-chaîne.

Exemple 1 : Vérification de sous-chaîne de base

text = "Hello, World!"

print("World" in text)      # Output: True
print("Python" in text)     # Output: False
print("hello" in text)      # Output: False (case-sensitive)

True
False
False

Exemple 2 : Vérification insensible à la casse

text = "Hello, World!"
search = "world"

print(search.lower() in text.lower())  # Output: True

True

Les tests d'appartenance de chaînes sont sensibles à la casse. Si vous avez besoin de vérifications insensibles à la casse, convertissez les deux chaînes au même cas. Les recherches de sous-chaînes dans les chaînes Python ont également une complexité O(n) dans le pire des cas.

Utiliser in avec les ensembles

Les ensembles sont optimisés pour les tests d'appartenance. Parce que les ensembles utilisent destables de hachage en interne, l'opérateur in a une complexité temporelle moyenne de O(1).

Exemple 1 : Vérification rapide d'appartenance

allowed_users = {"alice", "bob", "charlie"}

print("alice" in allowed_users)    # Output: True
print("dave" in allowed_users)     # Output: False

True
False

Exemple 2 : Optimisation des performances

# Slow for large lists
users = ["alice", "bob", "charlie"]
if "alice" in users:
    print("Found")

# Fast - convert to set first
users_set = set(users)
if "alice" in users_set:
    print("Found")

Found
Found

Si vous devez effectuer de nombreuses vérifications d'appartenance, convertir d'abord une liste en ensemble peut améliorer considérablement les performances.

Utiliser in avec les dictionnaires

Lorsque vous utilisez in avec un dictionnaire, il vérifie si une clé existe (pas les valeurs).

Exemple 1 : Vérifier les clés

user_ages = {"alice": 30, "bob": 25, "charlie": 35}

print("alice" in user_ages)      # Output: True
print("dave" in user_ages)       # Output: False
print(30 in user_ages)           # Output: False (30 is a value, not a key)

True
False
False

Exemple 2 : Vérifier les valeurs

user_ages = {"alice": 30, "bob": 25, "charlie": 35}

# Check if a value exists
print(30 in user_ages.values())  # Output: True

True

Exemple 3 : Vérifier les paires clé-valeur

user_ages = {"alice": 30, "bob": 25, "charlie": 35}

# Check if a key-value pair exists
print(("alice", 30) in user_ages.items())  # Output: True

True

Les tests d'appartenance de dictionnaires pour les clés sont également O(1) en moyenne car les dictionnaires utilisent des tables de hachage.

L'opérateur not in

Python fournit également l'opérateur not in, qui renvoie True si la valeurn'est pas trouvée.

Exemple : Utiliser not in

numbers = [1, 2, 3, 4, 5]

print(10 not in numbers)  # Output: True
print(3 not in numbers)   # Output: False

True
False

C'est simplement la négation logique de in, et cela fonctionne avec tous les mêmes types de données.

Utiliser in avec des objets personnalisés

Si vous créez vos propres classes, vous pouvez les faire fonctionner avec l'opérateur in en implémentant la méthode __contains__().

Exemple : Classe de collection personnalisée

class MyCollection:
    def __init__(self, items):
        self.items = items
    
    def __contains__(self, item):
        return item in self.items

my_list = MyCollection([1, 2, 3, 4, 5])

print(3 in my_list)   # Output: True
print(10 in my_list)  # Output: False

True
False

Si votre classe ne définit pas __contains__() mais est itérable (implémente __iter__()), Python reviendra à l'itération à travers la collection pour vérifier l'appartenance.

Considérations de performance

La performance de l'opérateur in dépend du type de données.

Pour les vérifications fréquentes d'appartenance sur de grandes collections, préférez les ensembles ou dictionnaires aux listes ou tuples.

Cas d'usage courants

Cas d'usage 1 : Vérifier les permissions utilisateur

admin_users = {"alice", "bob"}

if current_user in admin_users:
    print("Access granted")
else:
    print("Access denied")

Access granted

Cas d'usage 2 : Valider l'entrée

valid_options = ["yes", "no", "maybe"]

user_input = input("Enter your choice: ")

if user_input in valid_options:
    print("Valid choice")
else:
    print("Invalid choice")

Valid choice

Cas d'usage 3 : Filtrer les données

exclude_words = {"the", "is", "at", "which", "on"}

words = ["the", "quick", "brown", "fox"]
filtered = [word for word in words if word not in exclude_words]

print(filtered)  # Output: ['quick', 'brown', 'fox']

['quick', 'brown', 'fox']

Erreurs courantes et meilleures pratiques

Erreur 1 : Utiliser in pour les vérifications de plage

# Not recommended for performance-critical code
if 5 in range(1, 10):
    print("In range")

# Better: Use comparison operators
if 1 <= 5 < 10:
    print("In range")

N'utilisez pas in pour les vérifications de plage numérique comme if 5 in range(1, 10): dans le code critique pour les performances ; utilisez plutôt les opérateurs de comparaison : if 1 <= 5 < 10:.

Pratique 1 : Convertir les listes en ensembles pour les vérifications fréquentes

# When checking membership in large lists repeatedly
large_list = [1, 2, 3, ...]  # Many items

# Convert to set for faster lookups
large_set = set(large_list)
if item in large_set:
    print("Found")

Lors de la vérification de l'appartenance dans de grandes listes de manière répétée, convertissez d'abord la liste en ensemble pour des recherches beaucoup plus rapides.

Pratique 2 : Se souvenir du comportement du dictionnaire

user_data = {"name": "Alice", "age": 30}

# in checks keys, not values
print("name" in user_data)        # True
print("Alice" in user_data)        # False

# To check values, use .values()
print("Alice" in user_data.values())  # True

N'oubliez pas que in vérifie lesclés dans les dictionnaires, pas les valeurs. Utilisez .values() ou .items() si vous devez vérifier les valeurs ou les paires clé-valeur.

Pratique 3 : Sensibilité à la casse dans les chaînes

text = "Hello, World!"

# Case-sensitive check
print("hello" in text)  # False

# Case-insensitive check
print("hello".lower() in text.lower())  # True

Les tests d'appartenance de chaînes avec in sont sensibles à la casse ; normalisez la casse si nécessaire.

Sujets connexes

• if en python - Apprenez les déclarations conditionnelles de base
• if else en python - Apprenez à gérer les conditions alternatives
• and en python - Combinez plusieurs conditions
• or en python - Apprenez l'opérateur logique OR
• not en python - Négation des conditions avec l'opérateur NOT
• is en python - Vérifier l'identité de l'objet

Questions fréquemment posées