Python核心技术与实战
景霄
Facebook资深工程师
立即订阅
13891 人已学习
课程目录
已完结 46 讲
0/4登录后,你可以任选4讲全文学习。
开篇词 (1讲)
开篇词 | 从工程的角度深入理解Python
免费
基础篇 (14讲)
01 | 如何逐步突破,成为Python高手?
02 | Jupyter Notebook为什么是现代Python的必学技术?
03 | 列表和元组,到底用哪一个?
04 | 字典、集合,你真的了解吗?
05 | 深入浅出字符串
06 | Python “黑箱”:输入与输出
07 | 修炼基本功:条件与循环
08 | 异常处理:如何提高程序的稳定性?
09 | 不可或缺的自定义函数
10 | 简约不简单的匿名函数
11 | 面向对象(上):从生活中的类比说起
12 | 面向对象(下):如何实现一个搜索引擎?
13 | 搭建积木:Python 模块化
14 | 答疑(一):列表和元组的内部实现是怎样的?
进阶篇 (11讲)
15 | Python对象的比较、拷贝
16 | 值传递,引用传递or其他,Python里参数是如何传递的?
17 | 强大的装饰器
18 | metaclass,是潘多拉魔盒还是阿拉丁神灯?
19 | 深入理解迭代器和生成器
20 | 揭秘 Python 协程
21 | Python并发编程之Futures
22 | 并发编程之Asyncio
23 | 你真的懂Python GIL(全局解释器锁)吗?
24 | 带你解析 Python 垃圾回收机制
25 | 答疑(二):GIL与多线程是什么关系呢?
规范篇 (7讲)
26 | 活都来不及干了,还有空注意代码风格?!
27 | 学会合理分解代码,提高代码可读性
28 | 如何合理利用assert?
29 | 巧用上下文管理器和With语句精简代码
30 | 真的有必要写单元测试吗?
31 | pdb & cProfile:调试和性能分析的法宝
32 | 答疑(三):如何选择合适的异常处理方式?
量化交易实战篇 (8讲)
33 | 带你初探量化世界
免费
34 | RESTful & Socket: 搭建交易执行层核心
35 | RESTful & Socket: 行情数据对接和抓取
36 | Pandas & Numpy: 策略与回测系统
免费
37 | Kafka & ZMQ:自动化交易流水线
38 | MySQL:日志和数据存储系统
39 | Django:搭建监控平台
40 | 总结:Python中的数据结构与算法全景
技术见闻与分享 (4讲)
41 | 硅谷一线互联网公司的工作体验
42 | 细数技术研发的注意事项
加餐 | 带你上手SWIG:一份清晰好用的SWIG编程实践指南
43 | Q&A:聊一聊职业发展和选择
结束语 (1讲)
结束语 | 技术之外的几点成长建议
Python核心技术与实战
登录|注册

15 | Python对象的比较、拷贝

景霄 2019-06-12
你好,我是景霄。
在前面的学习中,我们其实已经接触到了很多 Python 对象比较和复制的例子,比如下面这个,判断 a 和 b 是否相等的 if 语句:
if a == b:
...
再比如第二个例子,这里 l2 就是 l1 的拷贝。
l1 = [1, 2, 3]
l2 = list(l1)
但你可能并不清楚,这些语句的背后发生了什么。比如,
l2 是 l1 的浅拷贝(shallow copy)还是深度拷贝(deep copy)呢?
a == b是比较两个对象的值相等,还是两个对象完全相等呢?
关于这些的种种知识,我希望通过这节课的学习,让你有个全面的了解。

'==' VS 'is'

等于(==)和 is 是 Python 中对象比较常用的两种方式。简单来说,'=='操作符比较对象之间的值是否相等,比如下面的例子,表示比较变量 a 和 b 所指向的值是否相等。
a == b
'is'操作符比较的是对象的身份标识是否相等,即它们是否是同一个对象,是否指向同一个内存地址。
在 Python 中,每个对象的身份标识,都能通过函数 id(object) 获得。因此,'is'操作符,相当于比较对象之间的 ID 是否相等,我们来看下面的例子:
a = 10
b = 10
a == b
True
id(a)
4427562448
id(b)
4427562448
a is b
True
这里,首先 Python 会为 10 这个值开辟一块内存,然后变量 a 和 b 同时指向这块内存区域,即 a 和 b 都是指向 10 这个变量,因此 a 和 b 的值相等,id 也相等,a == ba is b都返回 True。
取消
完成
0/1000字
划线
笔记
复制
© 版权归极客邦科技所有,未经许可不得传播售卖。 页面已增加防盗追踪,如有侵权极客邦将依法追究其法律责任。
该试读文章来自付费专栏《Python核心技术与实战》,如需阅读全部文章,
请订阅文章所属专栏。
立即订阅
登录 后留言

精选留言(48)

  • Jingxiao 置顶
    关于思考题:
    SCAR说的很对,程序会报错:'RecursionError: maximum recursion depth exceeded in comparison'。因为x是一个无限嵌套的列表,y深度拷贝x也是一个无限嵌套的列表,理论上x==y应该返回True,但是x==y内部执行是会递归遍历列表x和y中每一个元素的值,由于x和y是无限嵌套的,因此会stack overflow,报错
    2019-06-17
    22
  • SCAR
    应该会出错,因为x是一个无限嵌套的列表,y深拷贝于x,按道理来讲 x == y应该是True的,但进行比较操作符“==”的时候,'=='操作符则会递归地遍历对象的所有值,并逐一比较。而python为了防止栈崩溃,递归的层数是要限定的,不会无休下去,所以到了限定的层数,python解释器会跳出错误。执行了一下代码,也的确是跳出了 RecursionError: maximum recursion depth exceeded in comparison。
    之前课中做阶乘的例子,如果大于一定的整数,也是会出现递归错误,究其原因也是python的递归层数是有限定的。
    def factorial(n):
        return 1 if n <=1 else n*factorial(n-1)
    factorial(5000)
    RecursionError: maximum recursion depth exceeded in comparison
    在sys模块中有个方法可以得到递归的层数:
    import sys
    sys.getrecursionlimit()
    3000
    当然你也可以重新设定递归的层数:
    sys.setrecursionlimit(10000)
    那是不是可以设定无穷大呢?理论上可以,但你的程序崩溃也是一定的,我的mac内存是16G,如果把递归层数设定到1百万,大概跑到35000层左右,我的服务就挂了。
    2019-06-12
    70
  • yshan
    浅拷贝,不可变的不可变,可变的依旧可变
    深拷贝,都不可变
    2019-06-12
    26
  • hlz-123
    # 以下命令的输出是?
    x == y
    1. 出现如下错误信息,推测原因是x与y的列表进行一项一项比较,因无限嵌套,导致递归深度失败。
       RecursionError: maximum recursion depth exceeded in comparison
    2. 两个问题,需要老师解答
        既然是无限嵌套,为什么x.append(x)没有报错?
        运行len(x),结果为2,更是不可理解
      
    2019-06-12
    1
    11
  • Jason
    x.append(x)为什么会产生无限嵌套的列表呢?
    2019-06-12
    2
    9
  • 张丽娜
    a = 257
    b = 257
    print(id(a))
    print(id(b))
    在pycharm中运行结果中一致
    2019-06-12
    4
    9
  • 🍎🍎
    小结:
    1. ‘==’ 用于比较值的大小,‘is’用于比较对象的内存地址是否相同,指向同一个内存地址

    2. 对与整数型,范围在(-5 ~ 256 )之间的整形数,‘==’ 与 ‘is’ 结果相同,原因在于python建立了一个数组缓存,创建对象时直接引用缓存

    3. 浅拷贝:定义:重新分配一片内存,生成新的对象,里面的元素是原对象中子对象的引用。
                      生成方法: 可以通过数据构造器(list、set)完成浅拷贝,对于可变序列可以使用切片完成浅拷贝,对于元组而言,tupletuple()和切片不创建浅拷贝,指向相同元组的引用,还可以使用import copy, 使用copy.copy()来进行浅拷贝。
                    浅拷贝是对元素的引用,所以对于子对象,如果子对象是不可变,没有影响,如果是可变的序列,会带来一些影响

    4. 深拷贝,重新分配一块内存,创建一个新的对象,将原对象中的元素以递归的方式全部拷贝。深拷贝中会维持一个字典,记录已经拷贝的对象以及对象的ID,防止出现无限递归。

    作者回复: 笔记做的很好

    2019-06-20
    3
  • 瞳梦
    这节没讲好,其实可以简单归纳的:
    一、赋值:

    在 Python 中,对象的赋值就是简单的对象引用,这点和 C++不同

     

    二、浅拷贝(shallow copy):

     

    浅拷贝会创建新对象,其内容非原对象本身的引用,而是原对象内第一层对象的引用。浅拷贝有三种形式:切片操作、工厂函数、copy 模块中的 copy 函数。


    三、深拷贝(deep copy):

    深拷贝只有一种形式,copy 模块中的 deepcopy()函数。深拷贝和浅拷贝对应,深拷贝拷贝了对象的所有元素,包括多层嵌套的元素。因此,它的时间和空间开销要高。


    四、拷贝的注意点:

     

    1、对于非容器类型,如数字、字符,以及其他的“原子”类型,没有拷贝一说,产生的都是原对象的引用。
    2、如果元组变量值包含原子类型对象,即使采用了深拷贝,也只能得到浅拷贝。
    2019-07-08
    2
  • Dynasterran
    没看源码,猜的:
    1. 为什么 len(x) 是 2。
    >> x = [1]
    >> id(x)
    4378931848
    >> x.append(x)
    >> id(x)
    4378931848
    >> id(x[0])
    4304870656
    >> id(x[1])
    4378931848
    >> x[1] is x
    True
    >> len(x)
    2

    2. 为什么 x == y 会报错。
    ‘==’ 搜到 x[1] 时发现 x[1] 指向一个列表 x',又去遍历这个列表 x' 的每个值,然后发现这个列表里的 x'[1] 又指向一个列表 x'', ... 实际上 x, x', x'' 都是同一个,无限循环。
    2019-06-18
    2
  • 明月
    我的x超过256的还是is或者==为true 不知道是不是版本和机器的原因 我的是python3.5.3
    2019-06-12
    1
    2
  • pyhhou
    思考题:
    一开始猜想是 print True,因为当 x append 自身的时候,程序是没有报错的,返回的结果是:[1, [...]],我想程序既然没有报错,则 [...] 表示的应该是对应的一个最大限度的值,只是这里它没有将其表示出来;当我们 deepcopy 的时候 y 获得了同样的结果,表示深度拷贝成功;用 == 来比较两个 list 其实是比较里面的值是否相等,所以应该返回 True。

    当然尝试的结果是报错 “RecursionError: maximum recursion depth exceeded in comparison”,我想应该是内部的比较函数递归比较的时候递归深度过长,也就是列表的递归嵌套超过了其限度
    2019-06-12
    2
  • 小池
    x.append(x)会产生递归是因为list对象的append方法本质上是在list末尾追加x的引用,而不是直接添加x指向的实例。但为什么这样不会报栈溢出呢?请问老师,python支持[1, [...]]这种写法的机制是什么?
    2019-06-28
    1
  • lllong33
    两个注意点,
    a,b = 257,257 这种写法,引用的同一个地址,a is b 返回True,猜想是由于内部优化了,

    深拷贝中,对不可变的元素,会直接引用
    import copy
    l1 = [[1,2],(3,4),[257,258]]
    l2 = copy.deepcopy(l1)
    print([id(i) for i in l1], [id(i) for i in l2], , sep='\n')
    print([id(i) for j in l1 for i in j], [id(i) for j in l2 for i in j], sep='\n') # 这里地址都相同
    2019-06-20
    1
  • Jon徐
    a = 258
    b = 258
    在python解释器中使用id查看确实内存地址不同,但是使用vs code同样也是python解释器,内存地址是相同的。

    思考题中 x 是循环嵌套的列表,比较时超过了递归限制报错
    2019-06-12
    1
  • Hoo-Ah
    使用列表append自身的时候,没有报递归深度达到最大值的错误,然后我看了list类append方法的源码,里面有这句话Note: new_allocated won't overflow because the largest possible value is PY_SSIZE_T_MAX * (9 / 8) + 6 which always fits in a size_t. 翻译过来就是新的重载方法不会溢出。使用深拷贝也不会溢出,看源码没看懂。出现错误的原因是因为使用了“==”操作符,因为该操作符会递归的比较里面的值。
    2019-06-12
    1
  • KaitoShy
    有几个问题:
    1)a = 257
    b = 257
    print(id(a))
    print(id(b))
    ---------
    4526886832
    4526886832 这个和环境有关么?我用VsCode编辑运行和jupter运行的结果不一致。juterNotebook返回的不一样的
    2019-06-12
    4
    1
  • farFlight
    deepcopy创建一个新的对象,并且将原对象中的元素,以递归的方式,通过创建新的子对象拷贝到新对象中。因此'x == y'会无限递归对比,出现stack overflow。

    实际运行:
    x == y
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    RecursionError: maximum recursion depth exceeded in comparison
    2019-06-12
    1
  • Paul Shan
    python里的比较分为比较内容(==) , 和比较地址(is).
    拷贝分为浅拷贝和深拷贝。浅拷贝只是把对象第一层的引用拷贝了一遍。深拷贝则遍历整个对象图,把所有的引用都拷贝出来,同时拷贝过的对象不会再次处理。
    2019-11-15
  • Paul Shan
    思考题
    原以为结果是ture, 毕竟 is 必定相等。
    结果试验了一下
    RecursionError: maximum recursion depth exceeded in comparison
    Python 是不会检查是否已经引用同一对象了
    2019-11-15
  • mercy
    思考题:我用浅拷贝,并不会出现深拷贝的问题。为什么,明明都是无限递归
    2019-11-12
收起评论
48
返回
顶部