python3 完全理解赋值，浅copy,深copy 通过地址详细理解~

额。。。老规矩，先来一天NLP再说，也没几条了。

十，在任何一个系统里，最灵活的部分是最能影响大局的部分

灵活便是有一个以上的选择，选择便是能力，因此最灵活的人便是最有能力的人。

灵活来自减少只相信自己的一套信念，价值和规条，而多凭借观察运用环境所提供的其他条件。

灵活是使事情更快有效的的重要因素，因此，亦是人生成功快乐的重要因素。

灵活亦是自信的表现，自信越不足，坚持某个模式的态度会越强硬。

容许不同的意见和可能性，便是灵活。

在一个群体中，固执使人紧张，灵活使人放松。

灵活不代表放弃自己的立场，而是容许找出双赢的可能性（更进一步而三赢）。

在沟通中，明白人不代表接受，接受不代表投降（放弃立场）。

“流水”是学习灵活的老师。

灵活是用自己的步伐去做出转变，而固执则是在被压迫的情况下做出转变。

---

赋值，以及深浅copy的理解

赋值的时候，是把内容的地址给这个变量，内容是不可变数据类型，如 int, str, bool, tuple,时，一个值对应一个固定的地址。

但是如果内容是可变数据类型时，如list,dict,set的时候，拿列表来举例子 ： 列表整体有个地址，他是可以变化的，即两个长得一样的列表，他们整体的地址可以不同。

然后这个整体的列表地址对应的是列表各个内容，即各个元素所对应的各自的地址，比如其中一个内容是一个数字，数字是不可变类型数据，其地址是固定的一个值，如果是一个嵌套的列表，那就是再来一次整体可变地址指向内容地址。

实验结果如下：

 #!usr/bin/env/ python
 # -*- coding:utf-8 -*-
 # Author: XiaoFeng
 import copy
 # 赋值  对于不可变数据类型，赋值就是相当于把数据的地址复制给变量
 a = "abc"     # ”abc“的地址给a
 b = a         # a所存的内容，即“abc"的地址复制给b
 c = a         # a所存的内容，即"abc"的地址复制给c
 print(a, id(a))
 print(b, id(b))
 print(c, id(c))
 c = ""      # "32”的地址给c
 print(a, b, c, id(a), id(b), id(c))
 # 对于可变数据类型，赋值也是相当于把数据的地址复制给变量
 a = [1, 2, 3]    # 把列表的地址给a
 b = a            # 把a的内容，即列表的地址复制给b
 c = a            # 把a的内容，即列表的地址复制给c
 print(a, id(a))
 print(b, id(b))
 print(c, id(c))
 c.append("别人会变吗？")    # 从c得到列表的地址，找到列表，然后更改列表的内容
 print(a, b, c, id(a), id(b), id(c))   # 结果当然就变喽
 # 浅copy
 li = [1000, "sa"*30, 3, [12]]      # 把列表的每一个元素的地址组合成一个列表，然后把这个列表的地址给li
 li2 = li.copy()         # 复制原列表的元素的地址，然后组合成一个新的列表，再把这个新列表的地址给li2
 li2[3].append("嵌套的会变吗？")  # 会的，因为里层元素的地址没变
 li2.append("会变吗？")      # 不会，因为新列表最外层是新的地址了
 print(li, id(li), id(li[1]), id(3))
 print(li2, id(li2), id(li2[1]), id(3))
 # 深copy
 li = [10000, "q", ["", 9], 7]
 li2 = copy.deepcopy(li)
 print(li, id(li), id(li[0]), id(li[2]))
 print(li2, id(li2), id(li2[0]), id(li2[2]))   # 哈哈，果然嵌套得列表地址不一样了
 li[2].append(1000)
 print(li, li2, id(li[2]), id(li2[2]))  # 成功！
 # 来试个嵌套嵌套
 li = [1, [2, [3]]]
 li2 = copy.deepcopy(li)
 print(li, id(li[1][1]), li2, id(li2[1][1]))    # 地址很像，但不一样了，差点看错。。。估计是迭代的把所有可变类型的数据给了新地址
 li[1][1].append("会变吗")
 print(li, id(li[1][1]), li2, id(li2[1][1]))     # 假设成功，神奇啊 哈哈哈哈

运行结果如下：

E:\Python\python.exe E:/python_code_dir/Python_hight/Day_11/copy_test.py
abc 12768896
abc 12768896
abc 12768896
abc abc 32 12768896 12768896 49285504
[1, 2, 3] 12404176
[1, 2, 3] 12404176
[1, 2, 3] 12404176
[1, 2, 3, '别人会变吗？'] [1, 2, 3, '别人会变吗？'] [1, 2, 3, '别人会变吗？'] 12404176 12404176 12404176
[1000, 'sasasasasasasasasasasasasasasasasasasasasasasasasasasasasasa', 3, [12, '嵌套的会变吗？']] 86211600 13259224 1360779472
[1000, 'sasasasasasasasasasasasasasasasasasasasasasasasasasasasasasa', 3, [12, '嵌套的会变吗？'], '会变吗？'] 12825984 13259224 1360779472
[10000, 'q', ['', 9], 7] 12805984 86039520 86150280
[10000, 'q', ['', 9], 7] 86211600 86039520 12827144
[10000, 'q', ['', 9, 1000], 7] [10000, 'q', ['', 9], 7] 86150280 12827144
[1, [2, [3]]] 12825984 [1, [2, [3]]] 12827184
[1, [2, [3, '会变吗']]] 12825984 [1, [2, [3]]] 12827184

Process finished with exit code 0

还有一个数字符串里有多少数字的代码：

 #!usr/bin/env/ python
 # -*- coding:utf-8 -*-
 # Author: XiaoFeng

 # 找字符串里有多少个数
 o = -2
 count = 0
 x = input("<<<").strip()
 for index, i in enumerate(x):
     print(x)
     if i.isalpha():
         continue
     if i.isdigit() and index == o + 1:
         o = index
     else:
         count += 1
         o = index
 print(count)
 # 升级版：
 args = input("<<<:").strip()
 for i in args:
     print(args)
     if i.isalpha():
         args = args.replace(i, " ")  # 用空格替换字母 这里的args 变了 但是改的是已经被i接收了的位 没改后面的，所以对后面没影响
 final_list = args.split()   # 默认以任意数量空格来分割成列表
 print(len(final_list))