numpy 知识点总结

原文

一、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.ndarray

1.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: 要创建的数组每个维度的大小
1
2
3
创建数组(一维/多维)

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” ,详情如下图。
1
2
3

三、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', '=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)
1
2
3
4
5
6
7
8
9
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]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
五、ndarray 数组运算

5.1 算术运算:

    +,-,/,*,//(floor division整除),**(幂),%(取模)
    算数运算都是针对相同位置的元素进行的。
    更新运算符:+=,-=,*=,/=,**=
1
2
3
5.2 比较运算:

    同算术运算,返回bool值
    还可以通过通用函数:算术函数 来进行计算
1
2
5.3 判断:

    np.all(alltrue)    判断array 是否所有元素都为True
    np.any(sometrue)   判断array 是否至少有一个True
1
2
5.4 聚合计算:沿着一个指定维度计算汇总

    np.average     加权平均值(arr1 , weights = arr2)
    np.mean        算术平均值(arr1)
    np.median      计算中位数
    np.sum         求和
    np.prod        求乘积(阶乘)
    np.cumprod     数组的累积乘积
    np.min         求最小
    np.max         求最大

    np.bincount    计算每个元素出现的次数
1
2
3
4
5
6
7
8
9
10
5.5 查找和排列

    np.argmin                沿指定维度查找最小值下标
    np.argmax                沿指定维度查找最大值下标
    np.nonzero               查找非零元素的下标
    np.where(condition)     根据条件查找或替换
    np.take(column,index)    #根据索引获取值
    np.argsort     沿着指定维度计算下标,按这个下标元素是递增的
    np.sort        沿指定维度 元素按递增顺序排序
    np.lexsort     根据多个array进行排序
1
2
3
4
5
6
7
8
5.6 数组的修剪

用clip()函数计算:将所有比给定最大值num1还大的元素全部设为num1,
                而所有比给定最小值num2还小的元素全部设为给定的最小值num2
1
2
arr1. clip(num1,num2)  
arr1= [0 1 2 3 4]  
Clipped [1 1 2 2 2] 
1
2
3
5.7 数组的压缩

    利用compres ()函数计算:返回一个根据给定条件筛选后的数组。
1
六、线性代数

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   反三角函数
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 模块主要函数

函数及描述   演示代码
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) 求解线性方程组
1

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.0

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函数——专门用来抽取非零的数组元素
1
2
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()方法查看包含的array

10.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=,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.]]


十一、金融函数

 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年前存取的本金是多少金额 
1
2
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
1
print("npv:",np.npv(0.281,[-100,39,59,55,20]))----rate:折现率;values:现金流
>>>
npv: -0.00847859163845488

4.某同学房贷20万,准备15年还清,年利率为7.5%,则每月需还贷多少金额 ----计算pmt
1
print("每月需还贷金额为:",np.pmt(0.075/12,12*15,200000))
>>>
每月需还贷金额为: -1854.0247200054619

5.某同学房贷20万,年利率为7.5%,每月能还贷2000,则需要还多少期?-------计算nper
1
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

完全不拷贝 
赋值时,只是引用
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)
--------------------- 


你可能感兴趣的:(numpy 知识点总结)