Python初学者:“==”and“is”的区别是什么?

开发 后端
“==”和“is”都是Python中的运算符。初学者可能会把“a == b”理解为“a等于b”,而把“a is b” 理解为 “a is b”。也许这就是Python初学者混淆“==”和“is”的原因。

本文转载自公众号“读芯术”(ID:AI_Discovery)。

几天前,我在Reddit上浏览“learn python”板块的相关内容时,看到一位Reddit用户再次提问了这个问题:“==” and “is”的区别是什么?虽然网上对此问题已经有太多的答案和解释,但是很多初学者还是不知道,还是会犯错。

[[340873]]

“==”和“is”都是Python中的运算符。初学者可能会把“a == b”理解为“a等于b”,而把“a is b” 理解为 “a is b”。也许这就是Python初学者混淆“==”和“is”的原因。

在深入讨论之前,我想先举几个“==” 和 “is”的用例:

  1. >>> a = 5 
  2. >>> b = 5 
  3. >>> a == bTrue>>> a is b 
  4. True 

简单吧?a== b 和 a is b 都能返回 True。下一个例子:

  1. >>> a = 1000 
  2. >>> b = 1000 
  3. >>> a == bTrue>>> a is b 
  4. False 

这是为什么?第二个例子与第一个唯一的不同就在于a和b的值从5变成了1000,但是“==” 和 “is”输出的结果却完全不同。再看下一例:

  1. >>> a = [] 
  2. >>> b = []>>> a == bTrue>>> a is b 
  3. False 

如果这还不够震惊,再看最后一个例子:

  1. >>> a = 1000 
  2. >>> b = 1000 
  3. >>> a == bTrue>>> a is b 
  4. False>>> a = b>>> a == bTrue>>> a is b 
  5. True 

“==”的正式运算是相等,而“is”的运算是标识。用“==”是比较两个对象的值。“a == b”应解释为“a的值是否等于b的值”。在上述所有示例中,a的值始终等于b的值(即使对于空列的示例也是如此),因此“a == b”始终为真。

在解释标识的概念之前,我需要先介绍一下id函数。对象的标识可以通过id函数来获得。一个对象的标识始终是唯一且恒定的,你可以将其视为该对象的地址。如果两个对象的标识相同,则它们的值也一定相同。

  1. >>> id(a) 
  2. 2047616 

运算符“is”用于比较两个对象的标识是否相同,“a is b”就表示“a的标识与b的标识相同”。

[[340874]]

图源:unsplash

现在你知道了“==”和“is”的真正含义,我们就可以开始深入讨论上述示例。

首先是第一例和第二例的结果差异。因为Python存储了一个介于-5到256之间的整数数组列表,每一个整数都有固定的对应标识。当你在此范围内分配整数变量时,Python就会将此变量作为数组列里的整数为其分配标识。

因此,在第一例中,由于a和b的标识都是从数组列表中获得的,所以他们的标识当然相同,因此a is b为真。

  1. >>> a = 5 
  2. >>> id(a) 
  3. 1450375152 
  4. >>> b = 5 
  5. >>> id(b) 
  6. 1450375152 

但一旦变量的值不在这个区间范围内,由于Python内部没有对应该值的对象,因此Python将为此变量创建新的标识,并为这个变量赋值。

如前所述,每个创建的标识都是唯一的,因此即使两个变量的值相同,他们的标识也永远不会等同。这就是为什么第二例中的a is b返回False。

  1. >>> a = 1000 
  2. >>> id(a) 
  3. 12728608 
  4. >>> b = 1000 
  5. >>> id(b) 
  6. 13620208 

另外,假设你打开的是两个控制台,如果该值仍在区间内,也能得到相同标识。但是,如果该值不在区间内,结果当然就不同了。

Python初学者:“==”and“is”的区别是什么?

一旦理解了第一例和第二例的区别,就很容易理解第三例的结果了。由于Python不存储“空列表”对象,所以Python创建了一个新对象并赋值“空列表”。无论这两个列表是空还是元素相同,结果都是一样的。

  1. >>> a = [1,10,100,1000] 
  2. >>> b = [1,10,100,1000] 
  3. >>> a == bTrue>>> a is bFalse>>> id(a) 
  4. 12578024 
  5. >>> id(b) 
  6. 12578056 

来看最后一例。第二例与最后一例的唯一区别在于多了一行代码a = b。然而,这行代码却改变了变量a的命运。下面的结果将阐述原因:

  1. >>> a = 1000 
  2. >>> b = 2000 
  3. >>> id(a) 
  4. 2047616 
  5. >>> id(b) 
  6. 5034992 
  7. >>> a = b>>> id(a) 
  8. 5034992 
  9. >>> id(b) 
  10. 5034992 
  11. >>> a2000>>> b2000 

可以看到,在a= b之后,a的标识变成了b的标识。a = b把b的标识赋予了a。因此a和b就拥有了相同的标识,a的值现在就等于b的值,即2000。

最后一例传达出一个重要信息,即你可能在不经意间更改了对象的值,尤其是当对象为列表时。

  1. >>> a = [1,2,3] 
  2. >>> id(a) 
  3. 5237992 
  4. >>> b = a 
  5. >>> id(b) 
  6. 5237992 
  7. >>> a.append(4) 
  8. >>> a 
  9. [1, 2, 3, 4] 
  10. >>> b 
  11. [1, 2, 3, 4] 

从上例可以看出,a和b拥有相同的标识,他们的值就一定相同。因此在为a附加了一个新元素后,b的值也会受到影响。为了避免这种情况,如果要把一个对象的值复制到另一对象,又不引用同一标识,一个方法是在copy模块中使用deepcopy。对于列表,你还可以通过b= a[:]来实现。

  1. >>> import copy 
  2. >>> a = [1,2,3] 
  3. >>> bcopy.deepcopy(a) 
  4. >>> id(a) 
  5. 39785256 
  6. >>> id(b) 
  7. 5237992 

使用[:]把元素复制到新变量:

  1. >>> a = [1,2,3] 
  2. >>> id(a) 
  3. 39785256 
  4. >>> b = a[:] 
  5. >>> id(b) 
  6. 23850216 
  7. >>> a.append(4) 
  8. >>> a 
  9. [1, 2, 3, 4] 
  10. >>> b 
  11. [1, 2, 3] 

希望这篇文章能帮你彻底解决这个问题,不要再被相同的难题困住啦。

 

责任编辑:赵宁宁 来源: 今日头条
相关推荐

2010-03-10 17:09:26

Python语言

2011-09-16 09:38:19

Emacs

2022-04-24 15:21:01

MarkdownHTML

2011-04-12 10:13:24

2024-08-17 12:14:06

2014-03-12 10:11:57

Python设计模式

2009-09-28 09:45:00

CCNA学习经验CCNA

2011-07-04 14:14:54

java

2020-08-07 07:05:48

JavaScript开发技术

2022-10-10 15:28:45

负载均衡

2015-07-20 13:56:59

SDN

2020-08-04 08:42:10

Python开发工具

2021-03-07 00:56:05

区块链Python安全

2020-09-08 19:03:41

Java代码初学者

2010-06-13 11:13:38

UML初学者指南

2022-07-22 13:14:57

TypeScript指南

2009-08-30 15:04:56

2023-07-03 15:05:07

预测分析大数据

2021-05-10 08:50:32

网络管理网络网络性能

2022-03-28 09:52:42

JavaScript语言
点赞
收藏

51CTO技术栈公众号