NumPy科学计算库学习_006_NumPy数组的复制和视图

引入模块

import numpy as np

什么是浅拷贝？

浅拷贝会在内存中产生不同对象，但由于拷贝的是父对象，子对象并没有拷贝，所以浅拷贝会存在共享内存的情况，实际上，NumPy的视图np_arr.view()是一种浅拷贝。

什么是深拷贝？

通过深拷贝np.copy()得到的变量互不干扰，其中一个变量改变时，不影响其他变量的值。

完全没有被复制

import numpy as np
a = np.random.randint(0,10,size=(2,3))
b = a
print("【a】\n",a)
print("【b】\n",b)
print("【a is b】\n",a is b,"(a和b是两个不同变量，但是对应相同的内存对象)")
b[0,0] = 1024
print("【修改b的一个元素】\n","a:",a,"\n","b:",b,"\n【结论】\n","NumPy数组中，将a赋值给b后，由于a、b指向的内存地址相同，修改b的值的时候a的值也会被修改。")

【a】
 [[6 8 9]
 [9 7 2]]
【b】
 [[6 8 9]
 [9 7 2]]
【a is b】
 True (a和b是两个不同变量，但是对应相同的内存地址对象)
【修改b的一个元素】
 a: [[1024    8    9]
 [   9    7    2]] 
 b: [[1024    8    9]
 [   9    7    2]] 
【结论】
 NumPy数组中，将a赋值给b后，由于a、b指向的内存地址相同，修改b的值的时候a的值也会被修改。

通过视图实现浅拷贝

a = np.random.randint(0,10,size=(2,3))
b = a.view() # a与b此时共享视图、叫浅拷贝
print("【a】\n",a)
print("【b】\n",b,"(使用a中的数据创建了一个新的数组对象)")
print("【a is b】\n",a is b)
print("【b.base is a】\n",b.base is a)
print("【a.flags.owndata】\n",a.flags.owndata)
print("【b.flags.owndata】\n",b.flags.owndata)
b[0,0]=1024
print("【修改b的一个元素】\n","a:",a,"\n","b:",b)

【a】
 [[0 0 1]
 [4 3 8]]
【b】
 [[0 0 1]
 [4 3 8]] (使用a中的数据创建了一个新的数组对象)
【a is b】
 False
【b.base is a】
 True
【a.flags.owndata】
 True
【b.flags.owndata】
 False
【修改b的一个元素】
 a: [[1024    0    1]
 [   4    3    8]] 
 b: [[1024    0    1]
 [   4    3    8]]

深拷贝

a = np.arange(1e8) # 这里[0~1e8]
print("【a】(这是一个超长数组)\n",a)
print("【长度】\n",a.size)
print("===【深拷贝的基本应用】===")
b_simple = a.copy()
print("【b_simple】\n",b_simple)
print("===【深拷贝的特殊应用】===")
b_save_memory = a[::10000000].copy()
del a # 删除占用大量内存的a数组
print("【b_save_memory】(从a中的每1千万中取一个数)\n",b_save_memory)

【a】(这是一个超长数组)
 [0.0000000e+00 1.0000000e+00 2.0000000e+00 ... 9.9999997e+07 9.9999998e+07
 9.9999999e+07]
【长度】
 100000000
===【深拷贝的基本应用】===
【b_simple】
 [0.0000000e+00 1.0000000e+00 2.0000000e+00 ... 9.9999997e+07 9.9999998e+07
 9.9999999e+07]
===【深拷贝的特殊应用】===
【b_save_memory】(从a中的每1千万中取一个数)
 [       0. 10000000. 20000000. 30000000. 40000000. 50000000. 60000000.
 70000000. 80000000. 90000000.]