Python 中的 is：身份运算符详解

Python 中的 is 运算符是身份运算符，用于检查两个变量是否指向内存中的同一个对象。与比较值是否相等的 == 运算符不同，is 通过检查两个引用是否指向完全相同的内存位置来比较对象身份。这种区别对于编写正确且高效的 Python 代码至关重要。

IS vs == 运算符

is 和 == 之间的关键区别在于 == 比较值（相等性），而 is 比较身份（内存中的同一对象）。

示例 1：基本区别

# Value comparison with ==
a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)  # Output: True (same values)
print(a is b)  # Output: False (different objects)

# Identity comparison
c = a
print(a is c)  # Output: True (same object)

# Memory locations
print(f"id(a): {id(a)}")
print(f"id(b): {id(b)}")
print(f"id(c): {id(c)}")

True
False
True
id(a): 140234567890
id(b): 140234567920
id(c): 140234567890

== 运算符返回 True，因为两个列表具有相同的内容，但 is 返回 False，因为它们是内存中的不同对象。

使用 id() 理解对象身份

id() 函数返回对象的唯一标识符（内存地址），is 运算符使用它进行比较。

示例：使用 id() 函数

x = [1, 2, 3, 4, 5]
y = [1, 2, 3, 4, 5]
z = x

# Check identity with 'is'
print(x is z)    # Output: True
print(x is y)    # Output: False

# Verify with id()
print(f"id(x): {id(x)}")
print(f"id(y): {id(y)}")
print(f"id(z): {id(z)}")

# x and z have the same id
# y has a different id

True
False
id(x): 140234567890
id(y): 140234567920
id(z): 140234567890

id() 函数返回对象的唯一标识符（内存地址），is 运算符使用它进行比较。

IS NOT 运算符

is not 运算符在两个变量引用内存中的不同对象时返回 True。

示例：使用 is not

a = [1, 2, 3, 4, 5]
b = [1, 2, 3, 4, 5]
c = a

# Using 'is not'
print(a is not c)  # Output: False (they are the same object)
print(a is not b)  # Output: True (different objects)

# Equivalent to: not (a is b)
print(not (a is b))  # Output: True

False
True
True

运算符比较表：

何时使用 IS 运算符

is 运算符应在对象身份比值相等性更重要的特定场景中使用。

使用场景 1：检查 None

def process_data(value):
    # CORRECT: Always use 'is' with None
    if value is None:
        print("No data provided")
        return
    
    print(f"Processing: {value}")

# WRONG: Don't use == with None
def wrong_check(value):
    if value == None:  # Not Pythonic
        print("This works but is not recommended")

process_data(None)  # Output: No data provided
process_data(42)    # Output: Processing: 42

未提供数据
处理中: 42

与 None 比较时，始终使用 is 或 is not，因为它更明确且更快。

使用场景 2：检查布尔单例

def check_flag(flag):
    # Use 'is' for True/False when checking identity
    if flag is True:
        print("Flag is explicitly True")
    elif flag is False:
        print("Flag is explicitly False")
    else:
        print(f"Flag is truthy/falsy but not boolean: {flag}")

check_flag(True)   # Flag is explicitly True
check_flag(1)      # Flag is truthy/falsy but not boolean: 1
check_flag(False)  # Flag is explicitly False
check_flag(0)      # Flag is truthy/falsy but not boolean: 0

标志明确为 True
标志是真值/假值但不是布尔值: 1
标志明确为 False
标志是真值/假值但不是布尔值: 0

使用场景 3：检查变量是否引用同一列表/字典

def modify_list(original_list, new_list):
    if original_list is new_list:
        print("Warning: Same list reference, modifications will affect both")
        return False
    return True

my_list = [1, 2, 3]
same_ref = my_list
different_list = [1, 2, 3]

modify_list(my_list, same_ref)       # Warning message
modify_list(my_list, different_list) # Returns True

警告：相同的列表引用，修改将影响两者

Python 的整数和字符串驻留

Python 自动对小整数和某些字符串进行驻留优化，这可能导致令人惊讶的 is 行为。

示例：小整数缓存

# Small integers (-5 to 256) are cached
a = 256
b = 256
print(a is b)  # Output: True

a = 257
b = 257
print(a is b)  # Output: False (usually, depends on implementation)

# This is due to Python's integer interning optimization
print(id(256) == id(256))  # True
print(id(257) == id(257))  # May vary

True
False
True
True

示例：字符串驻留

# String interning
a = "TutorialsPoint"
b = a
print(f"id(a), id(b): {id(a)}, {id(b)}")
print(f"a is b: {a is b}")          # Output: True
print(f"b is not a: {b is not a}")  # Output: False

# Identical string literals are often interned
x = "hello"
y = "hello"
print(x is y)  # Output: True (usually)

# But not always for dynamically created strings
x = "hello world"
y = "hello world"
print(x is y)  # Output: May be True or False

# Strings with spaces/special chars may not be interned
x = "hello world!"
y = "hello world!"
print(x is y)  # Output: False (typically)

id(a), id(b): 140234567890, 140234567890
a is b: True
b is not a: False
True
True
False

Python 自动对小整数和某些字符串进行驻留优化，这可能导致令人惊讶的 is 行为。永远不要在生产代码中依赖此行为。

常见陷阱和错误

了解使用 is 运算符时的常见错误有助于避免错误并编写更可靠的代码。

Mistake 1: Using IS for Value Comparison

# WRONG: Using 'is' to compare values
a = 1000
b = 1000
if a is b:  # Unreliable!
    print("Equal")
else:
    print("Not equal")  # Usually prints this

# CORRECT: Use == for value comparison
if a == b:  # Reliable
    print("Equal")  # Always prints this for equal values

Mistake 2: Relying on Integer Interning

# Don't rely on this behavior!
def bad_comparison(x, y):
    if x is y:  # Only works reliably for small integers
        return True
    return False

print(bad_comparison(5, 5))      # True (cached)
print(bad_comparison(500, 500))  # False (not cached)

# CORRECT approach
def good_comparison(x, y):
    if x == y:  # Always reliable
        return True
    return False

print(good_comparison(5, 5))      # True
print(good_comparison(500, 500))  # True

Mistake 3: Misunderstanding Mutable vs Immutable Types

# Immutable types (int, str, tuple)
a = 42
b = 42
print(a is b)  # May be True (depends on interning)

# Mutable types (list, dict, set)
x = [1, 2]
y = [1, 2]
print(x is y)  # Always False (different objects)

# Assignment creates reference, not copy
z = x
print(x is z)  # True (same object)

# Use copy to create new object
import copy
w = copy.copy(x)
print(x is w)  # False (different objects)
print(x == w)  # True (same values)

最佳实践

遵循使用 is 运算符的最佳实践可确保可靠且符合 Python 风格的代码。

实践 1：始终对 None 使用 IS

# GOOD: Checking for None
if value is None:
    handle_none()

# BAD: Using == with None
if value == None:  # Works but not Pythonic
    handle_none()

与 <code>None</code> 比较时，始终使用 <code>is</code> 和 <code>is not</code>。

实践 2：使用 == 进行值比较

# GOOD: Value comparison
if count == 0:
    print("Empty")

# BAD: Using 'is' for value comparison
if count is 0:  # Unreliable!
    print("Empty")

在大多数其他情况下使用 <code>==</code> 进行值比较。

实践 3：对单例对象使用 IS

# GOOD: Checking if same list
if original_list is modified_list:
    print("Same object")

# GOOD: Checking if equal values
if list1 == list2:
    print("Equal contents")

对单例对象（<code>None</code>、<code>True</code>、<code>False</code>）使用 <code>is</code>，并检查两个变量是否引用同一个可变对象。

实践 4：永远不要依赖驻留

# BAD: Relying on integer interning
if x is 256:  # May work, but unreliable
    do_something()

# GOOD: Use == for value comparison
if x == 256:  # Always reliable
    do_something()

永远不要在生产代码中依赖整数或字符串驻留。>

实际示例

这些示例展示了 is 运算符在实际场景中的实际用途。

示例 1：单例模式实现

class DatabaseConnection:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            print("Creating new database connection")
        return cls._instance

# Test singleton
db1 = DatabaseConnection()
db2 = DatabaseConnection()

print(db1 is db2)  # Output: True (same instance)
print(id(db1) == id(db2))  # Output: True

创建新的数据库连接
True
True

示例 2：缓存实现

class Cache:
    def __init__(self):
        self._cache = {}
        self._MISSING = object()
    
    def get(self, key, default=None):
        result = self._cache.get(key, self._MISSING)
        
        if result is self._MISSING:
            print(f"Cache miss for key: {key}")
            return default
        
        print(f"Cache hit for key: {key}")
        return result
    
    def set(self, key, value):
        self._cache[key] = value

# Usage
cache = Cache()
cache.set('user_1', {'name': 'Alice'})

cache.get('user_1')        # Cache hit
cache.get('user_2')        # Cache miss
cache.get('user_2', {})    # Cache miss, returns {}

缓存命中，键: user_1
缓存未命中，键: user_2
缓存未命中，键: user_2

示例 3：防御性复制检测

def modify_list_safely(original, new_items):
    # Check if caller passed the same list
    if original is new_items:
        raise ValueError("Cannot pass same list for both arguments")
    
    original.extend(new_items)
    return original

my_list = [1, 2, 3]
additional = [4, 5]

result = modify_list_safely(my_list, additional)
print(result)  # [1, 2, 3, 4, 5]

try:
    modify_list_safely(my_list, my_list)  # Raises ValueError
except ValueError as e:
    print(f"Error: {e}")

[1, 2, 3, 4, 5]
错误：不能为两个参数传递相同的列表

相关主题

• if in python - 了解基本条件语句
• if else in python - 学习如何处理替代条件
• and in python - 组合多个条件
• or in python - 了解 OR 逻辑运算符
• or in python - 了解 OR 逻辑运算符

常见问题