一、ndarray概念
1.1、回顾python基本类型
数字类型： 整型： 布尔型bool、整型int、长整形long 非整型：浮点float 、复数complex 容器： 序列：字符串str 、列表list、元组tuple 集合：可变集合set、不可变集合frozen set 映射：字典dict python是C语言实现的，都是C语言设计的结构体 示例：int(1)在内存：应用计数和类型1.2、高效的固定类型数组：ndarray
list: 支持存储不同类型数据 可以动态增加长度 计算性能一般 存储冗余多 ndarray: 只能存储单一数据类型 不可以动态增加长度 计算性能好 存储冗余少1.3、ndarray的基本用法
import numpy as np #导入模块，并命名为np x = np.array([[1,2,3],[4,5,6]]) #创建一个ndarray数组 x array([[1,2,3], [4,5,6]]) type(x) #查看类型 numpy.ndarray1.4、ndarray的属性
ndim: 维度数 ndim = 2 shape： 数组形状 shape = (2,3) size： 数组元素总数 size = 6 dtype： 数组元素的数据类型 dtype = int 64 itemsize： 每个元素所需内存空间 itemsize = 8 strides： 移动到下一个元素所需偏移量（字节） nbytes： 存储该数组所需内存大小 itemsize*size data: 数组元素对应的内存区域
二、创建 ndarray
2.1 基本语法
array(object,dtype = None,copy=True,order= 'K',subok = False,ndmin = 0) object: 列表或任何一个_array_方法 返回一个数组的对象 dtype: 数组元素的数据类型，支持自动向更高精度转换 order： 数组元素在内存的储存顺序 C语言风格，行优先 Fortran风格，列优先2.2 从函数创建 array
定义一个函数，根据下标计算每个位置上的值
from function(function,shape,**kwargs) function:定义一个函数，接受N个参数（N维度数），返回一个数值 shape： 要创建的数组每个维度的大小创建数组（一维/多维）
import numpy as np # 导入模块，并命名为np list1 = [1,2,3,4,5] x1 = np.array(list) # 创建一个ndarray二维数组,里面为python容器 x2 =np.array([np.arange(2),np.arange(2)]) # 输出[[0,1],[0,1]] x3 = np.array([[1,2,3],[4,5,6]]) # 创建一个ndarray二维数组 ◆创建一个[a,b]范围内取n点的等间距分布数组 x4 =np.linspace(0,10,4,endpoint= True) #默认True >>>[0. 3.33333333 6.66666667 10. ] x5 =np.linspace(0,10,4,endpoint=False) >>>[0. 2.5 5. 7.5] ◆特殊多维矩阵 b = np.ones((1, 2)) #创建一个值均为 1 的1*2维ndarray对象 c = np.full((2, 2), 7) #创建一个值均为 7 的2*2维ndarray对象 d = np.eye(2) #创建一个 2*2 维对角矩阵 e=np.eye(3,k=2) #第一个参数：行数=列数，即行数或列数#第二个参数k：默认情况下输出的是对角线全“1” ，其余全“0” 的方阵, #如果k为正整数，则在右上方第k条对角线全“1” 其余全“0” ，k为负整数则 #在左下方第k条对角线全“1” 其余全“0” ，详情如下图。
三、numpy中的数据类型
| 名称 | 描述 |
|---|---|
| bool | 用一个字节存储的布尔类型（True或False） |
| inti | 由所在平台决定其大小的整数（一般为int32或int64） |
| int8 | 一个字节大小，-128 至 127 |
| int16 | 整数，-32768 至 32767 |
| int32 | 整数，-2 * 31 至 2 * 32 -1 |
| int64 | 整数，-2 * 63 至 2 * 63 - 1 |
| uint8 | 无符号整数，0 至 255 |
| uint16 | 无符号整数，0 至 65535 |
| uint32 | 无符号整数，0 至 2 ** 32 - 1 |
| uint64 | 无符号整数，0 至 2 ** 64 - 1 |
| float16 | 半精度浮点数：16位，正负号1位，指数5位，精度10位 |
| float32 | 单精度浮点数：32位，正负号1位，指数8位，精度23位 |
| float64或float | 双精度浮点数：64位，正负号1位，指数11位，精度52位 |
| complex64 | 复数，分别用两个32位浮点数表示实部和虚部 |
| complex128或complex | 复数，分别用两个64位浮点数表示实部和虚部 |
自定义数据类型：
T=np.dtype([('name', np.str_, 40), ('numitems',np.int32), ('price',np.float32)])
products = np.array([('DVD',42,3.14),('Butter',13,2.72)],dtype=T) #插入数据
print(products.dtype)
>>>
[('name', '<U40'), ('numitems', '<i4'), ('price', '<f4')]
四、ndarray多维数组操作
4.1访问数组
ndarray数组的索引 切片（Slicing） 访问一维数据/切片对象 slice(start,stop,step) [:] 所有元素 [1:] 索引>=1的元素 [ :3] 索引<=3的元素 [-2:] >=倒数第2个 [1::2] >=1开始，以2为步长取到结束 [::-1] 所有元素倒序 访问二维 [:,1] 所有行，第一列 [:,:2] 所有行，列步长2 访问三维 [2,1,2] =[2][1][2] 第三层第二行第三列 [0,:,:] 第一层所有 [0,1,::2] 第一层第二行列步长2 [::-1] 所有层数倒序4.1.1遍历数组
◆遍历每一个元素 x = np.arange(12).reshape((3,4)) for element in x.flat: #flat 迭代器 print element ◆按行遍历（即沿第一个维度切片） x = np.arange(12).reshape((3,4)) for row in x print (row) ◆沿任意维度遍历 x = np.arange(24).reshape((2,3,4)) for i in range(x,shape[1]): #获取指定维度大小 print (x[:,i,:]) #对这个维度上的每一个截面切片4.1.2 访问数组元素 [ 切片 ]
◆访问二维数组 及其元素 import numpy as np heros = np.array([['苏轼','陈咬金','廉颇'], ['后羿','公孙丽','狄仁杰']],dtype='U8') print(heros[0][2]) print(heros[:,1]) #获取所有行 第二列 print(heros[:,2]) #获取所有行 前二列 print(heros[:,::2]) #获取所有行;所有列，步长为2 >>>： [['苏轼' '廉颇'] ['后羿' '狄仁杰']] ◆访问多维数组 及其元素 arr_1 = np.array([ #一栋房子三层，两行，四列 [ ["苏烈","程咬金","廉颇","亚瑟"], ["后羿","公孙离","狄仁杰","鲁班"], ], [ ["王昭君","安其拉","貂蝉","小乔"], ["孙膑","大乔","鬼谷子","蔡文姬"] ], [ ["王lang","刘邦","刘备","孙悟空"], ["相遇","刘禅","周庄","东皇太一"] ] ]) print(arr_1[2][1][3]) #获取第三层第二行第四列。>>>：东皇太一 print(arr_1[0,1,:]) #获取第一层第二行所有值。>>>：['后羿' '公孙离' '狄仁杰' '鲁班'] print(arr_1[0,1,::2]) #获取第一层第二行步长为2。>>>：['后羿' '狄仁杰']4.1.3 访问数组元素 [ index ]
◆每个维度都可以指定一个索引数组 x = np.arange(10,19).reshape((3,3)) idx1 = [0,1,2] idx2 = [2,1,0] print ('原数组：\n',x) print ('获取\n',x[idx1,idx2]) ◆每个维度都可以指定一个多维索引数组 x = np.arange(10,19).reshape((3,3)) idx1 = np.arange([[0,0],[1,1]]) idx2 = np.arange([[2,1],[2,1]]) print ('原数组：\n',x) print ('获取\n',x[idx1,idx2]) ◆增加维度：newaxis:将原数组作为新的更高维数组中的一个切片 x = np.arange(6).reshape((2,3)) y = x[:,:,np.newaxis] #将二维数组的第三维作为1，形成三维数组 print (y) print (y.shape) ◆ 网格函数ix_ 以二维网格为例，假设x是一个二维数组 x[np.ix_]4.2 ndarray操作数组维度
4.2.1改变ndarray 形状
通过reshape方法改变 ndarray 形状 numpy.reshape(arr1,newshape,order='C') #arr1: 需要改变形状的数组 #newshape:新的形状tuple，其中有一个维度为-1，会根据数组总长和其它维度计算出来 #order: 以这个顺序来读取arr1中的元素，可选值{'C','F','A'} 通过 resize 方法改变 ndarray 形状 numpy.resize(arr1,newshape) arr1.resize(newshape,refcheck=True)print('---------------------修改多维数组---------------------') line = np.arange(24) print(line) 方法1 result = line.reshape(2,3,4) #操作数组的投影（视图）（先复制，再修改） print(result) 方法2 line.shape = (2,3,4) #直接修改数组的形状 print(line) 方法3 line.resize(2,3,4) #修改数组的形状 print(line) print('---------------将三维数组展平成一位数组-------------') d3 = np.arange(24).reshape(2,3,4) d1 = d3.ravel() #直接修改数组 print(d3) d2 = d3.flatten() #操作数组的投影（视图）（先复制，再修改） print(d2)4.2.2 ndarray数组合并
方法 用途 row_stack(tup) 多个一维array当作行，合并成2维（行拼接）== vstack（效果一样） column_stack(tup) 多个一维array当作列，合并成2维（列拼接）==hstack（效果一样） vstack(tup) 沿第一个维度合并（行拼接） hstack(tup) 沿第二个维度合并（列拼接） 通用公式 concatenate(tup,axis=0/1) 沿着指定维度合并 4.2.3 ndarray数组拆分
方法 用途 hsplit(arr,indices) 拆分多列 vsplit(arr,indices) 拆成多行 split(arr,indices,axis=0) 通用公式 沿着指定方向拆分 4.3 bool 数组
创建布尔（bool）数组
直接创建: x = np.array([True,False,True,False]) print (x) >>> [True,False,True,False] 通过比较操作符计算得到： x = np.arange(6).reshape((2,3)) print (x>3) # 运算符 >>> [False,False,False] [False,True,True] 通过通用函数计算 x = np.arange(6).reshape((2,3)) print np.greater(x,3) #使用numpy函数创建 >>> [False,False,False] [False,True,True]
五、ndarray 数组运算
5.1 算术运算：
+，-，/，*，//(floor division整除),**(幂)，%(取模) 算数运算都是针对相同位置的元素进行的。 更新运算符：+=，-=，*=，/=，**=5.2 比较运算：
同算术运算，返回bool值 还可以通过通用函数：算术函数 来进行计算5.3 判断：
np.all(alltrue) 判断array 是否所有元素都为True np.any(sometrue) 判断array 是否至少有一个True5.4 聚合计算：沿着一个指定维度计算汇总
np.average 加权平均值（arr1 , weights = arr2） np.mean 算术平均值（arr1） np.median 计算中位数 np.sum 求和 np.prod 求乘积（阶乘） np.cumprod 数组的累积乘积 np.min 求最小 np.max 求最大 np.bincount 计算每个元素出现的次数5.5 查找和排列
np.argmin 沿指定维度查找最小值下标 np.argmax 沿指定维度查找最大值下标 np.nonzero 查找非零元素的下标 np.where（condition） 根据条件查找或替换 np.take(column,index) #根据索引获取值 np.argsort 沿着指定维度计算下标，按这个下标元素是递增的 np.sort 沿指定维度 元素按递增顺序排序 np.lexsort 根据多个array进行排序5.6 数组的修剪
用clip()函数计算：将所有比给定最大值num1还大的元素全部设为num1， 而所有比给定最小值num2还小的元素全部设为给定的最小值num2arr1. clip(num1,num2) arr1= [0 1 2 3 4] Clipped [1 1 2 2 2]5.7 数组的压缩
利用compres ()函数计算：返回一个根据给定条件筛选后的数组。
六、线性代数
6.1矩阵的创建 np.mat( ) / np.bmat( )
import numpy as np mat1 = np.mat('1 2 3 4;5 6 7 8;9 11 12 13') #创建矩阵,方法1 mat2 = np.mat(np.arange(9)).reshape(3,3) #创建矩阵，方法2 print(mat1) print(mat2) >>> #输出mat1 [[ 1 2 3 4] [ 5 6 7 8] [ 9 11 12 13]] >>> #输出mat2 [[0 1 2] [3 4 5] [6 7 8]] ---------------------------------------------------- A = np.eye(3,3) B = A*2 mat3 = np.bmat("A B;B A") print(A,"\n") print(B,"\n") print(mat3) >>> #输出 A 矩阵 [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]] >>> 输出 B 矩阵 [[2. 0. 0.] [0. 2. 0.] [0. 0. 2.]] >>> 输出 mat3 矩阵 [[1. 0. 0. 2. 0. 0.] [0. 1. 0. 0. 2. 0.] [0. 0. 1. 0. 0. 2.] [2. 0. 0. 1. 0. 0.] [0. 2. 0. 0. 1. 0.] [0. 0. 2. 0. 0. 1.]]6.2 创建随机数矩阵函数
6.3 矩阵统计函数
6.4 一元通用函数：
函数 说明 abs、fabs 计算整数、浮点数或复数的绝对值。对于非复教值．可以使用更快的fabs sqrt 计算各元素的平方根。相当于 arr**0.5 square 计算各元素的平方。相当于 arr**2 exp 计算各元素的指数e**x log、log10、 log2 、log1p 分别为自然对数（底数为e）、底数为10的log、底数为2的log、log(1+x) sign 计算各元素的正负号：1 (正数)、 O(零)、-1（负数） ceil 计算各元素的ceiling值．即大于等于该值的最小整数 floor 计算各元素的floor值．即小于等于该值的最大整数 rint 将各元素值四含五入到．接近的整数．保留dtype modf 将数组的小数和整数部分以两个独立数组的形式返回 isnan 返回一个表示“哪些值是NaN（这不是一个数字）”的布尔型救组 isfinite 、isinf 分别返回一个表示“哪些元紊是有穷的（非inf.非 NaN )”或“哪些元素是无穷的”的布尔型数组 cos 、cosh 、sin、sinh、tan、tanh 普通型和双曲型三角函 arccos、arccosh、arcsin 反三角函数 6.5 二元通用函数：
函数 说明 add 将数组中对应的元素相加 subtract 从第一个数组中减去第二个数组中的元素 multiply 数组元索相乘 divide、floor_divide 除法或向下取整除法（丢弃余数 ） power 对第一个救组中的元素，根据第二个数组中的相应元索B ，计算AB. max、fmax 元素级的最大值计算。 fmax 将忽峪 NaN min、fmix 元素级的最小值计林。 fmin 将忽略 NaN mod 元素级的求模计算（除法的余数） copysign 将第二个数组中的值的符号复制给第一个数组中的值 greater、greater_equal、less、less_equal、equal Not_qual 执行元素级的比较运算，最终产生布尔型数组。相当于中缀运算符 >，>=，<，<=，==．!= logical_add、logical_or、 Logical_xor 执行元素级的直值逻辑运算。相当于中缀运算符＆、 6.6 自定义函数 zero_like:
a = np.array(np.arange(9)).reshape(3,3) def ultimate_answer(a): result = np.zeros_like(a) result.flat = 42 return result function_like = np.frompyfunc(ultimate_answer,1,1) text=function_like(a) print(text)6.7 四种自定义求和函数
a = np.arange(9) print("Reduce", np.add.reduce(a)) >>>36 print("Accumulate", np.add.accumulate(a)) >>>[ 0 1 3 6 10 15 21 28 36] print("Reduceat", np.add.reduceat(a, [0, 5, 2, 7])) >>>[10 5 20 15] #第一步用到索引值列表中的0和5，对数组中索引值在0到5之间的元素进行reduce操作 得到10 #第二步用到索引值5和2。由于2比5小，所以直接返回索引值为5的元素 得到5 #第三步用到索引值2和7。对索引值在2到7之间的数组元素进行reduce操作 得到20 #第四步用到索引值7。对索引值从7开始直到数组末端的元素进行reduce操作 得到15 print("Outer", np.add.outer(np.arange(1,3), a)) >>>[[ 1 2 3 4 5 6 7 8 9] >>>[ 2 3 4 5 6 7 8 9 10]] #返回1+a数组的每个元素； #返回2+a数组的每个元素。6.8
numpy.linalg模块主要函数
序号 函数及描述 1. dot 两个数组的点积 2. vdot 两个向量的点积 3. inner 两个数组的内积 4. matmul 两个数组的矩阵积 5. determinant 数组的行列式 6. solve 求解线性矩阵方程 7. inv 寻找矩阵的乘法逆矩阵 print('------------逆矩阵与单位矩阵---------------') import numpy as np A = np.mat("0 1 2;1 0 3;4 -3 8") print("A=",A) inverse = np.linalg.inv(A) print(u"A的逆矩阵：","\n",inverse) I = A*inverse print('单位矩阵:I = A*inverse：',"\n",I) >>> A= [[ 0 1 2] [ 1 0 3] [ 4 -3 8]] A的逆矩阵： [[-4.5 7. -1.5] [-2. 4. -1. ] [ 1.5 -2. 0.5]] 单位矩阵:I = A*inverse： [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]使用 np.linalg.solve(A, b) 求解线性方程组
A= np.mat("1 -2 1;0 2 -8;-4 5 9") B= np.array([0,8,-9]) C = np.linalg.solve(A,B) print("X=",C[0],"Y=", C[1],"Z=", C[2]) >>> X= 29.0 Y= 16.0 Z= 3.06.9 特征值、特征向量
Arr =np.mat("3 -2;1 0") print("单独求特征值：",np.linalg.eigvals(Arr)) print("特征值，特征向量：",np.linalg.eig(Arr)) >>> 单独求特征值： [2. 1.] 特征值，特征向量： (array([2., 1.]), matrix([[0.89442719, 0.70710678], [0.4472136 , 0.70710678]]))6.10奇异值分解
print('----------------SVD奇异值分解---------------') Arr2 = np.mat("4 11 14;8 7 -2") U,Sigma,V = np.linalg.svd(Arr2,full_matrices=False) print("U",U) print("Sigma",Sigma) print("V",V) >>> U [[-0.9486833 -0.31622777] [-0.31622777 0.9486833 ]] Sigma [18.97366596 9.48683298] V [[-0.33333333 -0.66666667 -0.66666667] [ 0.66666667 0.33333333 -0.66666667]]6.11 计算矩阵的行列式
print('----------矩阵行列式的计算-----------') Arr3 = np.mat("3 4;5 6") print("矩阵行列式的计算：",np.linalg.det(Arr3)) >>> 矩阵行列式的计算： -2.0000000000000013
七、排序函数
排序
7.1、 ndarray类的sort方法——可对数组进行原地排序； np.sort(-arr , axis=1)降序排序 7.2、 argsort函数——返回输入数组排序后的下标； np.argsort(-arr,axis=1)降序排序 7.3、 sort函数——返回排序后的数组print('----------------ndarray排序-----------------') list1 = [[3,1,2],[5,7,0]] array1 = np.array(list1) array1.sort(axis=1) print(array1) >>> [[1 2 3] [0 5 7]] print("------------返回排序后的索引值----------------") list1 = [[3,1,2],[5,7,0]] array1 = np.array(list1) array2 = np.argsort(array1,axis=0) #返回列索引 array3 = np.argsort(array1,axis=1) #返回行索引 print("array2:",array2) print("array3:",array3) >>> array2:[[0 0 1] [1 1 0]] array3:[[1 2 0] [2 0 1]]
八、搜索函数
常用搜索函数
◆ argmax函数： 返回数组中最大值对应的下标 ◆ nanargmax函数： 与argmax提供相同的功能，但忽略NaN值 ◆ argmin函数： 返回数组中最小值对应的下标 ◆ nanargmin函数： 与argmin的功能类似， 但忽略NaN值 ◆ argwhere函数： 根据条件搜索非零的元素，并分组返回对应的下标 ◆ searchsorted函数：为指定的插入值寻找维持数组排序的索引位置。该函数使用二分print('----------返回最大值的索引----------') arr_a = np.array([[3,1,2],[5,7,0]]) print(np.argmax(arr_a)) #先将多维数组展平，再返回最大值的索引 print("------argwhere返回对应的下标-----") arr_a = np.array([[3,1,2],[5,7,0]]) print(np.argwhere(arr_a>3)) >>> [[1 0] #第二行第一列 [1 1]] #第二行第二列 print('-----searchsorted()为指定的插入值寻找维持数组排序的索引位置----') arr_b = np.arange(5) arr_insert = np.searchsorted(arr_b,[-1,7]) print("插入后：",np.insert(arr_b,arr_insert,[-1,7])) >>> 插入后： [-1 0 1 2 3 4 7]
九、数组元素抽取
9.1、 extract函数——根据某个条件从数组中抽取元素 9.2、 nonzero函数——专门用来抽取非零的数组元素print('-----------元素抽取-------------') arr_ele = np.arange(8) condition =(arr_ele%2) ==0 print("抽取能被2整除的元素：",np.extract(condition,arr_ele)) print("非零值：",np.nonzero(arr_ele)) >> 抽取能被2整除的元素： [0 2 4 6] 非零值： (array([1, 2, 3, 4, 5, 6, 7], dtype=int64),) print('-----------元素抽取(condition)-------------') arr_ele = np.arange(8) arr_fa = arr_ele.compress(condition=(arr_ele%2) ==0) print("抽取能被2整除的元素",arr_fa) print('-----------元素抽取(where)-------------') arr_ele = np.arange(8) arr_fa = np.where((arr_ele%2) ==0) print("抽取能被2整除的元素",arr_fa) print('---------非零元素索引提取----------') arr = np.array([[0,1,3], [0,4,7], [7,0,9]]) row,col = np.nonzero(arr) print("非零元素行索引row_index",row) print("非零元素列索引col_index",col)
十、金融函数
fv 函数——计算所谓的终值（future value），某个金融资产在未来某一时间点的价值。 pv 函数——计算现值（present value），即金融资产当前的价值。 npv 函数——计算净现值（net present value），即按折现率计算的净现金流之和。 pmt 函数——根据本金和利率计算每期需支付的金额。(payment) nper函数——计算定期付款的期数。 rate函数——计算利率（rate of interest）。 1. 某用户去银行存款，假设年利率3%、每季度续存金额 -------------计算fv 10元、存5年以及存款1000，则计算5年后可领取多少金额 分析： rate : 0.03/4 nper : 5*4 pmt : -10 pv : -1000 fv : 存款终值是本息和 贷款终值是0import numpy as np print("Future value",np.fv(0.03/4,5*4,-10,-1000)) fvals = [] for i in range(1,6): fvals.append(np.fv(.03/4,i*4,-10,-1000)) print('第{}年的本息和是{}'.format(i,fvals[i-1])) >>> Future value 1376.0963320407982 第1年的本息和是1070.7914448828128 第2年的本息和是1143.7306449093103 第3年的本息和是1218.8827612322955 第4年的本息和是1296.3149319412119 第5年的本息和是1376.09633204079822.某用户去银行存款，假设年利率3%、每季度续存金额10--------------计算pv 元、存5年后可领1376.0963320，则计算5年前存取的本金是多少金额pv = np.pv(0.03/4,5*4,-10,1376.096) print("当初存钱：",np.round(pv)) --np.round()四舍五入 >>> 当初存钱： -1000.03.投资100，支出39、 59、 55、 20。 折现率为28.1%，则净现值为多少？---计算npvprint("npv:",np.npv(0.281,[-100,39,59,55,20]))----rate:折现率；values:现金流 >>> npv: -0.008478591638454884.某同学房贷20万，准备15年还清，年利率为7.5%，则每月需还贷多少金额 ----计算pmtprint("每月需还贷金额为:",np.pmt(0.075/12,12*15,200000)) >>> 每月需还贷金额为: -1854.02472000546195.某同学房贷20万，年利率为7.5%，每月能还贷2000，则需要还多少期?-------计算nperyear = np.ceil(np.nper(0.075/12,-2000,200000)/12)------np.ceil：向上取整 print("需要还贷{}年。".format(year)) >>> 需要还贷14.0年。
十一、广播
让两个不同维度的 array进行元素运算 若维数较小的array增加1的维度，直到两者维数相等x = np.arange(6).reshape((2,3)) y = np.arange(9).reshape((3,3)) x[:,np.newaxis,:]+y array([ [[0,2,4], [3,5,7], [6,8,10]] [[3,5,7], [6,8,10], [9,11,13]] ])
十二、array数组copy
完全不拷贝
赋值时，只是引用x = np.array([1,2,3,4]) y = x y is x True浅拷贝(copy视图/投影) 视图会创建一个新 array 对象，但和原来的 array 共享同一份数据 创建视图：ndarray.view/通过切片 判断一个array是否为视图 ndarray.flags.owndata 示例：#通过ndarray.view 创建 x = np.array([1,2,3,4]) y = x.view() print 'y.flags.owndata:',y.flags.owndata print 'y.base is x:',y.base is x y.flags.owndata:False y.base is x:True深拷贝：完全copy。 创建新拷贝 --ndarray.copy() --通过索引数组和布尔数组获取新的array（又称为Fancy Indexing）