2.5 深拷贝、浅拷贝与不拷贝

话不多说，先上图！

 （其实和面向对象那里的对象的不拷贝、浅拷贝和深拷贝类似）

2.5.1 不拷贝

就是直接赋值，a和b指向的地址是一样的。

import numpy as np
a = np.arange(1, 33).reshape(4, 8)
b = a
print(a is b)  # 结果为：True
print(id(a))  # 结果为：2322353337136
print(id(b))  # 结果为：2322353337136
# 发现a和b的id值是一样的，也就是指向一个地址

2.5.2 浅拷贝

利用view()函数进行强制浅拷贝。（浅拷贝，虽然是不同的变量但是共用一个地址！）

import numpy as np
a1 = np.arange(1, 33).reshape(4, 8)
b1 = a1.view()
print(a1)
print(b1)
print("修改(0,0)位置上元素的值（也就是a1[0][0]的值）：")
a1[0, 0] = 100
print(a1)
print(b1)
"""
结果为：
[[ 1  2  3  4  5  6  7  8]
 [ 9 10 11 12 13 14 15 16]
 [17 18 19 20 21 22 23 24]
 [25 26 27 28 29 30 31 32]]
[[ 1  2  3  4  5  6  7  8]
 [ 9 10 11 12 13 14 15 16]
 [17 18 19 20 21 22 23 24]
 [25 26 27 28 29 30 31 32]]
修改(0,0)位置上元素的值（也就是a1[0][0]的值）：
[[100   2   3   4   5   6   7   8]
 [  9  10  11  12  13  14  15  16]
 [ 17  18  19  20  21  22  23  24]
 [ 25  26  27  28  29  30  31  32]]
[[100   2   3   4   5   6   7   8]
 [  9  10  11  12  13  14  15  16]
 [ 17  18  19  20  21  22  23  24]
 [ 25  26  27  28  29  30  31  32]]
"""
# 可以发现，a1的(0,0)位置上的元素改变了，b1的也会改变，所以a1与b1共用一个地址！

2.5.3 深拷贝

利用copy()函数进行强制深拷贝。（深拷贝，就是重新开辟地址创造了新变量，新变量用新地址，不会再和被拷贝（就变量）用一个地址！）

a2 = np.arange(1, 33).reshape(4, 8)
b2 = a2.copy()
print(a2)
print(b2)
print("修改变量后")
a2[0, 0] = 100
print(a2)
print(b2)
"""
结果为：
[[ 1  2  3  4  5  6  7  8]
 [ 9 10 11 12 13 14 15 16]
 [17 18 19 20 21 22 23 24]
 [25 26 27 28 29 30 31 32]]
[[ 1  2  3  4  5  6  7  8]
 [ 9 10 11 12 13 14 15 16]
 [17 18 19 20 21 22 23 24]
 [25 26 27 28 29 30 31 32]]
修改变量后
[[100   2   3   4   5   6   7   8]
 [  9  10  11  12  13  14  15  16]
 [ 17  18  19  20  21  22  23  24]
 [ 25  26  27  28  29  30  31  32]]
[[ 1  2  3  4  5  6  7  8]
 [ 9 10 11 12 13 14 15 16]
 [17 18 19 20 21 22 23 24]
 [25 26 27 28 29 30 31 32]]
"""
# a2变了，b2没变！所以b2是开辟了新地址的！