一、总结
一句话总结：
NumPy：大数据量的纯粹数组处理，以及复杂函数和线性代数等
1、numpy中创建矩阵的方法？
numpy中的数据结构主要是同构的多维数组，所以创建数组的方法主要有array和arange方法，当然还有其它的一些比如linspace等等
arr = np.array([[1,2,3],[4,5,6]])
arr = np.arange(6).reshape((2,3))
2、numpy库中创建数组方法array和asarray的区别？
array和asarray都可以将结构数据转化为ndarray，但是主要区别就是当数据源是ndarray时，【array仍然会copy出一个副本，占用新的内存，但asarray不会】
3、numpy中的特殊矩阵？
numpy中的特殊矩阵 主要有ones（全1）、zeros（全0）、eye（单位矩阵）、empty（未初始化）
np.ones((3,4))
np.zeros((3,4))
np.eye(2)
np.empty((6,4))
4、numpy中的常用属性？
numpy的多维数组常用属性主要有dtype（数据类型）、ndim（维度）、shape（性状）、size（元素个数）
arr = np.arange(12).reshape((3,4))
print(arr)
# 数据类型
print(arr.dtype)
# 维数
print(arr.ndim)
# 行数和列数
print(arr.shape)
# 大小，也就是元素个数
print(arr.size)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
int32
2
(3, 4)
12
5、numpy中的基本计算？
numpy中的ndarray对象重载了许多运算符，使用这些运算符可以完成矩阵间对应元素的运算。如 +，-，*（内积），/，%，**（次方），@（矩阵阶层）
# 矩阵内积：对应位置相乘
print(arr1*arr2)
# 矩阵乘法：
print(arr1@arr2)
print(np.dot(arr1,arr2))
print(arr1.dot(arr2))
6、numpy中的常用函数？
numpy常用多维函数有sin、sqrt、sort、transpose、max、
mean（average）、sum、median（中位数）、var（方差）、std（标准差）、cumsum（累加）、
np.clip(arr,5,9)（小于5的数全部让它变成5，大于9的数全部是9）
7、numpy中axis为0为1表示的意思是什么？
axis为0表示对列进行操作，axis为1表示为行进行操作
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
# 平均数
print(arr.mean())
print(np.average(arr))
print(np.average(arr,axis=0)) # 0是列
print(np.average(arr,axis=1)) # 1是行
5.75
5.75
[4. 5. 7. 7.]
[1.5 6.25 9.5 ]
8、numpy中索引？
numpy中，可以像普通数组一样用下标来访问元素，比如a[1][1]、a[1,1]
9、numpy中访问行列元素？
a[1,:]（打印下标为1的行所有数）
a[:,1]（打印下标为1的列的所有数）
a[1,1:3]（第1行 列从1-2）
10、numpy中迭代行循环打印即可，如何迭代列？
将矩阵转置即可
# 迭代列 (转置一下即可实现)
for i in a.T:
print(i)
11、numpy中如何迭代多维数组的每一个数？
for i in a.flat: print(i)
12、numpy中数组合并？
numpy数组水平合并可以np.hstack((a,b))，类似于np.concatenate((a,b,a),axis=1)
numpy数组垂直合并可以np.vstack((a,b))，类似于np.concatenate((a,b,a),axis=0)
13、numpy中数组分割？
等量分割：水平分成两块np.split(a,2,axis=1)，vsplit和hsplit也可以等量分割
不等量分割：np.array_split(a,3,axis=1)
14、numpy中数组拷贝？
numpy 中的 copy方法是 deep copy：b = np.copy(a)
二、Numpy库使用总结
博客对应课程的视频位置：
一、numpy库概述
numpy库是做什么的
大数据量的纯粹数组处理，以及复杂函数和线性代数等
NumPy的主要对象是同构多维数组。它是一个元素表（通常是数字），所有类型都相同，由非负整数元组索引。
numpy库核心
numpy的结构是纯粹的ndarray
numpy库和pandas库的关系
NumPy：大数据量的纯粹数组处理，以及复杂函数和线性代数等 Pandas：处理非纯粹的、混杂数组
虽然NumPy有着以上的种种出色的特性，其本身则难以独支数据分析这座大厦，这是一方面是由于NumPy几乎仅专注于数组处理， 另一方面则是数据分析牵涉到的数据特性众多，需要处理各种表格和混杂数据，远非纯粹的数组（NumPy）方便解决的，而这就是pandas发力的地方。
NumPy在大数组的数据处理方面进行的优化？
- 【连续的内存块】：NumPy是在一个连续的内存块中存储数据，独立于其他Python内置对象，如此便可以加速数据索引的速度。
- 【调用大量c语言算法库】：NumPy调用了大量的用C语言编写的算法库，使得其可以直接操作内存，不必进行Python动态语言特性所含有的前期类型检查工作，从而大大提高了运算速度。
- 【整数组直接计算】：NumPy所有独有的可以在整个数组上执行复杂的计算也能够大幅提高运算效率（基于NumPy的算法要比纯Python快10到100倍，甚至会快更多）。
上百G的数据如何处理
Python处理几个G的数据绰绰有余，至于几十G也勉强可以，而上百G的数据这就算是Hadoop与Spark系列的任务，不是Python的NumPy与pandas可以应付的，也不是R语言某个第三方包可以处理的。
NumPy数组 和 原生Python Array（数组）之间有几个重要的区别
- NumPy 数组在创建时具有固定的大小，与Python的原生数组对象（可以动态增长）不同。更改ndarray的大小将创建一个新数组并删除原来的数组。
- NumPy 数组中的元素都需要具有相同的数据类型，因此在内存中的大小相同。 例外情况：Python的原生数组里包含了NumPy的对象的时候，这种情况下就允许不同大小元素的数组。
- NumPy 数组有助于对大量数据进行高级数学和其他类型的操作。通常，这些操作的执行效率更高，比使用Python原生数组的代码更少。
- 越来越多的基于Python的科学和数学软件包使用NumPy数组; 虽然这些工具通常都支持Python的原生数组作为参数，但它们在处理之前会还是会将输入的数组转换为NumPy的数组，而且也通常输出为NumPy数组。
二、创建矩阵
numpy库中创建数组方法array和asarray的区别
array和asarray都可以将结构数据转化为ndarray，但是主要区别就是当数据源是ndarray时，
【array仍然会copy出一个副本，占用新的内存，但asarray不会】
意思是对数据源进行重新赋值的话，array转化后的数据不变，asarray转化后的数据也会跟着数据源重新被赋值。
创建矩阵的方法
numpy中的数据结构主要是同构的多维数组，所以创建数组的方法主要有array和arange方法，当然还有其它的一些比如linspace等等
arr = np.array([[1,2,3],[4,5,6]])
arr = np.arange(6).reshape((2,3))
In [42]:
# 安装库
# pip install numpy
# 查看安装的库
# pip list
# 引入库
import numpy as np
1、array方法
In [4]:
# numpy的核心是n维数组，所以创建数组是array方法
arr = np.array([[1,2,3],
[4,5,6]])
print(arr)
[[1 2 3]
[4 5 6]]
In [7]:
# 指定类型
arr = np.array([1,2,3],dtype=np.int64)
print(arr)
print(arr.dtype)
[1 2 3]
int64
In [17]:
# 同构还是异构
# 原生python中
list1 = [1,True,"a",[1,23]]
print(list1)
# numpy中
arr = np.array([1,True,'a'])
print(arr)
print(arr.dtype)
# 可以看到结果里面全部转化成了字符串，也就是全部转化为了同一类型
[1, True, 'a', [1, 23]]
['1' 'True' 'a']
<U11
2、arange方法
为了创建数字组成的数组，NumPy提供了一个类似于range的函数arange，该函数返回数组而不是列表。
In [13]:
arr = np.arange(10)
print(arr)
# 指定起点和终点
arr = np.arange(10,20)
print(arr)
# 指定步长
arr = np.arange(10,20,3)
print(arr)
[0 1 2 3 4 5 6 7 8 9]
[10 11 12 13 14 15 16 17 18 19]
[10 13 16 19]
In [15]:
# reshape方法改变维数
arr = np.arange(6).reshape((2,3))
print(arr)
[[0 1 2]
[3 4 5]]
In [18]:
# 等差数列
arr = np.linspace(1,3,5)
print(arr)
print(arr.dtype)
[1. 1.5 2. 2.5 3. ]
float64
In [21]:
# 等比数列
arr = np.logspace(1,3,5)
print(arr)
print(arr.dtype)
[ 10. 31.6227766 100. 316.22776602 1000. ]
float64
三、特殊矩阵
numpy中的特殊矩阵
numpy中的特殊矩阵 主要有ones（全1）、zeros（全0）、eye（单位矩阵）、empty（未初始化）
np.ones((3,4))
np.zeros((3,4))
np.eye(2)
np.empty((6,4))
In [23]:
# 参数是一个元组，来指定行列
arr = np.ones((3,4))
print(arr)
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
In [25]:
arr = np.zeros((3,4))
print(arr)
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
In [35]:
help(np.eye)
Help on function eye in module numpy:
eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
Return a 2-D array with ones on the diagonal and zeros elsewhere.
Parameters
----------
N : int
Number of rows in the output.
M : int, optional
Number of columns in the output. If None, defaults to `N`.
k : int, optional
Index of the diagonal: 0 (the default) refers to the main diagonal,
a positive value refers to an upper diagonal, and a negative value
to a lower diagonal.
dtype : data-type, optional
Data-type of the returned array.
order : {'C', 'F'}, optional
Whether the output should be stored in row-major (C-style) or
column-major (Fortran-style) order in memory.
.. versionadded:: 1.14.0
Returns
-------
I : ndarray of shape (N,M)
An array where all elements are equal to zero, except for the `k`-th
diagonal, whose values are equal to one.
See Also
--------
identity : (almost) equivalent function
diag : diagonal 2-D array from a 1-D array specified by the user.
Examples
--------
>>> np.eye(2, dtype=int)
array([[1, 0],
[0, 1]])
>>> np.eye(3, k=1)
array([[0., 1., 0.],
[0., 0., 1.],
[0., 0., 0.]])
In [49]:
# 对角矩阵的行列肯定是一样的
arr = np.eye(2)
print(arr)
[[1. 0.]
[0. 1.]]
In [50]:
# empty为空，表示没有初始化的意思
arr1 = np.empty((6,4))
print(arr1)
[[4.624e-321 4.624e-321 4.190e-321 4.190e-321]
[2.628e-321 2.628e-321 3.992e-321 3.992e-321]
[4.585e-321 4.585e-321 4.427e-321 4.427e-321]
[5.613e-321 5.613e-321 5.652e-321 5.652e-321]
[5.454e-321 5.454e-321 2.174e-321 2.174e-321]
[5.830e-321 5.830e-321 4.466e-321 4.466e-321]]
四、常用属性
numpy的多维数组常用属性主要有dtype（数据类型）、ndim（维度）、shape（性状）、size（元素个数）
arr = np.arange(12).reshape((3,4))
print(arr)
# 数据类型
print(arr.dtype)
# 维数
print(arr.ndim)
# 行数和列数
print(arr.shape)
# 大小，也就是元素个数
print(arr.size)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
int32
2
(3, 4)
12
In [52]:
arr = np.arange(12).reshape((3,4))
print(arr)
# 数据类型
print(arr.dtype)
# 维数
print(arr.ndim)
# 行数和列数
print(arr.shape)
# 大小，也就是元素个数
print(arr.size)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
int32
2
(3, 4)
12
五、基本计算
numpy中的ndarray对象重载了许多运算符，使用这些运算符可以完成矩阵间对应元素的运算。
如 +，-，*（内积），/，%，**（次方），@（矩阵阶层）
# 矩阵内积：对应位置相乘
print(arr1*arr2)
# 矩阵乘法：
print(arr1@arr2)
print(np.dot(arr1,arr2))
print(arr1.dot(arr2))
In [61]:
arr1 = np.array([[0,1],[1,2]])
arr2 = np.arange(4).reshape((2,2))
ans = arr1 + arr2
print(arr1)
print(arr2)
print("===========================")
print(ans)
print(arr2-arr1)
[[0 1]
[1 2]]
[[0 1]
[2 3]]
===========================
[[0 2]
[3 5]]
[[0 0]
[1 1]]
In [64]:
# 矩阵内积：对应位置相乘
print(arr1*arr2)
# 矩阵乘法：
print(arr1@arr2)
print(np.dot(arr1,arr2))
print(arr1.dot(arr2))
[[0 1]
[2 6]]
[[2 3]
[4 7]]
[[2 3]
[4 7]]
[[2 3]
[4 7]]
In [65]:
print(arr1*3)
[[0 3]
[3 6]]
In [66]:
print(arr1/2)
[[0. 0.5]
[0.5 1. ]]
In [67]:
print(arr1**2)
[[0 1]
[1 4]]
In [69]:
print(arr2%3)
[[0 1]
[2 0]]
六、常用函数
numpy常用多维函数有sin、sqrt、sort、transpose、max、
mean（average）、sum、median（中位数）、var（方差）、std（标准差）、cumsum（累加）、
np.clip(arr,5,9)（小于5的数全部让它变成5，大于9的数全部是9）
axis为0为1表示的意思是什么
axis为0表示对列进行操作，axis为1表示为行进行操作
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
# 平均数
print(arr.mean())
print(np.average(arr))
print(np.average(arr,axis=0)) # 0是列
print(np.average(arr,axis=1)) # 1是行
5.75
5.75
[4. 5. 7. 7.]
[1.5 6.25 9.5 ]
In [71]:
arr = np.arange(12).reshape((3,4))
print(arr)
print(np.sin(arr))
print(np.sqrt(arr))
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[ 0. 0.84147098 0.90929743 0.14112001]
[-0.7568025 -0.95892427 -0.2794155 0.6569866 ]
[ 0.98935825 0.41211849 -0.54402111 -0.99999021]]
[[0. 1. 1.41421356 1.73205081]
[2. 2.23606798 2.44948974 2.64575131]
[2.82842712 3. 3.16227766 3.31662479]]
In [77]:
# 随机数 排序 转置 求平均数
arr = np.random.random(12).reshape((3,4))
print(arr)
# 默认每行排序
print(np.sort(arr))
[[0.14680654 0.45555777 0.20272618 0.80548907]
[0.0580613 0.59622315 0.14429785 0.50518877]
[0.7277057 0.26036975 0.71367339 0.64882704]]
[[0.14680654 0.20272618 0.45555777 0.80548907]
[0.0580613 0.14429785 0.50518877 0.59622315]
[0.26036975 0.64882704 0.71367339 0.7277057 ]]
In [79]:
arr = np.random.random(12).reshape((3,4))
print(arr)
# 指定列排序
print(np.sort(arr,axis=0))
[[0.28404892 0.16859485 0.40676585 0.82394419]
[0.13459384 0.35249053 0.43333728 0.09445943]
[0.80790859 0.13132432 0.17725597 0.90638246]]
[[0.13459384 0.13132432 0.17725597 0.09445943]
[0.28404892 0.16859485 0.40676585 0.82394419]
[0.80790859 0.35249053 0.43333728 0.90638246]]
In [83]:
# 转置
arr = np.arange(12).reshape((3,4))
print(arr)
print(arr.T)
print(arr.transpose())
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
In [101]:
# max,min
# 0是列（一列来操作），1是行（一行来操作）
arr = np.arange(12).reshape((3,4))
arr[1][2]=9
print(arr)
print(np.max(arr))
print(np.max(arr,axis=0))
print(np.max(arr,axis=1))
[[ 0 1 2 3]
[ 4 5 9 7]
[ 8 9 10 11]]
11
[ 8 9 10 11]
[ 3 9 11]
In [102]:
# 平均数
print(arr.mean())
print(np.average(arr))
print(np.average(arr,axis=0)) # 0是列
print(np.average(arr,axis=1)) # 1是行
5.75
5.75
[4. 5. 7. 7.]
[1.5 6.25 9.5 ]
In [103]:
# 中位数
print(np.median(arr))
print(np.median(arr,axis=0)) # 0是列
print(np.median(arr,axis=1)) # 1是行
6.0
[4. 5. 9. 7.]
[1.5 6. 9.5]
In [93]:
# 方差和标准差
# 方差的函数为var(),方差函数var()相当于函数mean(abs(x - x.mean())**2),其中x为矩阵。
print(np.var(arr))
# 标准差的函数为std()， std()相当于sqrt(mean(abs(x - x.mean())**2))，或相当于sqrt(x.var())。
print(np.std(arr))
11.916666666666666
3.452052529534663
In [95]:
# 求和
print(np.sum(arr))
66
In [97]:
# 累加
print(arr)
print(np.cumsum(arr))
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[ 0 1 3 6 10 15 21 28 36 45 55 66]
In [105]:
# 小于5的数全部让它变成5
# 大于9的数全部是9
print(np.clip(arr,5,9))
[[5 5 5 5]
[5 5 9 7]
[8 9 9 9]]
In [106]:
help(np.clip)
Help on function clip in module numpy:
clip(a, a_min, a_max, out=None, **kwargs)
Clip (limit) the values in an array.
Given an interval, values outside the interval are clipped to
the interval edges. For example, if an interval of ``[0, 1]``
is specified, values smaller than 0 become 0, and values larger
than 1 become 1.
Equivalent to but faster than ``np.maximum(a_min, np.minimum(a, a_max))``.
No check is performed to ensure ``a_min < a_max``.
Parameters
----------
a : array_like
Array containing elements to clip.
a_min : scalar or array_like or None
Minimum value. If None, clipping is not performed on lower
interval edge. Not more than one of `a_min` and `a_max` may be
None.
a_max : scalar or array_like or None
Maximum value. If None, clipping is not performed on upper
interval edge. Not more than one of `a_min` and `a_max` may be
None. If `a_min` or `a_max` are array_like, then the three
arrays will be broadcasted to match their shapes.
out : ndarray, optional
The results will be placed in this array. It may be the input
array for in-place clipping. `out` must be of the right shape
to hold the output. Its type is preserved.
**kwargs
For other keyword-only arguments, see the
:ref:`ufunc docs <ufuncs.kwargs>`.
.. versionadded:: 1.17.0
Returns
-------
clipped_array : ndarray
An array with the elements of `a`, but where values
< `a_min` are replaced with `a_min`, and those > `a_max`
with `a_max`.
See Also
--------
ufuncs-output-type
Examples
--------
>>> a = np.arange(10)
>>> np.clip(a, 1, 8)
array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.clip(a, 3, 6, out=a)
array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8)
array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])
七、索引和迭代
numpy中，可以像普通数组一样用下标来访问元素，比如a[1][1]、a[1,1]
numpy中访问行列元素
a[1,:]（打印下标为1的行所有数）
a[:,1]（打印下标为1的列的所有数）
a[1,1:3]（第1行 列从1-2）
numpy中迭代行循环打印即可，如何迭代列
将矩阵转置即可
# 迭代列 (转置一下即可实现)
for i in a.T:
print(i)
numpy中如何迭代多维数组的每一个数
for i in a.flat: print(i)
In [125]:
a = np.arange(3,15)
print(a)
# 索引像数组一样
print(a[3])
[ 3 4 5 6 7 8 9 10 11 12 13 14]
6
In [108]:
# 二维数组
a = np.arange(3,15).reshape((3,4))
print(a)
# 索引像数组一样
print(a[1])
print(a[1][1])
print(a[1,1])
[[ 3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]]
[ 7 8 9 10]
8
8
In [109]:
# 打印下标为1的行所有数
print(a[1,:])
# 打印下标为1的列的所有数
print(a[:,1])
# 第1行 列从1-2
print(a[1,1:3])
[ 7 8 9 10]
[ 4 8 12]
[8 9]
In [110]:
# 迭代行
a = np.arange(3,15).reshape((3,4))
print(a)
for i in a:
print(i)
[[ 3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]]
[3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]
In [111]:
# 迭代列 (转置一下即可实现)
for i in a.T:
print(i)
[ 3 7 11]
[ 4 8 12]
[ 5 9 13]
[ 6 10 14]
In [112]:
# 迭代每一个数
print(a.flatten())
# flatten() 和 flat的区别
# flat是一个迭代器
for i in a.flat:
print(i)
[ 3 4 5 6 7 8 9 10 11 12 13 14]
3
4
5
6
7
8
9
10
11
12
13
14
八、数组合并
numpy数组水平合并可以np.hstack((a,b))，类似于np.concatenate((a,b,a),axis=1)
numpy数组垂直合并可以np.vstack((a,b))，类似于np.concatenate((a,b,a),axis=0)
In [113]:
a = np.array([1,2,3])
b = np.array([4,5,6])
# 合并数组
# 上下合并 vertical stack
c = np.vstack((a,b))
print(c)
print(a.shape)
print(c.shape)
[[1 2 3]
[4 5 6]]
(3,)
(2, 3)
In [114]:
# 左右合并 horizontal
c = np.hstack((a,b))
print(c)
[1 2 3 4 5 6]
In [115]:
# 如何实现把一个横向的数列变成一个竖向的数列
a = np.array([1,2,3])
# 在行上加了一个维度
print(a[np.newaxis,:])
# 在列上加了一个维度
print(a[:,np.newaxis])
[[1 2 3]]
[[1]
[2]
[3]]
In [116]:
a = np.array([1,2,3])[:,np.newaxis]
b = np.array([4,5,6])[:,np.newaxis]
print(a)
print(b)
print("====================")
c = np.concatenate((a,b,a),axis=0)
print(c)
print("====================")
d = np.concatenate((a,b,a),axis=1)
print(d)
[[1]
[2]
[3]]
[[4]
[5]
[6]]
====================
[[1]
[2]
[3]
[4]
[5]
[6]
[1]
[2]
[3]]
====================
[[1 4 1]
[2 5 2]
[3 6 3]]
九、数组分割
等量分割：水平分成两块np.split(a,2,axis=1)，vsplit和hsplit也可以等量分割
不等量分割：np.array_split(a,3,axis=1)
In [128]:
a = np.arange(12).reshape((3,4))
print(a)
print("====================")
# 分割
# 每行分割成两个
# axis=1表示对水平进行操作
print(np.split(a,2,axis=1))
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
====================
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
In [118]:
# 纵向分割成3块
print(np.split(a,3,axis=0))
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
In [119]:
# 不等量分割
# ValueError: array split does not result in an equal division
# print(np.split(a,3,axis=1)) # 行的四个元素分成3个会出错
print(np.array_split(a,3,axis=1))
# 这样分成了 2 1 1
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2],
[ 6],
[10]]), array([[ 3],
[ 7],
[11]])]
In [131]:
print(np.vsplit(a,3))
print(np.hsplit(a,2))
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
十、数组拷贝
numpy 中的 copy方法是 deep copy：b = np.copy(a)
In [121]:
a = np.arange(4)
b = a
print(a)
print(b)
[0 1 2 3]
[0 1 2 3]
In [122]:
a[0] = 199
b[1:3] = [7,8]
print(a)
print(b)
print(id(a))
print(id(b))
print(b is a)
[199 7 8 3]
[199 7 8 3]
2190570709120
2190570709120
True
In [132]:
# numpy 中的 copy方法是 deep copy
# 文档中说的非常详细
a = np.arange(4)
# b = a.copy()
b = np.copy(a)
print(a)
print(b)
print(id(a))
print(id(b))
[0 1 2 3]
[0 1 2 3]
2190587830880
2190587831440
In [133]:
a[0] = 199
b[1:3] = [7,8]
print(a)
print(b)
[199 1 2 3]
[0 7 8 3]
In [ ]:
我的旨在学过的东西不再忘记（主要使用艾宾浩斯遗忘曲线算法及其它智能学习复习算法）的偏公益性质的完全免费的编程视频学习网站： fanrenyi.com；有各种前端、后端、算法、大数据、人工智能等课程。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
