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"      # "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", ["6", 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:Pythonpython.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', ['6', 9], 7] 12805984 86039520 86150280
[10000, 'q', ['6', 9], 7] 86211600 86039520 12827144
[10000, 'q', ['6', 9, 1000], 7] [10000, 'q', ['6', 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))