转载自：原文：https://blog.csdn.net/wsp_1138886114/article/details/80527863
一、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: 数组元素对应的内存区域
real and imag属性: 复数的实部和虚部属性
flat属性，返回一个numpy.flatiter对象，即可迭代的对象。
二、创建 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： 要创建的数组每个维度的大小
fromfunction()方法可以根据矩阵的行号列号生成矩阵的元素。 例如创建一个矩阵，矩阵中的每个元素都为行号和列号的和。
import numpy as np
def func(i,j):
return i+j
a = np.fromfunction(func,(5,6))
# 第一个参数为指定函数，第二个参数为列表list或元组tuple,说明矩阵的大小
print(a)
# 返回
[[ 0. 1. 2. 3. 4. 5.]
[ 1. 2. 3. 4. 5. 6.]
[ 2. 3. 4. 5. 6. 7.]
[ 3. 4. 5. 6. 7. 8.]
[ 4. 5. 6. 7. 8. 9.]]
#注意这里行号的列号都是从0开始的2.2.1 创建数组（一维/多维）
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” ，详情如下图。2.2.2 fromstring
fromstring()方法可以将字符串转化成ndarray对象，需要将字符串数字化时这个方法比较有用，可以获得字符串的ascii码序列
import numpy as np
a = "abcdef"
b = np.fromstring(a,dtype=np.int8) # 因为一个字符为8位，所以指定dtype为np.int8
print(b) # 返回 [ 97 98 99 100 101 102]
三、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:] 索引>=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) 沿着指定维度合并
堆叠数组
b
array([[ 0, 1, 20, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])
c = b*2
c
array([[ 0, 2, 40, 6, 8, 10],
[12, 14, 16, 18, 20, 22]])
水平叠加
hstack()
np.hstack((b,c))
array([[ 0, 1, 20, 3, 4, 5, 0, 2, 40, 6, 8, 10],
[ 6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 20, 22]])
column_stack()函数以列方式对数组进行叠加，功能类似hstack（）
np.column_stack((b,c))
array([[ 0, 1, 20, 3, 4, 5, 0, 2, 40, 6, 8, 10],
[ 6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 20, 22]])
垂直叠加
vstack()
np.vstack((b,c))
array([[ 0, 1, 20, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11],
[ 0, 2, 40, 6, 8, 10],
[12, 14, 16, 18, 20, 22]])
row_stack()函数以行方式对数组进行叠加，功能类似vstack（）
np.row_stack((b,c))
array([[ 0, 1, 20, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11],
[ 0, 2, 40, 6, 8, 10],
[12, 14, 16, 18, 20, 22]])
concatenate()方法，通过设置axis的值来设置叠加方向
axis=1时，沿水平方向叠加
axis=0时，沿垂直方向叠加
np.concatenate((b,c),axis=1)
array([[ 0, 1, 20, 3, 4, 5, 0, 2, 40, 6, 8, 10],
[ 6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 20, 22]])
np.concatenate((b,c),axis=0)
array([[ 0, 1, 20, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11],
[ 0, 2, 40, 6, 8, 10],
[12, 14, 16, 18, 20, 22]])
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还小的元素全部设为给定的最小值num2
arr1. 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 矩阵统计函数
np.random.normal(loc,scale,size): # loc:均值；scale标准差；size 数据量
loc：float
此概率分布的均值（对应着整个分布的中心centre）
scale：float
此概率分布的标准差（对应于分布的宽度，scale越大越矮胖，scale越小，越瘦高）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 反三角函数
logic_not 计算各元素not x 的真值，相当于-arr
#一元ufunc 的代码：
print '一元ufunc示例'
x = numpy.arange(6)
print x # [0 1 2 3 4 5]
print numpy.square(x) # [ 0 1 4 9 16 25]
x = numpy.array([1.5,1.6,1.7,1.8])
y,z = numpy.modf(x)
print y # [ 0.5 0.6 0.7 0.8]
print z # [ 1. 1. 1. 1.]
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 执行元素级的直值逻辑运算。相当于中缀运算符＆、#二元ufunc代码示例：
print '二元ufunc示例'
x = numpy.array([[1,4],[6,7]])
y = numpy.array([[2,3],[5,8]])
print numpy.maximum(x,y) # [[2,4],[6,8]]
print numpy.minimum(x,y) # [[1,3],[5,7]]
6.5.1 NumPy的where函数使用
np.where(condition, x, y)，第一个参数为一个布尔数组，第二个参数和第三个参数可以是标量也可以是数组。
print 'where函数的使用'
cond = numpy.array([True,False,True,False])
x = numpy.where(cond,-2,2)
print x # [-2 2 -2 2]
cond = numpy.array([1,2,3,4])
x = numpy.where(cond>2,-2,2)
print x # [ 2 2 -2 -2]
y1 = numpy.array([-1,-2,-3,-4])
y2 = numpy.array([1,2,3,4])
x = numpy.where(cond>2,y1,y2) # 长度须匹配
print x # [1,2,-3,-4]
print 'where函数的嵌套使用'
y1 = numpy.array([-1,-2,-3,-4,-5,-6])
y2 = numpy.array([1,2,3,4,5,6])
y3 = numpy.zeros(6)
cond = numpy.array([1,2,3,4,5,6])
x = numpy.where(cond>5,y3,numpy.where(cond>2,y1,y2))
print x # [ 1. 2. -3. -4. -5. 0.]
---------------------
作者：cxmscb
来源：CSDN
原文：https://blog.csdn.net/cxmscb/article/details/54583415
版权声明：本文为博主原创文章，转载请附上博文链接！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 模块主要函数
矩阵的逆
设A是数域上的一个n阶方阵，若在相同数域上存在另一个n阶矩阵B，使得： AB=BA=E。 则我们称B是A的逆矩阵，而A则被称为可逆矩阵。
求矩阵的逆需要先导入numpy.linalg，用linalg的inv函数来求逆。矩阵求逆的条件是矩阵应该是方阵。import numpy as np
import numpy.linalg as lg
a = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(lg.inv(a))
# 结果
[[ -4.50359963e+15 9.00719925e+15 -4.50359963e+15]
[ 9.00719925e+15 -1.80143985e+16 9.00719925e+15]
[ -4.50359963e+15 9.00719925e+15 -4.50359963e+15]]
a = np.eye(3) # 3阶单位矩阵
print(lg.inv(a)) # 单位矩阵的逆为他本身
# 结果
[[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]]
函数及描述 演示代码
dot 两个数组的点积 a = np.array([[1,2],[3,4]]),
b = np.array([[11,12],[13,14]]);
np.dot(a,b)：
[[1*11+2*13, 1*12+2*14],[3*11+4*13, 3*12+4*14]]
vdot 两个向量的点积 a = np.array([[1,2],[3,4]]) ,
b = np.array([[11,12],[13,14]]) ;
np.vdot(a,b)：1*11 + 2*12 + 3*13 + 4*14 = 130
inner 两个数组的内积 np.inner(np.array([1,2,3]),np.array([0,1,0]));
输出：1*0+2*1+3*0
matmul 两个数组的矩阵积 矩阵乘法
determinant 数组的行列式 行列式的det
solve 求解线性矩阵方程
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) 求解线性方程组
6.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)十、ndarray的文件IO
10.1.保存为二进制文件
保存单个 array( .npy文件)
np.save(file,arr,allow_pickle=True,fix_imports=True)
allow_pickle:允许使用pickle的方式保存对象。出于安全性和兼容性考虑，会禁用pickle
安全性：加载一个pickle的数据时，会执行任何代码
兼容性：pickle对象对版本有要求，不同版本python不兼容
保存多个 array(.npz文件)
np.savez(file,*args,**kwargs)
*args:以列表参数的方式指定要保存的array，无法保存array变量名，加载时通过arr_0,arr_1这种方式获取。
**kwargs:以命名参数的方式指定array，加载时可以通过名称获取array
保存多个array并压缩( .npz文件)
np.savez_compressed(file,*args,**kwargs)
10.2 加载二进制文件
np.load(file,mmap_mode=None,allow_pickle=True,fix_imports=True,encoding='ASCII')
mmap_mode:可选值(None,'r+','r','w+','c')。如果不是None，则会用指定的模式把内存块映射为一个file对象。
可以实现访问array中的一部分而不用把整个array导入内存
fix_imports：只在python3中读取python2 生成含pickle对象的文件时有用
encoding： 只在python3中读取python2 生成含pickle对象的文件时有用
可选值有('latin1','ASCII',bytes)
np.load 可以支持。npy和,npz文件的读取
读取.npy文件 直接返回array
读取.npz文件，返回一个NpzFile对象（用完close），可以通过.key()方法查看包含的array10.3 保存为文本文件
np.savetxt(filename,array,fmt= '%.18e',delimiter='',
newline='\n',header='',footer='',comments='#')
-filename: 文件名，若以.gz结尾则自动以gzip压缩
-fmt: 保存格式
-delimiter：分隔符
-newline： 换行符
-header： 首行输出内容
-footer： 末行输出内容
-comments: 在header和footer前插入的字符，表示注释10.4 加载文本文件
np.loadtxt(fname,dtype=<type 'float'>,comments= '#',delimiter=None,
concerters=None,skiprows=0,usecols=None,skiprows=0,uppack=False,ndmin=0)
comments : 在header和footer前插入的字符，表示注释
concerters : 转换函数字典，通过下标key,为每列定义一个转换函数
skiprows : 跳过开头的若干行
usecols : 使用指定列，下标0开始
uppack : 若为 True,可以用变量捕获每一列
ndmin : 最小的维度数
import numpy as np
■ 无参数写读
arr1 = np.random.normal(size=20).reshape(4,5) #创建随机数矩阵
np.savetxt('arr1_file.txt',arr1) #默认分隔符：空格
arr_data1 = np.loadtxt('arr_file.txt')
■ 带参数写读
arr2 = np.random.normal(size=20).reshape(4,5) # 创建随机数矩阵
np.savetxt('arr1_file.txt',arr2,fmt="%d",delimiter=",") # %d: 保存为整数，
# 分隔符：逗号
arr_data2 = np.loadtxt('arr2_file.txt',delimiter=",")
■ 读取文件：
arr3_file.csv文件内容如下：
"姓名","年龄","年级","体重","身高"
"李光",30,12,100,188
"司马光",42,9,120,178
"董卓",56,8,155,184
"项羽",45,9,142,186
arr3_data = np.loadtxt('arr3_file.csv',dtype = np.str,delimiter=",")
arr3_num = arr3_data[1:,1:].astype(np.float)
print(arr3_num)
>>>
[[ 30. 12. 100. 188.]
[ 42. 9. 120. 178.]
[ 56. 8. 155. 184.]
[ 45. 9. 142. 186.]
[ 65. 6. 152. 189.]]
csv加载时间数据,请看这儿☛
十一、金融函数
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 : 存款终值是本息和 贷款终值是0
import 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.0963320407982
2.某用户去银行存款，假设年利率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.0
3.投资100，支出39、 59、 55、 20。 折现率为28.1%，则净现值为多少？---计算npv
print("npv:",np.npv(0.281,[-100,39,59,55,20]))----rate:折现率；values:现金流
>>>
npv: -0.00847859163845488
4.某同学房贷20万，准备15年还清，年利率为7.5%，则每月需还贷多少金额 ----计算pmt
print("每月需还贷金额为:",np.pmt(0.075/12,12*15,200000))
>>>
每月需还贷金额为: -1854.0247200054619
5.某同学房贷20万，年利率为7.5%，每月能还贷2000，则需要还多少期?-------计算nper
year = 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
numpy关于copy有三种情况，完全不复制、视图（view）或者叫浅复制（shadow copy）和深复制（deep copy）。而b = a[:]就属于第二种，即视图，这本质上是一种切片操作（slicing），所有的切片操作返回的都是视图。具体来说，b = a[:]会创建一个新的对象b（所以说 id 和a不一样），但是b的数据完全来自于a，和a保持完全一致，换句话说，b的数据完全由a保管，他们两个的数据变化是一致的，可以看下面的示例:
a = np.arange(4) # array([0, 1, 2, 3])
b = a[:] # array([0, 1, 2, 3])
b.flags.owndata # 返回 False，b 并不保管数据
a.flags.owndata # 返回 True，数据由 a 保管
# 改变 a 同时也影响到 b
a[-1] = 10 # array([0, 1, 2, 10])
b # array([0, 1, 2, 10])
# 改变 b 同时也影响到 a
b[0] = 10 # array([10, 1, 2, 10])
a # array([10, 1, 2, 10])
b = a 和 b = a[:] 的差别就在于后者会创建新的对象，前者不会。两种方式都会导致a和b的数据相互影响。要想不让a的改动影响到b，可以使用深复制：unique_b = a.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）