清醒、自律、知进退、爱自己！

2.浅Copy与深Copy

引用、浅拷贝和深拷贝的区别

lst=[1,2,3,4]
lst1=lst # 同一个对象，指向同一个东西
lst2=lst.copy() # 内容相同，不同的对象，遇到引用类型不会复制对象，只会复制地址
lst3=copy.deepcopy(lst) # 内容相同，但不同的对象，如果有引用类型也会复制出不同的对象

浅拷贝：影子拷贝；为了解决函数传递后被修改的问题，就需要拷贝一份副本，将副本传递给函数使用，就算是副本被修改，也不会影响原始数据 。

深拷贝：深拷贝使复制过程递归。这意味着首先构造一个新的集合对象，然后递归地用在原始对象中找到的子对象的副本填充它。以这种方式复制一个对象，遍历整个对象树，以创建原始对象及其所有子对象的完全独立的克隆。

数据拷贝会涉及到Python中对象、可变类型、引用这3个概念，先来看看这几个概念，只有明白了他们才能更好的理解深拷贝与浅拷贝到底是怎么一回事。

2.1** Python对象**都拥有三个属性：身份、类型、值。

In [2]: id(name)  # id:身份的唯一标识
Out[2]: 1698668550104
In [3]: type(name) # type:对象的类型，决定了该对象可以保存什么类型的值
Out[3]: str
In [4]: name  # 对象的值，表示的数据
Out[4]: 'laowang'

可变与不可变对象

可变对象： 列表、字典、集合

所谓可变是指可变对象的值可变，身份是不变的。

不可变对象：数字、字符串、元组

不可变对象就是对象的身份和值都不可变。新创建的对象被关联到原来的变量名，旧对象被丢弃，垃圾回收器会在适当的时机回收这些对象。

引用=id()

引用实际就是内存中的一个数字地址编号，在使用对象时，只要知道这个对象的地址，就可以操作这个对象，但是因为这个数字地址不方便在开发时使用和记忆，所以使用变量名的形式来代替对象的数字地址。 在 Python 中，变量就是地址的一种表示形式，并不开辟开辟存储空间

不可变对象的拷贝

不可变对象只在修改的时候才会在内存中开辟新的空间， 而拷贝实际上是让多个对象同时指向一个引用，和对象的赋值没区别。

In [11]: import copy
In [12]: a = 10
In [13]: b = copy.copy(a)
In [14]: id(a)
Out[14]: 1730306496
In [15]: id(b)
Out[15]: 1730306496

可变对象的拷贝

可变对象的拷贝，会在内存中开辟一个新的空间来保存拷贝的数据。当再改变之前的对象时，对拷贝之后的对象没有任何影响。

In [25]: l1 = [1, 2, 3]
In [26]: l2 = copy.copy(l1)
In [27]: id(l1)
Out[27]: 1916631742088
In [28]: id(l2)
Out[28]: 1916636282952
In [29]: l1[0] = 11
In [30]: id(l1)
Out[30]: 1916631742088
In [31]: id(l2)
Out[31]: 1916636282952

同样的，通过一个实例来感受一下：不难看出，a与b指向相同的引用，不可变对象的拷贝就是对象赋值。

复杂对象在拷贝时，并没有解决数据在传递之后，数据改变的问题。 出现这种原因，是copy() 函数在拷贝对象时，只是将指定对象中的所有引用拷贝了一份，如果这些引用当中包含了一个可变对象的话，那么数据还是会被改变。 这种拷贝方式，称为浅拷贝。

深拷贝——解决原始数据改变的问题

区别于浅拷贝只拷贝顶层引用，深拷贝会逐层进行拷贝，直到拷贝的所有引用都是不可变引用为止。

l1 = [3, 4, a]
In [47]: l2 = copy.deepcopy(li)
In [48]: id(l1)
Out[48]: 1916632194312
In [49]: id(l2)
Out[49]: 1916634281416
In [50]: a[0] = 11
In [51]: id(l1)
Out[51]: 1916632194312
In [52]: id(l2)
Out[52]: 1916634281416
In [54]: l1
Out[54]: [3, 4, [11, 2]]
In [55]: l2
Out[55]: [1, 2, 3]

查漏补缺

1.为什么Python默认的拷贝方式是浅拷贝？
时间角度：浅拷贝花费时间更少
空间角度：浅拷贝花费内存更少
效率角度：浅拷贝只拷贝顶层数据，一般情况下比深拷贝效率高。

本文知识点总结：

1.不可变对象在赋值时会开辟新空间
2.可变对象在赋值时，修改一个的值，另一个也会发生改变
3.深、浅拷贝对不可变对象拷贝时，不开辟新空间，相当于赋值操作
4.浅拷贝在拷贝时，只拷贝第一层中的引用，如果元素是可变对象，并且被修改，那么拷贝的对象也会发生变化
5.深拷贝在拷贝时，会逐层进行拷贝，直到所有的引用都是不可变对象为止。
6.Python 中有多种方式实现浅拷贝，copy模块的copy 函数 ，对象的 copy 函数 ，工厂方法，切片等。
7.大多数情况下，编写程序时，都是使用浅拷贝，除非有特定的需求
8.浅拷贝的优点：拷贝速度快，占用空间少，拷贝效率高

深度解读Python深拷贝与浅拷贝问题

Python中的random模块（假随机）

Python中的random模块用于生成随机数。下面介绍一下random模块中最常用的几个函数。

1. random.random # random.random()用于生成一个0到1的随机符点数: 0 <= n < 1.0

代码如下(生成随机浮点数):
>>> import random
>>> random.random()
0.85415370477785668

2. random.uniform

random.uniform的函数原型为：random.uniform(a, b)，用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。如果a > b，则生成的随机数n: a <= n <= b。如果 a <b， 则 b <= n <= a。

代码：
print random.uniform(10, 20)
print random.uniform(20, 10)
# 18.7356606526
# 12.5798298022  

>>> random.uniform(1, 10)
5.4221167969800881

3. random.randint [a,b]

代码：
print random.randint(12, 20)  
# 生成的随机数 n: 12 <= n <= 20


print random.randint(20, 20)  
# 结果永远是20     

# print random.randint(20, 10)  
# 该语句是错误的，下限必须小于上限
>>> import random
>>> random.randint(0,99)
21

4. random.randrange [a , b)

random.randrange的函数原型为：
步长：random.randrange(10, 100, 2)，结果相当于从[10, 12, 14, 16, ... 96, 98]序列中获取一个随机数。
random.randrange(10, 100, 2)在结果上与 random.choice(range(10, 100, 2) 等效。

代码如下:
>>> import random
>>> random.randrange(0, 100, 2)
60

#randomint 与 randrange的差别在于
randrange可以设置步长；

5. random.choice

random.choice从序列中获取一个随机元素。其函数原型为：random.choice(sequence)。参数sequence表示一个有序类型。这里要说明 一下：sequence在python不是一种特定的类型，而是泛指一系列的类型。list, tuple, 字符串都属于sequence。有关sequence可以查看python手册数据模型这一章。下面是使用choice的一些例子：

代码：
print random.choice("学习Python")
print random.choice(["JGood", "is", "a", "handsome", "boy"])
print random.choice(("Tuple", "List", "Dict"))  

>>> import random
>>> random.choice ( ['apple', 'pear', 'peach', 'orange', 'lemon'] )
'orange'

6.random.shuffle 就地修改

random.shuffle(x[, random])，用于将一个列表中的元素打乱。如:

代码如下:
>>> import random
>>> p = ["Python", "is", "powerful", "simple", "and so on..."]
>>> random.shuffle(p)
>>> print (p)
['simple', 'is', 'powerful', 'Python', 'and so on...']

7. random.sample

random.sample(sequence, k)，从指定序列中随机获取指定长度的片断。sample函数不会修改原有序列

代码如下:
list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
slice = random.sample(list, 5)  # 从list中随机获取5个元素，作为一个片断返回
print slice
print list  # 原有序列并没有改变

>>> import random
>>> random.sample('abcdefghij', 3)
['h', 'g', 'b']