Python怎么判断两个变量是否指向同一个对象_is运算符与对象身份比较-Python教程-PHP中文网

Python中is运算符用于判断两个变量是否指向同一对象，通过比较内存地址（id）实现，而==比较值是否相等。示例显示可变对象如列表即使内容相同但独立创建时is返回False，不可变对象如小整数和短字符串因Python优化可能共享对象使is返回True，但此行为不应依赖。核心区别在于is检查身份、==检查值，常见用途包括与None比较、单例模式及缓存机制。

python怎么判断两个变量是否指向同一个对象_is运算符与对象身份比较

在Python中，要判断两个变量是否指向内存中的同一个对象，我们主要依赖

is

登录后复制

运算符。它检查的是对象的身份（identity），也就是它们在内存中的地址是否一致，这与

==

登录后复制

运算符检查值是否相等是完全不同的概念。简单来说，

is

登录后复制

关心的是“是不是同一个东西”，而

==

登录后复制

关心的是“是不是长得一样”。

Python提供了一个非常直观的方式来判断两个变量是否真的指向了同一个对象，那就是使用

is

登录后复制

运算符。这玩意儿，说实话，刚开始学Python的时候，我常常把它和

==

登录后复制

搞混，觉得它们差不多，都是用来做比较的。但深入下去，你会发现它们之间有着天壤之别，理解这个差异，对你写出更健壮、更符合Python哲学代码至关重要。

is

登录后复制

运算符的核心功能，就是判断两个操作数所引用的对象是不是同一个内存地址上的实体。你可以把它想象成在问：“这两个标签，是不是贴在了同一个箱子上？”如果答案是肯定的，

is

登录后复制

就返回

True

登录后复制

；否则，返回

False

登录后复制

。

为了更好地理解这一点，Python还提供了一个内置函数

id()

登录后复制

。每个对象在内存中都有一个唯一的身份标识，

id()

登录后复制

函数就是用来返回这个标识的。你可以把

id()

登录后复制

的返回值看作是对象在内存中的“门牌号”。当

a is b

登录后复制

为

True

登录后复制

时，

id(a)

登录后复制

和

id(b)

登录后复制

必然是相等的。反之亦然。

立即学习“Python免费学习笔记（深入）”；

我们来看几个例子：

# 列表是可变对象
list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1

print(f"id(list1): {id(list1)}")
print(f"id(list2): {id(list2)}")
print(f"id(list3): {id(list3)}")

print(f"list1 is list2: {list1 is list2}")  # False，它们是两个不同的列表对象，尽管内容相同
print(f"list1 == list2: {list1 == list2}")  # True，它们的值相等
print(f"list1 is list3: {list1 is list3}")  # True，list3引用了list1所指向的同一个对象

# 整数是不可变对象
a = 10
b = 10
c = 20
d = a

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

print(f"a is b: {a is b}")  # True (Python对小整数做了优化，会指向同一个对象)
print(f"a == b: {a == b}")  # True
print(f"a is c: {a is c}")  # False
print(f"a is d: {a is d}")  # True

# 字符串也是不可变对象
str1 = "hello"
str2 = "hello"
str3 = "world"
str4 = str1

print(f"id(str1): {id(str1)}")
print(f"id(str2): {id(str2)}")

print(f"str1 is str2: {str1 is str2}") # True (Python对短字符串也做了优化)
print(f"str1 == str2: {str1 == str2}") # True
print(f"str1 is str3: {str1 is str3}") # False
print(f"str1 is str4: {str1 is str4}") # True

登录后复制

从上面的例子可以看出，对于列表这样的可变对象，即使内容完全一样，只要是独立创建的，

is

登录后复制

就会返回

False

登录后复制

。但如果你把一个变量赋值给另一个变量（比如

list3 = list1

登录后复制

），那么它们就会指向同一个对象，

is

登录后复制

自然就返回

True

登录后复制

了。而对于整数和字符串这些不可变对象，情况就稍微有点“复杂”了，这涉及到Python的内部优化机制，我们稍后会详细聊聊。

Python的

is

登录后复制

运算符与

==

登录后复制

运算符究竟有何本质区别？

在我看来，这是Python初学者最容易混淆，但也是最需要搞清楚的一个知识点。简单来说，

is

登录后复制

比较的是“身份”，而

==

登录后复制

比较的是“值”。

is
登录后复制
运算符：它判断的是两个变量是否指向内存中的同一个对象。这实际上是比较它们的
```
id()
```
登录后复制
值。如果
```
id(var1)
```
登录后复制
等于
```
id(var2)
```
登录后复制
，那么
```
var1 is var2
```
登录后复制
就为
```
True
```
登录后复制
。这个比较是底层且高效的，因为它只需要检查内存地址。
==
登录后复制
运算符：它判断的是两个变量所引用的对象的值是否相等。这个比较是通过调用对象的
```
__eq__
```
登录后复制
方法来实现的。例如，当你比较两个列表
```
[1, 2, 3] == [1, 2, 3]
```
登录后复制
时，Python会去检查这两个列表的每个元素是否都相等。如果它们都相等，
```
__eq__
```
登录后复制
方法就会返回
```
True
```
登录后复制
。这个过程可能涉及到更复杂的逻辑和计算，取决于对象的类型和
```
__eq__
```
登录后复制
方法的实现。

举个例子，假设我们有两张一模一样的照片：

photo1 = "一张风景照"
photo2 = "一张风景照"
photo_copy = photo1

登录后复制

```
photo1 == photo2
```
登录后复制
：这就像问“这两张照片的内容是不是一样的？”答案很可能是
```
True
```
登录后复制
，因为它们都是“一张风景照”。
```
photo1 is photo2
```
登录后复制
：这就像问“这两张照片是不是同一张物理纸质照片？”答案很可能是
```
False
```
登录后复制
，因为它们可能是两张不同的打印件，尽管内容一样。
```
photo1 is photo_copy
```
登录后复制
：这就像问“这张照片和它的副本是不是同一张物理照片？”答案是
```
True
```
登录后复制
，因为
```
photo_copy
```
登录后复制
直接指向了
```
photo1
```
登录后复制
所指的那张照片。

所以，核心区别在于：

is

登录后复制

关注的是物理上的同一性，而

==

登录后复制

关注的是逻辑上的等价性。对于可变对象，如果你修改了

list1

登录后复制

，那么

list1 is list3

登录后复制

为

True

登录后复制

的情况下，

list3

登录后复制

也会随之改变，因为它们就是同一个东西。但如果只是

list1 == list2

登录后复制

为

True

登录后复制

，修改

list1

登录后复制

并不会影响

list2

登录后复制

。

AI Word

一款强大的 AI 智能内容创作平台，致力于帮助用户高效生成高质量、原创且符合 SEO 规范的各类文章。

226

查看详情

为什么Python对小整数和短字符串的

is

登录后复制

比较结果有时会出人意料？

这确实是一个很有意思的“陷阱”，很多初学者都会在这里绊一跤。我记得我刚开始的时候，就因为这个特性，对

is

登录后复制

运算符的理解产生了偏差。这背后其实是CPython（Python最常用的实现）为了优化性能和内存使用而进行的一些“驻留”（interning）或“缓存”操作。

小整数对象驻留（Interning）： CPython会预先创建并缓存一定范围内的整数对象。通常这个范围是
```
-5
```
登录后复制
到
```
256
```
登录后复制
。这意味着，当你创建任何在这个范围内的整数时，Python不会每次都创建一个新的对象，而是直接返回已经存在的那个对象。
```
a = 100
b = 100
print(f"a is b: {a is b}") # True，因为100在-5到256之间

x = 300
y = 300
print(f"x is y: {x is y}") # False，因为300超出了驻留范围，Python会创建两个不同的对象
```
登录后复制
所以，当
```
a
```
登录后复制
和
```
b
```
登录后复制
都是
```
100
```
登录后复制
时，它们会指向同一个对象，
```
is
```
登录后复制
返回
```
True
```
登录后复制
。但当
```
x
```
登录后复制
和
```
y
```
登录后复制
都是
```
300
```
登录后复制
时，由于
```
300
```
登录后复制
不在缓存范围内，Python会创建两个不同的
```
300
```
登录后复制
对象，所以
```
is
```
登录后复制
返回
```
False
```
登录后复制
。这事儿听起来有点魔幻，但确实是Python为了效率做的优化。
短字符串对象驻留：与小整数类似，CPython也会对某些短字符串进行驻留。具体规则比较复杂，通常包括：
- 只包含字母、数字、下划线的字符串。
- 在编译时确定，或者在运行时被某些操作（如字典键）隐式驻留的字符串。
- 短字符串。
```
s1 = "hello_world"
s2 = "hello_world"
print(f"s1 is s2: {s1 is s2}") # True，因为是短字符串且符合驻留条件

s3 = "hello world" # 包含空格
s4 = "hello world"
print(f"s3 is s4: {s3 is s4}") # False，通常包含空格的字符串不会被驻留（取决于具体实现和上下文）

s5 = "a" * 50 # 较长的字符串
s6 = "a" * 50
print(f"s5 is s6: {s5 is s6}") # False，通常较长的字符串不会被驻留
```
登录后复制
这个字符串驻留的规则比整数更复杂，也更容易受到Python版本、运行环境以及字符串创建方式的影响。所以，虽然它能带来性能提升，但在实际编程中，我们不应该依赖
```
is
```
登录后复制
来比较字符串的相等性，而应该始终使用
```
==
```
登录后复制
。
```
None
```
登录后复制
,
True
登录后复制
,
False
登录后复制
：这三个特殊值在Python中都是单例对象。这意味着在整个程序运行期间，无论你在哪里引用它们，它们都指向内存中的同一个对象。因此，
```
None is None
```
登录后复制
、
```
True is True
```
登录后复制
、
```
False is False
```
登录后复制
永远都是
```
True
```
登录后复制
。这也是我们经常用
```
if var is None:
```
登录后复制
来判断变量是否为空的原因。

这些优化是CPython的实现细节，它们可以减少内存消耗和对象创建的开销。但作为一个开发者，我的建议是：不要依赖这些实现细节来编写核心逻辑。除非你明确知道自己在做什么，并且有充分的理由，否则在比较值时，请始终使用

==

登录后复制

。

is

登录后复制

应该保留给需要严格判断对象身份的场景。

在日常编程中，除了与

None

登录后复制

比较，

is

登录后复制

运算符还有哪些实用场景？

除了最常见的

if var is None:

登录后复制

这种判断之外，

is

登录后复制

运算符在一些特定的场景下，确实能发挥出它独特的价值。它不仅仅是一个比较工具，有时更像是一种代码意图的表达。

实现单例模式（Singleton Pattern）：单例模式确保一个类只有一个实例。当你需要一个全局唯一的资源（比如配置管理器、数据库连接池），就可以利用
```
is
```
登录后复制
来检查是否已经创建了实例。
```
class Singleton:
    _instance = None
    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

s1 = Singleton()
s2 = Singleton()
print(f"s1 is s2: {s1 is s2}") # True
```
登录后复制
在这里，
```
is None
```
登录后复制
的判断是关键，它确保了
```
_instance
```
登录后复制
在第一次创建后，后续的调用都会返回同一个对象。

缓存机制或备忘录模式（Memoization）：在某些需要缓存计算结果的函数中，如果缓存的键是对象本身，而不是其值，那么

is

登录后复制

就可以用来判断传入的参数是否是缓存中已有的那个对象。这在处理复杂对象或自定义对象时尤其有用。

_cache = {}

def expensive_computation(obj):
    # 如果obj是缓存中的同一个对象，直接返回
    for cached_obj, result in _cache.items():
        if obj is cached_obj:
            print("从缓存获取结果")
            return result

    # 否则，进行昂贵的计算
    print("执行昂贵计算")
    result = obj * 2 # 假设这是昂贵的计算
    _cache[obj] = result # 将对象本身作为键存入缓存
    return result

data1 = [1, 2]
data2 = [1, 2]
data3 = data1

print(expensive_computation(data1))
print(expensive_computation(data3)) # 此时应该从缓存获取
print(expensive_computation(data2)) # 此时应该重新计算，因为data2是不同的对象

登录后复制

这个例子展示了

is

登录后复制

如何确保我们只对同一个对象进行一次昂贵的计算。

框架或库的内部实现：在一些复杂的框架或库中，开发者可能会定义一些特殊的“哨兵对象”（sentinel objects）来表示特定的状态或值，这些对象通常是单例。例如，一个迭代器可能有一个特殊的

END_OF_ITERATION

登录后复制

对象来标记迭代结束，而不是使用

None

登录后复制

，以避免与实际的

None

登录后复制

值混淆。

# 假设有一个自定义的哨兵对象
class Sentinel:
    def __repr__(self):
        return "EndOfStream"

END_OF_STREAM = Sentinel() # 这是一个单例哨兵对象

def get_next_item(data_source):
    # 模拟从数据源获取下一个项
    if not data_source:
        return END_OF_STREAM
    return data_source.pop(0)

my_data = [1, 2, 3]
while True:
    item = get_next_item(my_data)
    if item is END_OF_STREAM: # 使用is判断是否到达流的末尾
        print("数据流结束")
        break
    print(f"处理项: {item}")

登录后复制

这种方式比使用

None

登录后复制

更清晰，因为

None

登录后复制

本身可能是一个有效的数据值。

优化比较性能（特定场景）：理论上，
```
is
```
登录后复制
运算符比
```
==
```
登录后复制
运算符更快，因为它只是比较内存地址。在某些对性能极其敏感的循环中，如果你能确定两个变量在逻辑上确实应该指向同一个对象，并且这种身份比较是你的核心需求，那么使用
```
is
```
登录后复制
可能会带来微小的性能提升。但这通常是微优化，不建议在不清楚其必要性的情况下滥用。