Python那些让我疑惑许久的代码

阳光穿透心脏的1/2处 2022-12-03 09:12 135阅读 0赞

### Python那些让我疑惑许久的代码 ###

*  疑惑代码1
 *   *  疑惑点
     *  解决疑惑点
     *   *  a, b = a\[b\] = \{\}, 5的执行流程是怎样的?
         *  为什么会出现\{....\}
         *  结果是怎么来的
 *  疑惑代码2
 *   *  疑惑点
     *  解决疑惑点
     *   *  \+和+=有什么区别
         *  二者的效率一样吗

# 疑惑代码1 #

a, b = a[b] = { }, 5
    print(a)  # {5: ({...}, 5)}
    print(b)  # 5

## 疑惑点 ##

*  a, b = a\[b\] = \{\}, 5的执行流程是怎样的?
 *  为什么会出现\{…\}
 *  结果是怎么来的

## 解决疑惑点 ##

### a, b = a\[b\] = \{\}, 5的执行流程是怎样的? ###

**官方文档中关于赋值语句的形式:**

(target_list "=")+ (expression_list | yield_expression)

**个人翻译等式应该是这样:  
目标列表=多个计算表达式列表  
按照列表赋值的方式,则应该是表达式运算完后依次从左到右赋值给目标列表**  
**现在知道了列表赋值从左到右,但是却不知道\{\},5是先赋值给a,b还是a\[b\]**  
我们可以通过下面这个案例来说明\{\},5到底先赋值给谁

lst=[]
    x=1
    lst=lst[len(lst):] = lst[len(lst):] = [x]
    print(lst)

**我们这里可以先假设lst=lst\[len(lst):\] = lst\[len(lst):\] = \[x\]是从右往左开始赋值的**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center]  
**但是真实输出的答案为:**  
![在这里插入图片描述][2020090220161279.png_pic_center]  
**所以我们在进行另一个假设:lst=lst\[len(lst):\] = lst\[len(lst):\] = \[x\]是从左往右开始赋值的**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center 1]  
???为什么是\[1,1,1\],那\[1,1,1,1\]到底怎么来的,反复看上面的图,和赋值表达式,唯一能证实的就是

S=[x]
    S1=S
    S2=S

**这样运算才能获取\[1,1,1,1\],从而证实了python中如果存在多个目标时,会先将运算表达式赋值给最左边的目标,然后得到的结果分别赋值给其他目标**

a,b=c=d=1,2
    print(a,b)
    print(c)
    print(d)

![在这里插入图片描述][20200902203429901.png_pic_center]  
通过上面的分析我们可以得到 "a, b = a\[b\] = \{\}, 5的执行流程是怎样的?"的答案了

1.a={ },b=5
    2.a[b]=a,b

### 为什么会出现\{…\} ###

\*\*现在我们已经知道a\[b\]=a,b  
那为什么会出现\{…\},\{…\}这个又是什么东西?  
可以简单看个小案例

lst=lst[0]=[0]
    print(lst)	//[[...]]

其实\[\[…\]\]指的是与 lst 引用了相同的对象。\*\*及lst\[0\] is lst,当引用的相同的对象时,Python就会打印出\[…\]  
由与a\[b\]=a,b,a\[b\]中的a和a,b中的a是相同的对象,所以则会导致出现\{…\},这种现象

### 结果是怎么来的 ###

解决上面二个问题这个问题就很容易解决了

1.a,b={ },5
    2.a={ },b=5
    3.a[b]={ },5
    4.a[5]=({ ....},5)

# 疑惑代码2 #

a=[1,2,3]
    a+=[4,5,6]
    a=a+[7,8,9]
    print(a) //[1, 2, 3, 4, 5, 6, 7, 8, 9]

## 疑惑点 ##

*  \+和+=有什么区别
 *  二者的效率一样吗

## 解决疑惑点 ##

### \+和+=有什么区别 ###

**在python的内存机制中,当不可变对象改变了原有的值,其别名绑定到了新值上面,id肯定会改变  
\+和+=的区别可以从可变对象和不可变对象说起  
对于+号操作，可变对象和不可变对象调用的都是\_\_add\_\_操作  
对于+=号操作，可变对象调用\_\_add\_\_，不可变对象调用的是\_\_iadd\_\_(不可变对象没有\_\_iadd\_\_) \_\_iadd\_\_是原地修改**  
**在列表中+号则是一个特例**  
因为python中列表使用+的时候,等价于list.extend(list2),所以列表的另一个操作数必须是列表

### 二者的效率一样吗 ###

import timeit
    print(timeit.timeit("a = a + b + c", setup="a='a'*10000;b='b'*10000;c='c'*10000", number=100))
    print(timeit.timeit("a += b + c", setup="a='a'*10000;b='b'*10000;c='c'*10000", number=100))

![在这里插入图片描述][2020090221034292.png_pic_center]

可以看出+=的效率明显高于+,但是二者效率的比较还是存在质疑  
我们先从其机械指令来看为什么?

import dis
    def fun():
        a = 1
        b = 2
        a = a + b
        a += b
    
    dis.dis(fun)

结果:

3           0 LOAD_CONST               1 (1)
                  2 STORE_FAST               0 (a)
    
      4           4 LOAD_CONST               2 (2)
                  6 STORE_FAST               1 (b)
    
      5           8 LOAD_FAST                0 (a)
                 10 LOAD_FAST                1 (b)
                 12 BINARY_ADD
                 14 STORE_FAST               0 (a)
    
      6          16 LOAD_FAST                0 (a)
                 18 LOAD_FAST                1 (b)
                 20 INPLACE_ADD
                 22 STORE_FAST               0 (a)
                 24 LOAD_CONST               0 (None)
                 26 RETURN_VALUE

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center 2]

二者唯一区别在于BINARY\_ADD与INPLACE\_ADD,从现在看出+=的效率高一些只能说明INPLACE\_ADD效率总是不低于BINARY\_ADD,但是未必a+=b 比 a=a+b快  
1.JIT影响，很可能二者最终是相同的机器指令，就是一模一样  
2.例子中int是immutable， INPLACE\_ADD未必真正意义的inplace,否则就破坏了int immutable原则，至少能确定不论哪种方式加，每加一次a的内存地址变一次，a新分配地址是整个过程最大的开销(加逻辑计算可以忽略)，在大量执行的情况下，二者应该开销基本一致，都是a内存分配开销  
而且作者在莫论坛看到  
![在这里插入图片描述][20200902211305607.png_pic_center]  
所以a+=b和a=a+b在效率方面可能还是存在可变因素

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/7f6d72795a15425096893d9badd3b8fc.png
[2020090220161279.png_pic_center]: /images/20221123/ae0eedb3fd2247778c880333416f86db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/d881a40c929b4be3a59d1bb15041af11.png
[20200902203429901.png_pic_center]: /images/20221123/288f98ca0272470e86a531de3d4f79d9.png
[2020090221034292.png_pic_center]: /images/20221123/a04b708347e54d399cb6b0f14dd338d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/b8bdcdd12e8c4882b99b9393cab28aaf.png
[20200902211305607.png_pic_center]: /images/20221123/41fc5dba4f6441e9b165376b81a52bda.png