Membership & Identity Operators

Beginner ~15 min read

Python provides intuitive operators for checking if values exist in sequences (in, not in) and for comparing object identity (is, is not). These make your code read almost like English!

The 'in' Membership Operator

The in operator checks if a value exists within a sequence like a list, string, tuple, set, or dictionary.

Sequence Type	What 'in' Checks	Example
List	Item in list	`'a' in ['a', 'b']` → True
String	Substring in string	`'or' in 'world'` → True
Tuple	Item in tuple	`1 in (1, 2, 3)` → True
Set	Item in set	`5 in {1, 5, 9}` → True
Dictionary	Key in dict (not value!)	`'name' in {'name': 'Jo'}` → True

# The 'in' Membership Operator

# Works with lists
print("=== Lists ===")
fruits = ["apple", "banana", "cherry"]
print(f"fruits = {fruits}")
print(f"'banana' in fruits: {'banana' in fruits}")  # True
print(f"'orange' in fruits: {'orange' in fruits}")  # False

print()

# Works with strings (substring search)
print("=== Strings ===")
message = "Hello, World!"
print(f"message = '{message}'")
print(f"'World' in message: {'World' in message}")  # True
print(f"'world' in message: {'world' in message}")  # False (case-sensitive!)
print(f"'o' in message: {'o' in message}")  # True

print()

# Works with tuples
print("=== Tuples ===")
coordinates = (10, 20, 30)
print(f"coordinates = {coordinates}")
print(f"20 in coordinates: {20 in coordinates}")  # True

print()

# Works with dictionaries (checks KEYS, not values!)
print("=== Dictionaries ===")
person = {"name": "Alice", "age": 30}
print(f"person = {person}")
print(f"'name' in person: {'name' in person}")   # True (checks keys)
print(f"'Alice' in person: {'Alice' in person}") # False (Alice is a value!)
print(f"'Alice' in person.values(): {'Alice' in person.values()}")  # True

print()

# Works with sets
print("=== Sets ===")
numbers = {1, 2, 3, 4, 5}
print(f"numbers = {numbers}")
print(f"3 in numbers: {3 in numbers}")  # True
print(f"10 in numbers: {10 in numbers}") # False

Output

Click Run to execute your code

Key Point: For dictionaries, in checks keys by default. Use value in dict.values() to check values, or value in dict.items() for key-value pairs.

The 'not in' Operator

The not in operator is the opposite of in - it returns True when a value is NOT found in the sequence.

# The 'not in' Membership Operator

# Basic usage
print("=== Basic 'not in' ===")
allowed_users = ["admin", "moderator", "user"]
print(f"allowed_users = {allowed_users}")

current_user = "guest"
print(f"current_user = '{current_user}'")
print(f"'{current_user}' not in allowed_users: {current_user not in allowed_users}")  # True

print()

# Practical validation example
print("=== Input Validation ===")
valid_choices = ["yes", "no", "maybe"]
user_input = "perhaps"

if user_input not in valid_choices:
    print(f"'{user_input}' is not a valid choice!")
    print(f"Please choose from: {valid_choices}")

print()

# String validation
print("=== String Validation ===")
password = "MyP@ssw0rd"
forbidden_chars = " '\""  # space, single quote, double quote

has_forbidden = False
for char in forbidden_chars:
    if char in password:
        has_forbidden = True
        print(f"Password contains forbidden character: '{char}'")

if not has_forbidden:
    print("Password is valid (no forbidden characters)")

print()

# Filtering a list
print("=== Filtering with 'not in' ===")
all_items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
exclude = [2, 4, 6, 8, 10]

# Keep only items not in exclude list
filtered = [x for x in all_items if x not in exclude]
print(f"All items: {all_items}")
print(f"Exclude: {exclude}")
print(f"Filtered: {filtered}")  # [1, 3, 5, 7, 9]

Output

Click Run to execute your code

Performance Tip: Checking membership in a set is O(1) constant time, while lists are O(n). For large collections with many lookups, convert to a set first!

Identity Operators: 'is' and 'is not'

Identity operators check if two variables point to the same object in memory, not just if they have equal values.

Operator	Description	Example
`is`	True if same object	`a is b`
`is not`	True if different objects	`a is not b`

# Identity Operators: 'is' and 'is not'
# Check if two variables point to the SAME object in memory

print("=== Understanding 'is' ===")

# Two variables pointing to same object
a = [1, 2, 3]
b = a  # b points to the same list as a
print(f"a = {a}")
print(f"b = a")
print(f"a is b: {a is b}")  # True - same object
print(f"id(a): {id(a)}")
print(f"id(b): {id(b)}")  # Same ID!

print()

# Two variables with equal values, different objects
x = [1, 2, 3]
y = [1, 2, 3]  # New list with same values
print(f"x = {x}")
print(f"y = {y}")
print(f"x is y: {x is y}")  # False - different objects
print(f"x == y: {x == y}")  # True - same values
print(f"id(x): {id(x)}")
print(f"id(y): {id(y)}")  # Different IDs!

print()

# 'is not' operator
print("=== Understanding 'is not' ===")
print(f"x is not y: {x is not y}")  # True - different objects
print(f"a is not b: {a is not b}")  # False - same object

print()

# Small integer caching (Python optimization)
print("=== Python Caching (Small Integers) ===")
small1 = 5
small2 = 5
print(f"small1 = 5, small2 = 5")
print(f"small1 is small2: {small1 is small2}")  # True (Python caches -5 to 256)

large1 = 1000
large2 = 1000
print(f"large1 = 1000, large2 = 1000")
print(f"large1 is large2: {large1 is large2}")  # May be True or False!
print("(Result depends on Python implementation)")

Output

Click Run to execute your code

Important: Don't use is to compare values! Use == for value comparison. is should primarily be used for checking None, True, or False.

Practical Uses of Identity Operators

The most common and important use of is is checking for None.

# Practical Uses of Identity Operators

# 1. Checking for None (most common use!)
print("=== Checking for None ===")

def get_user(user_id):
    """Returns user or None if not found"""
    users = {1: "Alice", 2: "Bob"}
    return users.get(user_id)

result = get_user(3)
print(f"get_user(3) returned: {result}")

# Always use 'is' or 'is not' with None!
if result is None:
    print("User not found!")
else:
    print(f"Found user: {result}")

print()

# Why use 'is' instead of '==' for None?
print("=== Why 'is' for None? ===")
print("None is a singleton - there's only ONE None object")
print(f"id(None): {id(None)}")

# == can be overridden by classes, 'is' cannot
print("'is' is safer and faster for None checks")

print()

# 2. Checking for True/False explicitly
print("=== Boolean Identity ===")
value = True

# These are all different!
print(f"value = {value}")
print(f"value is True: {value is True}")    # Checks identity
print(f"value == True: {value == True}")    # Checks equality
print(f"if value: ... (truthy check)")      # Checks truthiness

# Be careful with non-boolean values
print()
print(f"1 == True: {1 == True}")    # True (value comparison)
# Note: Using 'is' with literals shows identity comparison
one_is_true = 1 is True
print(f"1 is True: {one_is_true}")    # False (different objects!)

print()

# 3. Checking object mutation
print("=== Detecting Object Mutation ===")
original = [1, 2, 3]
reference = original
copy = original.copy()

original.append(4)

print(f"original: {original}")
print(f"reference: {reference}")  # Also changed!
print(f"copy: {copy}")            # Not changed

print(f"reference is original: {reference is original}")  # True
print(f"copy is original: {copy is original}")            # False

Output

Click Run to execute your code

Best Practice: Always use is None or is not None instead of == None. It's faster, safer, and the recommended Python style (PEP 8).

Common Mistakes

1. Using 'is' to compare values

# Wrong - may work sometimes, but unreliable!
if name is "Alice":  # Don't do this!
    print("Hello Alice")

# Correct - use == for value comparison
if name == "Alice":
    print("Hello Alice")

2. Checking dictionary values with 'in'

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

# Wrong - checks keys, not values!
if "Alice" in person:  # False!
    print("Found Alice")

# Correct - explicitly check values
if "Alice" in person.values():
    print("Found Alice")

3. Case-sensitive string membership

text = "Hello World"

# This fails because of case
if "hello" in text:  # False!
    print("Found")

# Correct - normalize case first
if "hello" in text.lower():
    print("Found")

4. Using == instead of 'is' for None

# Works but not recommended
if result == None:
    print("No result")

# Correct and preferred
if result is None:
    print("No result")

Exercise: Access Control

Task: Build an access control checker using membership operators.

Requirements:

Check if a user is in the guests list using in
Check if a user is in the banned list using in
Check if a user is NOT banned using not in

Output

Click Run to execute your code

Show Solution

guests = ["Alice", "Bob", "Charlie", "David"]
banned_users = ["Eve", "Mallory"]

name_to_check = "Bob"
banned_name = "Eve"

# 1. Check if name is in guests list
is_invited = name_to_check in guests
print(f"Is {name_to_check} invited? {is_invited}")  # True

# 2. Check if name is in banned list
is_banned = banned_name in banned_users
print(f"Is {banned_name} banned? {is_banned}")  # True

# 3. Check if name is NOT in banned list
is_safe = name_to_check not in banned_users
print(f"Is {name_to_check} safe? {is_safe}")  # True

Summary

in: Checks if a value exists in a sequence (list, string, tuple, set, dict keys)
not in: Checks if a value does NOT exist in a sequence
is: Checks if two variables point to the same object in memory
is not: Checks if two variables point to different objects
Use == for value comparison, is for identity/None checks
Performance: Set membership is O(1), list membership is O(n)

What's Next?

Congratulations on completing the Operators module! You now have all the tools to build expressions and make decisions in Python. Next, we'll learn about control flow with if statements - using these operators to direct your program's execution!

Previous Bitwise Operators

Next If Statements

The 'in' Membership Operator

The 'not in' Operator

Identity Operators: 'is' and 'is not'

Practical Uses of Identity Operators

Common Mistakes

1. Using 'is' to compare values

2. Checking dictionary values with 'in'

3. Case-sensitive string membership

4. Using == instead of 'is' for None

Exercise: Access Control

Summary

What's Next?

Enjoying these tutorials?