转载地址：https://blog.csdn.net/sinat_26917383/article/details/52290505 素质云博客
先学了R，最近刚刚上手python,所以想着将python和R结合起来互相对比来更好理解python。最好就是一句python，对应写一句R。
python中的numpy模块相当于R中的matirx矩阵格式，化为矩阵，很多内容就有矩阵的属性，可以方便计算。
以下符号：
=R=
代表着在R中代码是怎么样的。
array模块定义了一种序列数据结构，看起来和list很相似，但是所有成员必须是相同基本类型。
array-固定类型数据序列array作用是高效管理固定类型数值数据的序列。
笔者在使用的时候，觉得array十分特别，笔者这样的新手，感觉有点驾驭不了。
————————————————————————————————————
速查手册：（来源：NumPy 的 Array 介紹）
- # 属性
- ndarray.shape: 多維陣列的大小（形狀）
- ndarray.ndim: 多維陣列的維度
- ndarray.itemsize: 陣列當中元素的大小（佔幾個 byte）
- ndarray.nbytes: 整個陣列所有元素的大小總計
- ndarray.T: 轉置矩陣，只能在維度 <= 2 的時候使用，與 self.transpose() 效果相同
- ndarray.flat: 把陣列扁平化輸出
- # 格式转换
- ndarray.item: 類似 List 的 Index，把 Array 扁平化取得某 Index 的 value
- ndarray.tolist: 把 NumPy.ndarray 輸出成 Python 原生 List 型態
- ndarray.itemset: 把 ndarray 中的某個值（純量）改掉
- # 维度操作
- ndarray.reshape(shape): 把同樣的資料以不同的 shape 輸出（array 的 total size 要相同）
- ndarray.resize(shape): 重新定義陣列的大小
- ndarray.flatten(): 把多維陣列收合成一維陣列（扁平化＆Copy）
- ndarray.ravel(): 回傳扁平化的陣列（無 Copy）
- # 项目选择与操作
- ndarray.take(indices): 根據輸入索引值來得到指定陣列
- ndarray.put(indices, values): 根據索引值改變陣列 value
- ndarray.repeat(times): 重複陣列的值（類似擴張）
- ndarray.sort(): 把陣列當中的元素排序
- ndarray.sum(): 加總多維陣列（可指定加總的維度根據）
- # 实用模块
- np.squeeze(array) # 去掉array的第一列
- np.maximin(x,0,y) # 比较两个值大小，若有小于0的，则为0
————————————————————————————————————
一、数据生成与复制、重复
1、数列生成
构造单一数列
- arange(10) =R=1:10 生成一个连贯的数列
- arange(3,7) =R=3:7
- arange(3,10,2) =R= seq(3, 9, by = 2)
- array(arange(4)) =R= matrix(1:4)
生成的过程：
- np.array([1,2])
需要np.，笔者在写的时候，常常用R的思维去写...
出错： array(1,2) array([1,2]) np.array([1,2],[1,2])
类似cut分组
- np.linspace(2.0, 3.0, num=5) =R= cut(2:3,5) #类似cut功能，在2,3之间分成5份
matrix矩阵组
- ma=arange(10).reshape(5,2) #matrix(rep(1:10),nrow=5,ncol=2) 按行或列生成一定规则的
- ones((2,3), dtype=int) =R= matrix(rep(1,6),2,3) #矩阵内元素都为1
- random.random((2,3)) =R= matrix(runif(6),2,3) #生成随机数
构造空白数组：
ones创建全1矩阵
zeros创建全0矩阵
eye创建单位矩阵
empty创建空矩阵（实际有值）
- import numpy as np
- a_ones = np.ones((3,4)) # 创建3*4的全1矩阵
- print(a_ones)
- # 结果
- [[ 1. 1. 1. 1.]
- [ 1. 1. 1. 1.]
- [ 1. 1. 1. 1.]]
- a_zeros = np.zeros((3,4)) # 创建3*4的全0矩阵
- print(a_zeros)
- # 结果
- [[ 0. 0. 0. 0.]
- [ 0. 0. 0. 0.]
- [ 0. 0. 0. 0.]]
- a_eye = np.eye(3) # 创建3阶单位矩阵
- print(a_eye)
- # 结果
- [ 1. 0. 0.]
- [ 0. 1. 0.]
- [ 0. 0. 1.]]
- a_empty = np.empty((3,4)) # 创建3*4的空矩阵
- print(a_empty)
- # 结果
- [[ 1.78006111e-306 -3.13259416e-294 4.71524461e-309 1.94927842e+289]
- [ 2.10230387e-309 5.42870216e+294 6.73606381e-310 3.82265219e-297]
- [ 6.24242356e-309 1.07034394e-296 2.12687797e+183 6.88703165e-315]]
等差、等比数列
linspace()和matlab的linspace很类似，用于创建指定数量等间隔的序列，实际生成一个等差数列。
- import numpy as np
- a = np.linspace(0,10,7) # 生成首位是0，末位是10，含7个数的等差数列
- print(a)
- # 结果
- [ 0. 1.66666667 3.33333333 5. 6.66666667 8.33333333 10. ]
linspace用于生成等差数列，而logspace用于生成等比数列。
下面的例子用于生成首位是100，末位是102，含5个数的等比数列。
- import numpy as np
- a = np.logspace(0,2,5)
- print(a)
- # 结果
- [ 1. 3.16227766 10. 31.6227766 100. ]
2、复制/重复repeat、title
貌似是list/tuple/dict唯一一个拥有重复属性的吧？ 两个重复函数：repeat/tile
repeat函数功能：对数组中的元素进行连续重复复制
用法有两种：
1) numpy.repeat(a, repeats, axis=None)
2) a.repeats(repeats, axis=None)
- >>>import numpy as np
- >>> a = np.arange(10)
- >>> a
- array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
- >>> a.repeat(5)
- array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4,
- 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 9,
- 9, 9, 9, 9])
- >>> a
- np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) #a数组的内容没改变
tile函数功能：对整个数组进行复制拼接
用法：numpy.tile(a, reps)
其中a为数组，reps为重复的次数
- >>> np.tile(a,2)
- array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
- >>> a
- np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
- >>> a=np.array([10,20])
- >>>a
- array([10,20])
- >>>np.tile(a, (3,2)) #构造3*2个copy
- array([[10, 20, 10, 20],
- [10, 20, 10, 20],
- [10, 20, 10, 20]])
——————————————————————————————————————————————————
二、array属性与统计、运算
1、矩阵属性
- ma.shape #输出5,2（矩阵横纵维度）
- ma.ndim =R=dim(ma) #维度,dim(data)
- ma.size #元素总数，5*2
- In [26]: arr3.dtype #dtype方法返回数组的数据类型
- Out[26]: dtype('int32')
缺失值填补：
- example = np.where(np.isnan(example), 0, example)
- example = np.where(np.isnan(example), 0, example)
2、数组拉直
- <span style="font-family:Arial, Helvetica, sans-serif;">a = arr3.ravel() #通过ravel的方法将数组拉直（多维数组降为一维数组）</span>
- In [24]: arr3
- Out[24]:
- array([[ 1, 1, 2, 3],
- [ 5, 8, 13, 21],
- [ 34, 55, 89, 144]])
第二种办法：
- In [29]: b = arr3.flatten() #通过flatten的方法将数组拉直
- In [30]: b
- Out[30]: array([ 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144])
两者的区别在于ravel方法生成的是原数组的视图，无需占有内存空间，但视图的改变会影响到原数组的变化。而flatten方法返回的是真实值，其值的改变并不会影响原数组的更改。
通过下面的例子也许就能明白了：
- In [31]: b[:3] = 0
- In [32]: arr3
- Out[32]:
- array([[ 1, 1, 2, 3],
- [ 5, 8, 13, 21],
- [ 34, 55, 89, 144]])
通过更改b的值，原数组没有变化。
3、矩阵运算——相乘、求积
- (arange(4).reshape(2,2))* (arange(8).reshape(2,2)) #组内数字相乘
- dot( (arange(4).reshape(2,2)),(array([[1,2],[3,5]]))) #矩阵相乘
- ma*=2 #ma=ma*2,会原地的改变数组而不是创建一个新的数组
- prod()
得到数组所有元素之积，是个数字。也可以aaa.sum(axis)，分别求每一行或者是每一列的元素之积
累计积：cumprod()
all() ：如果所有元素为真，返回真；否则返回假
特征值 ：linalg.eigvals()
返回A的特征值
4、矩阵运用函数——加总、求均值、累积和、极大值、极小值
- ma.sum()
- ma.min()
- ma.max()
- ma.sum(axis=0) =R=apply(b,1,sum) =R=colSums（data） #axis=0代表纵向,列；axis=1，代表横向
- ma.cumsum(axis=1) #按行，累计加总的结果
（1）求和：
ma.sum/min代表所有元素加总.其中，如果是矩阵连加，有两种方式：array+array=矩阵，array.sum()=数值
第一种就是mat + mat,用加号，生成的还是矩阵，高纬度；
第二种就是sum(mat)，用sum，一维单个数值.
同时注意，跟ma.sum()不一样，.sum()返回的是一个矩阵总和。
场景一：矩阵相加-均值
- data_array + data_array - data_array.mean()
场景二：矩阵小于某阈值的，赋值
- data.array[data.array< 0 ] = 0
场景三：矩阵变一维向量:ravel()
- data.array.ravel()
（2）求平均：
获得矩阵中元素的平均值可以通过函数mean()。同样地，可以获得整个矩阵、行或列的平均值。
- import numpy as np
- a = np.array([[1,2,3],[4,5,6]])
- print(a.mean()) #结果为： 3.5
- # 同样地，可以通过关键字axis参数指定沿哪个方向获取平均值
- print(a.mean(axis=0)) # 结果 [ 2.5 3.5 4.5]
- print(a.mean(axis=1)) # 结果 [ 2. 5.]
（3）进行正弦计算：
- >>> y = np.sin(x)
- >>> y
- array([ 0.00000000e+00, 6.42787610e-01, 9.84807753e-01,
- 8.66025404e-01, 3.42020143e-01, -3.42020143e-01,
- -8.66025404e-01, -9.84807753e-01, -6.42787610e-01,
- -2.44921271e-16])
| 矩阵函数 | 说明 |
|---|---|
| np.sin(a) | 对矩阵a中每个元素取正弦,sin(x) |
| np.cos(a) | 对矩阵a中每个元素取余弦,cos(x) |
| np.tan(a) | 对矩阵a中每个元素取正切,tan(x) |
| np.arcsin(a) | 对矩阵a中每个元素取反正弦,arcsin(x) |
| np.arccos(a) | 对矩阵a中每个元素取反余弦,arccos(x) |
| np.arctan(a) | 对矩阵a中每个元素取反正切,arctan(x) |
| np.exp(a) | 对矩阵a中每个元素取指数函数,ex |
| np.sqrt(a) | 对矩阵a中每个元素开根号√x |
- aaa.cumsum()
- 2 结果为：array([ 10, 19, 27, 34, 40, 45, 87, 120, 122])
（5）求最大值，最小值：
获得矩阵中元素最大最小值的函数分别是max和min，可以获得整个矩阵、行或列的最大最小值。
例如
- import numpy as np
- a = np.array([[1,2,3],[4,5,6]])
- print(a.max()) #获取整个矩阵的最大值 结果： 6
- print(a.min()) #结果：1
- # 可以指定关键字参数axis来获得行最大（小）值或列最大（小）值
- # axis=0 行方向最大（小）值，即获得每列的最大（小）值
- # axis=1 列方向最大（小）值，即获得每行的最大（小）值
- # 例如
- print(a.max(axis=0))
- # 结果为 [4 5 6]
- print(a.max(axis=1))
- # 结果为 [3 6]
- # 要想获得最大最小值元素所在的位置，可以通过argmax函数来获得
- print(a.argmax(axis=1))
- # 结果为 [2 2]
（6）求方差与标准差
方差：比较简单，分别是np.sum(), np.mean(), np.var(), np.std()(这个是标准差)，关键是在加入axis参数以后要很好的区分
- >>> a
- array([[6, 7, 1, 6],
- [1, 0, 2, 3],
- [7, 8, 2, 1]])
- 方差：
- >>> np.var(a)
- 7.7222222222222223
- >>> np.var(a,axis=0)
- array([ 6.88888889, 12.66666667, 0.22222222, 4.22222222])
- >>> np.std(a,axis=0)
- array([ 2.62466929, 3.55902608, 0.47140452, 2.05480467])
5、偏度、峰度
参考：Python统计学一数据的概括性度量、《Python数据分析基础教程：Numpy学习指南》- 速记 - 第十章
在scipy模块中
偏度（skewness）、描述的是概率分布的偏斜（非对称）程度。偏度检验有两个返回值，其中第二个返回值为p-value，即观察到的数据集服从正态分布的概率，取值范围为0~1
峰度（kurtosis）描述的是概率分布曲线的陡峭程度。
偏态系数：偏度(Skewness)亦称偏态、偏态系数，偏度是统计数据分布偏斜方向和程度的度量，是统计数据分布非对称程度的数字特征。Sk>0时，分布呈正偏态（右偏），Sk<0时，分布呈负偏态（左偏）。 峰态系数：（Kurtosis)峰度系数是用来反映频数分布曲线顶端尖峭或扁平程度的指标。在正态分布情况下，峰度系数值是3。>3的峰度系数说明观察量更集中，有比正态分布更短的尾部；<3的峰度系数说明观测量不那么集中，有比正态分布更长的尾部，类似于矩形的均匀分布。峰度系数的标准误用来判断分布的正态性。峰度系数与其标准误的比值用来检验正态性。如果该比值绝对值大于2，将拒绝正态性。
- from scipy import stats
- import matplotlib.pyplot as plt
- generated = stats.norm.rvs(size=900) #使用scipy.stats包按正态分布生成随机数。
- print "Mean", "Std", stats.norm.fit(generated) #用正态分布去拟合生成的数据，得到其均值和标准差。
- #偏度（skewness）描述的是概率分布的偏斜（非对称）程度。偏度检验有两个返回值，其中第二个返回值为p-value，即观察到的数据集服从正态分布的概率，取值范围为0~1。
- print "Skewtest", "pvalue", stats.skewtest(generated)
- #output
- #Skewtest pvalue (-0.62120640688766893, 0.5344638245033837)
- #该数据集有53%的概率服从正态分布。
- #峰度（kurtosis）描述的是概率分布曲线的陡峭程度。
- print "Kurtosistest","pvalue",stats.kurtosistest(generated)
- #正态性检验（normality test）可以检查数据集服从正态分布的程度。我们来做一个正态性检验。该检验同样有两个返回值，其中第二个返回值为p-value。
- print "Normaltest", "pvalue", stats.normaltest(generated)
- #得到95%处的数值如下
- print "95 percentile", stats.scoreatpercentile(generated, 95)
- #将前一步反过来，可以从数值1出发找到对应的百分比
- print "Percentile at 1", stats.percentileofscore(generated, 1)
6、numpy的除法
很多情况会遇到，1/2=0的情况，所以需要了解一下。
精确除法
除法总是会返回真实的商，不管操作数是整形还是浮点型。执行from __future__ import division 指令就可以做到这一点。
- >>>from __future__ import division
- >>>1/2
- 0.5
- >>>1//2
- 0
- >>>1.0//2
- 0
- >>>-1//2.0
- -1
>>>1.0/2.0 0.5
地板除
从Python2.2开始，增加了一个操作符 // ，以执行地板除：//除法不管操作数为何种数值类型，总是会舍去小数部分，返回数字序列中比真正的商小的最接近的数字。
- >>>1//2
- 0
- >>>1.0//2
- 0
- >>>-1//2.0
- -1
传统除法
如果是整数除法则执行地板除，如果是浮点数除法则执行精确除法。
- >>>1/2
- 0
- >>>1.0/2.0
- 0.5
7、白化（Whitening）
白化相当于在零均值化和归一化操作之间插入一个旋转操作，将数据投影到主轴上。一张图片经过白化后，可以认为每个像素之间是统计独立的。然而白化很少在卷积神经网络中使用，可能原因是图像信息本来就是依靠像素之间的相对差异来体现的，白化让像素间去相关，让这种差异变得不确定，损失了信息。
将数据零均值化，再计算协方差矩阵（convariance matrix）来观察数据中的相关结构。
- X-=np.mean(X,axis=0)
- cov=np.dot(X.T,X)/X.shape[0] #计算协方差矩阵
然后做去相关操作, 即通过将原始数据（零均值化后的数据）投影到特征基空间（eigenbasis）。
- U,S,V=np.linalg.svd(cov) #计算数据协方差矩阵的奇异值分解（SVDfactorization）
- Xrot=np.dot(X,U) #对数据去相关
最后一步变换是白化，即把特征基空间的数据除以每个维度的特征值来标准化尺度。
- Xwhite=Xrot/np.sqrt(S+1e-5) #除以奇异值的平方根，注意到这里加了个 1e-5 是为了防止分母是 0 的情况。
三、numpy如何导出以及导入、数列格式转换
1、numpy如何导出、导入
Numpy提供了几种数据保存的方法。
以3*4数组a为例：
1. a.tofile("filename.bin")
这种方法只能保存为二进制文件，且不能保存当前数据的行列信息，文件后缀不一定非要是bin，也可以为txt，但不影响保存格式，都是二进制。
这种保存方法对数据读取有要求，需要手动指定读出来的数据的的dtype，如果指定的格式与保存时的不一致，则读出来的就是错误的数据。
b = numpy.fromfile("filename.bin",dtype = **)
读出来的数据是一维数组，需要利用
b.shape = 3,4重新指定维数。
2.numpy.save("filename.npy",a)
利用这种方法，保存文件的后缀名字一定会被置为.npy，这种格式最好只用
numpy.load("filename")来读取。
3.numpy.savetxt("filename.txt",a)
b = numpy.loadtxt("filename.txt")
用于处理一维和二维数组
2、数组格式转换
数组转换：tolist将数组转换为列表，astype()强制转换数组的数据类型，下面是两个函数的例子：
- In [53]: b = a.tolist()
- In [54]: b
- Out[54]:
- [[0, 1, 2, 3],
- [4, 5, 6, 7],
- [8, 9, 10, 11],
- [12, 13, 14, 15],
- [16, 17, 18, 19],
- [20, 21, 22, 23]]
- In [55]: type(b)
- Out[55]: list
- In [56]: c = a.astype(float)
- In [57]: c
- Out[57]:
- array([[ 0., 1., 2., 3.],
- [ 4., 5., 6., 7.],
- [ 8., 9., 10., 11.],
- [ 12., 13., 14., 15.],
- [ 16., 17., 18., 19.],
- [ 20., 21., 22., 23.]])
- In [58]: a.dtype
- Out[58]: dtype('int32')
- In [59]: c.dtype
- Out[59]: dtype('float64')
这里有一个非常实际的问题：
一般结果输出都是array格式，然后我要加一个字符串形式进行，总不能.append的加，所以需要把array转化格式。譬如有一个名称为a的array格式数据。
- ['a1.jpg',] + a.tolist()
其他格式转化：
1. list转化为numpy.ndarray：
np.array(example)
2. numpy.ndarray转化为list：
list(example)
3. numpy.ndarray转化为dataframe:
pd.DataFrame(example)
4. dataframe转化为numpy.ndarray：
example.values[:, :]
四、array添加数据、切片、合并
1、array添加数据
- a=[]
- #append
- a.append([1,2])
- #insert
- a.insert(2,1)
- a.insert(2,[1,2])
append加在后面，insert(位置，内容)可以加在指定位置。这边笔者又要吐槽自己了...以为又在使用R，如果a是array格式的，append是不可以使用的。只有a=[]元组的时候，才可以append加进去。
注意append用法：其中append用在list之中，在DataFrame/array无法使用
2、切片过程：
- >>>Array[0:] ——>切片从前面序号“0”开始到结尾，包括“0”位
- [2, 3, 9, 1, 4, 7, 6, 8]
- >>>Array[:-1] ——>切片从后面序号“-1”到最前，不包括“-1”位
- [2, 3, 9, 1, 4, 7, 6]
- >>>Array[3:-2] ——>切从前面序号“3”开始(包括)到从后面序号“-2”结束(不包括)
- [1, 4, 7]
- >>>Array[3::2] ——>从前面序号“3”(包括)到最后，其中分隔为“2”
- [1, 7, 8]
3、numpy对象纵向合并
用numpy中的concatenation函数进行合并。
4、用逻辑符bool定位出numpy中的内容
- vector = numpy.array([5, 10, 15, 20])
- print(vector)
- [ 5 10 15 20]
- equal_to_ten = (vector == 10)
- print(equal_to_ten)
- [False True False False]
- # 输出只有相对于位布尔值是True位置上的值
- print(vector[equal_to_ten])
- [10]
5、横向拼接
- In [40]: arr3
- Out[40]:
- array([[ 0, 0, 0, 3],
- [ 5, 8, 13, 21],
- [ 34, 55, 89, 144]])
- In [41]: arr4
- Out[41]:
- array([[ 1, 2, 3, 4],
- [ 5, 6, 7, 8],
- [ 9, 10, 11, 12]])
- In [42]: np.hstack((arr3,arr4))
- Out[42]:
- array([[ 0, 0, 0, 3, 1, 2, 3, 4],
- [ 5, 8, 13, 21, 5, 6, 7, 8],
- [ 34, 55, 89, 144, 9, 10, 11, 12]])
横向拼接 arr3和arr4两个数组，但必须满足两个数组的行数相同。
- In [43]: np.vstack((arr3,arr4))
- Out[43]:
- array([[ 0, 0, 0, 3],
- [ 5, 8, 13, 21],
- [ 34, 55, 89, 144],
- [ 1, 2, 3, 4],
- [ 5, 6, 7, 8],
- [ 9, 10, 11, 12]])
- In [44]: np.column_stack((arr3,arr4)) #与hstack函数具有一样的效果
- Out[44]:
- array([[ 0, 0, 0, 3, 1, 2, 3, 4],
- [ 5, 8, 13, 21, 5, 6, 7, 8],
- [ 34, 55, 89, 144, 9, 10, 11, 12]])
- In [45]: np.row_stack((arr3,arr4)) #与vstack函数具有一样的效果
- Out[45]:
- array([[ 0, 0, 0, 3],
- [ 5, 8, 13, 21],
- [ 34, 55, 89, 144],
- [ 1, 2, 3, 4],
- [ 5, 6, 7, 8],
- [ 9, 10, 11, 12]])
————————————————————————————————————————
延展一：range的用法
一开始还是R的思维以为[1:2]就可以得到一个序列，python里面不是，需要range，有点像R里面的rep
range(0,2) =R= [1,2]
range(0,10,2) 0-9每隔2个取数一次
xrange 用法与 range 完全相同，所不同的是生成的不是一个list对象，而是一个生成器。
- >>> xrange(5)
- xrange(5)
- >>> list(xrange(5))
- [0, 1, 2, 3, 4]
- >>> xrange(1,5)
- xrange(1, 5)
- >>> list(xrange(1,5))
- [1, 2, 3, 4]
- >>> xrange(0,6,2)
- xrange(0, 6, 2)
- >>> list(xrange(0,6,2))
- [0, 2, 4]
————————————————————————————————————————
延伸二：高纬度array表示[0,0,0,0]
一个array有四个维度：[1,1024,19,19]，代表的意思是，有1024个19*19矩阵，如果要抽取其中一个19*19的矩阵，则表示为：
[0,1,:,:]
————————————————————————————————————————
延伸三：array中数据的替换
ndarray.itemset: 把 ndarray 中的某個值（純量）改掉，使用範例如下：
- >>> x = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]], np.int32)
- >>> x
- array([[[ 1, 2, 3],
- [ 4, 5, 6]],
- [[ 7, 8, 9],
- [10, 11, 12]]], dtype=int32)
- # 把 index = 1 的 value 改成 999
- >>> x.itemset(1, 999)
- >>> x
- array([[[ 1, 999, 3],
- [ 4, 5, 6]],
- [[ 7, 8, 9],
- [ 10, 11, 12]]], dtype=int32)
- # 把 index = (1, 1, 2) 的值改成 888
- >>> x.itemset((1, 1, 2), 888)
- >>> x
- array([[[ 1, 999, 3],
- [ 4, 5, 6]],
- [[ 7, 8, 9],
- [ 10, 11, 888]]], dtype=int32)
1102
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
