1.numpy入门介绍

 NumPy(Numerical Python) 是 Python 语言的一个扩展程序库,支持大量的维度数组与矩阵运算,此外也针对数组运算提供大量的数学函数库。NumPy 是一个运行速度非常快的数学库,主要用于数组计算,包含:一个强大的N维数组对象 ndarray;广播功能函数;整合 C/C++/Fortran 代码的工具;线性代数、傅里叶变换、随机数生成等功能等。

NumPy 通常与 SciPy(Scientific Python)和 Matplotlib(绘图库)一起使用, 这种组合广泛用于替代 MatLab,是一个强大的科学计算环境,有助于我们通过 Python 学习数据科学或者机器学习。SciPy 是一个开源的 Python 算法库和数学工具包。SciPy 包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。

Matplotlib 是 Python 编程语言及其数值数学扩展包 NumPy 的可视化操作界面。它为利用通用的图形用户界面工具包,如 Tkinter, wxPython, Qt 或 GTK+ 向应用程序嵌入式绘图提供了应用程序接口(API)。

numeric python 数字化的python()

numpy中最重要的一个形式叫ndarray:n dimension array 工程数学(线性代数)​。零维度:标量  1;一维:向量   [1,2,3,4,5,6];二维:矩阵   A=[[1,2,3],[1,2,3]]  A.shape(2x3);三维及以上:张量  。Python 本身支持的数值类型有 int(整型,python2 中存在 long 长整型)、float(浮点型)、bool(布尔型) 和 complex(复数型)。​而 Numpy 支持比 Python 本身更为丰富的数值类型,细分如下:​

 1 '''
 2 1. bool:布尔类型,1 个字节,值为 True 或 False。
 3 2. int:整数类型,通常为 int64 或 int32 。
 4 3. intc:与 C 里的 int 相同,通常为 int32 或 int64。
 5 4. intp:用于索引,通常为 int32 或 int64。
 6 5. int8:字节(从 -128 到 127) tinyint(tinyint 1字节 -2 ^7 ~ 2^7-1 (-128~127))
 7 6. int16:整数(从 -32768 到 32767) smallint(smallint 2字节 -2 ^15 ~ 2^15-1 (-32768~32765))
 8 7. int32:整数(从 -2147483648 到 2147483647) int(int 4字节 -2 ^31~ 2^31-1 (-2147483648~2147483647))
 9 8. int64:整数(从 -9223372036854775808 到 9223372036854775807) bigint(bigint 8字节 -2 ^63 ~ 2^63-1)
10 9. uint8:无符号整数(从 0 到 255) unsigned
11 10. uint16:无符号整数(从 0 到 65535)
12 11. uint32:无符号整数(从 0 到 4294967295)
13 12. uint64:无符号整数(从 0 到 18446744073709551615)
14 13. float:float64 的简写。
15 14. float16:半精度浮点,5 位指数,10 位尾数
16 15. float32:单精度浮点,8 位指数,23 位尾数
17 16. float64:双精度浮点,11 位指数,52 位尾数
18 17. complex:complex128 的简写。
19 18. complex64:复数,由两个 32 位浮点表示。
20 19. complex128:复数,由两个 64 位浮点表示。
21 '''

在 Numpy 中,上面提到的这些数值类型都被归于 dtype(data-type数据类型) 对象的实例。​我们可以用 numpy.dtype(object, align, copy) 来指定数值类型。而在数组里面,可以用 dtype= 参数。

 

numpy创建数组:

1). np.ndarray(shape [, dtype] ):随机生成一个ndarray。

2). np.array(object [dtype=None, copy=True, order=None, subok=False, ndmin=0] ):列表或元组转换为ndarray数组;object:表示列表或元组等,dtype:数据类型(如未给出,则类型为被保存对象所需的最小类型),copy:布尔来写,默认 True,表复制对象。

3). np.arange(start, stop [, step, dtype=None] ):生成一个有规律增长的一维数组,在给定区间内创建一系列均匀间隔的值,[开始,停止)半开半闭区间。step:步长用于设置值之间的间隔。dtype可以设置返回ndarray 的值类型。

4). np.linsapce(start, stop [, num=50, endpoint=True, retstep=False, dtype=None] ):生成一个有规律增长的一维数组,和arange方法很像,在指定的区间内返回间隔均匀的值,全闭区间。start:序列的起始值; stop:序列的结束值;num:生成的样本数。默认值为50;endpoint:布尔值,如果为真,则最后一个样本包含在序列内;retstep:布尔值,如果为真,返回间距;dtype:数组的类型。

5). np.ones(shape[, dtype=None, order='C']):生成一个元素全部都为1的数组;shape:用于指定数组形状,例如(1,2)或 3。 dtype:数据类型。 order:{'C','F'},按行或列方式储存数组。

6). np.zeros(shape, dtype=None, order='C'):生成一个元素全部为0的数组 ,zeros 方法和 ones 方法非常相似。

7). np.full(shape,fill_value=num):自定义填充值的数组;用于创建一个自定义形状的数组,可以自己指定一个值,该值填满整个矩阵 。

8). np.eye(N, M=None, k=0, dtype=<type 'float'>):生成一个单位矩阵,创建一个二维数组,N:输出数组的行数。 M:输出数组的列数。
 其特点是k 对角线上的值为 1,其余值全部为0,k表示从下标第几个开始, k:对角线索引:0(默认)是指主对角线,正值是指上对角线,负值是指下对角线。

9). np.random.randint(low,high,size):生成随机的整数型矩阵,low 表示最小值, high表示最大值,size 是一个元祖类型  size = shape。

10). np.random.randn( ):生成标准的正太分布,没有固定的参数,每多加一个数字,代表多增加一个维度,高斯正太分布=高斯分布 ,分布:是统计学中的。标准的高斯分布 的中间值是0 ,最好的范围是1 -1,超出范围的都是异常值。

11). np.random.random(size):生成0-1之间的元素数组,size 表形状,random随即生产的范围是0-1之间,每个随机数都是一个维度。

12). np.random.rand( ):生成0-1之间的元素数组,和 np.random.random有一样的功能,random 需要 size来描述形状,而rand只需要我们直接给值,通过值的数量来确定形状。

13). np.random.normal(loc,scale,size):生成一个正太分布的数组,location 是定位的的值, scale 是波动值,size 是数据长度。

14). np.logspace(start,stop,num,base=10.0):生一个有规律的求对数的一维数组 ,线性生成,全闭区间,start从几开始 ,stop 到数字结尾, num生成多少个数 默认50,base是底数 默认以10为底。

15). np.diag(v,k=0):生成一个对角矩阵,v可以是一维或二维的矩阵,k<0表示斜线在矩阵的下方,k>0表示斜线在矩阵的上方。

 

代码演示示例:

 1 import numpy as np
 2 
 3 # 1.随机生成一个ndarray
 4 np.ndarray(shape=(5,4,3),dtype=np.uint8)
 5 
 6 # 2.将列表或元组转换为 ndarray 数组
 7 arr1 = np.array([1, 2, 3, 4, 5])            # array([0, 1, 2, 3, 4])
 8 arr2 = np.array((1,2,3,4,5))                # array([0, 1, 2, 3, 4])
 9 np.array(range(5))                          # array([0, 1, 2, 3, 4])
10 
11 # 3.生成一个有规律增长的一维数组,左闭右开区间
12 np.arange(0,10,2,np.float16)                # array([0., 2., 4., 6., 8.], dtype=float16)
13 
14 # 4.生成一个有规律增长的一维数组,全闭区间
15 np.linspace(0,10,num=10,dtype='uint8')      # array([ 0,  1,  2,  3,  4,  5,  6,  7,  8, 10], dtype=uint8)
16 
17 # 5.生成一个元素全部都为1的数组
18 np.ones((10,10))                            # 十行十列全部为 1 的多维数组
19 
20 # 6.生成一个元素全部为0的数组
21 zeros = np.zeros((3,3))                     # 三行三列全为 0 的数组
22 
23 # 7.自定义填充值的数组
24 np.full((3,3),'你好')                        # 三行三列全为‘你好’的数组,dtype='<U2'
25 
26 # 8.生成一个单位矩阵
27 I = np.eye(3)                               # 三行三列对角线为1,其余全为 0 的数组
28 
29 # 9.生成随机的整数型矩阵
30 np.random.randint(low=10,high=150,size=(5,4))  # 生成10-150之间的五行四列整数数组
31 
32 # 10.标准的正太分布
33 np.random.randn(3,3)                       # 三行三列-1~1之间的数组
34 
35 # 11./12.生成0-1之间的元素数组
36 np.random.random(size=(3,3))                # 三行三列0-1之间的元素数组
37 np.random.rand(3,3)                         # 三行三列0-1之间的元素数组
38 
39 # 13.生成一个正太分布的数组
40 np.random.normal(10,scale=10,size=(3,3))    # 生成0-20之间的数,三行三列有异常值的数组
41 
42 # 14.生一个有规律的求对数的一维数组 
43 np.logspace(0,49,base=10.0)                 # 生成50个0-49之间的以10为底的数组
44 #   np.log2(N):底数为二的对数
45 #   np.log10(N):为10的对数
46 
47 # 15.生成一个对角矩阵
48 np.diag([1,2],k=-1)                         # array([[0, 0, 0],
49                                             #        [1, 0, 0],
50                                             #        [0, 2, 0]])   

【补充】:

range()是一个可迭代对象;arange()直接生成一个数组类型

字典可以转变为数组,但是无法使用;arr=np.array({'a':1,"b":2})

零矩阵 = 代数中的0,单位矩阵=代数中的1;主对角线上全为1的矩阵是单位矩阵,单位矩阵必定是一个方阵

线性代数的乘法;线性代数中有+ — × 但是没有除法(逆矩阵),*只能做普通代数乘法,矩阵的乘法是 np.dot(A,B),np.dot():线性代数的乘法,A*B != B*A

 

numpy中的属性:

 1 '''
 2 ndarray.size:查看元素的总量   *****
 3 ndarray.ndim:查看数组的维度
 4 ndarray.shape:查看数组的形状  *****
 5 ndarray.dtype:查看数据类型    *****
 6 ndarray.imag:获取复数的虚数部分
 7 ndarray.real:获取复数的实数部分
 8 ndarray.T:数组的转置
 9 ndarray.itemsize:查看数组占用的字节数
10 ndarray.nbytes:查看数组中每个元素总和的字节数
11 ndarray.strides:数字的递进字节数  数据步长  *****
12 ndarray.transpose():数组的转置
13 ndarray.astype():转变数据类型,但是不会对原数据产生影响
14 '''

 

numpy的索引:

一维数组与列表一样;numpy的索引支持层级索引;index可以重复

 1 B = np.array([[[1,2,3],[4,5,6],[7,8,9]]])
 2 B  # array([[[1, 2, 3],     
 3              [4, 5, 6],
 4              [7, 8, 9]]])
 5 B[0][0][0]   # 1  取出第一行第一列
 6 B[0,0,0]     # 1  取出第一行第一列,这样的层级索引list不支持
 8 
 9 nd = np.arange(10,20)
10 nd                  # array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])  
11 nd[[0,0,0,1,0,0]]   # array([10, 10, 10, 11, 10, 10]) 里面是索引,使用列表的方式可以重复的去获取

 

重设形状 reshape:

reshape 可以在不改变数组数据的同时,改变数组的形状;numpy.reshape(nd,shape) == array.reshape(shape) ;该函数不对原数组产生影响,元素的总量不能改变;如果在reshape写上-1,代表剩余的元素数量;nd.reshape(-1):表示数组的展开。

 1 nd = np.arange(10,20)
 2 nd.shape                 # (10,)
 3 # np.reshape(nd,(2,5)) 相当于 np.reshape(nd,(-1,5)) 相当于nd.reshape((2,5))
 4 np.reshape(nd,(2,5))     #array([[10, 11, 12, 13, 14],
 5                          #       [15, 16, 17, 18, 19]])
 6 # nd.reshape(5,2) 相当于 nd.reshape(5,-1)   
 7 nd.reshape(5,2)
 8        # array([[10, 11],
 9        #       [12, 13],
10        #       [14, 15],
11        #       [16, 17],
12        #       [18, 19]])

 

数组展开 ravel:无论是几维的数组,直接展开变为一维,ndarray.ravel()  ;数组的展开,变成一维数组ndarry.reshape(-1) 。

 

级联 concatenate:

级联就是将多个数组进行合并。axis:轴。axis=1,列合并,行必须相等 x轴的事;axis=0,行合并,列必须相等 y轴的事;np.concatenate((a1,a2,...)):需要被合并的数组可以放在元祖中;np.concatenate([a1,a2,...]):也可以放在列表中。

堆做级联 hstack|vstack。hstack:水平的合并;vstack:垂直的合并。这两个函数中没有axis参数,填入的参数必须被小括号或中括号包裹。水平 np.hstack((nd1,nd2));垂直 np.vstack([nd1,nd2])。

副本:所有赋值运算不会为ndarray的任何元素创建副本。对赋值后的对象的操作也对原来的对象生效。可使用ndarray.copy()函数创建副本。

 

聚合函数:

 1 # axis:轴,轴的排序y-x-z = 0,1,2
 2 # 每一个聚合函数中都有axis,我们可以对指定的维度进行计算
 3 '''
 4 np.sum():求和
 5 np.nansum():将NaN当作0处理
 6 np.max():求最大值
 7 np.min():求最小值
 8 np.mean():均值
 9 np.argmax():找出最大值的索引
10 np.argmin():找出最小值的索引
11 np.std():求标准差
12 np.var():方差
13 np.argwhere():条件查询,并返回符合条件的索引(最好能展开)
14 '''

 

代码演示示例:

 1 # 一维数组
 2 nd1 = np.random.randint(0,10,10)
 3 np.sum(nd1)
 4 nd1.sum()
 5  6 # 二维的数组
 7 nd2 = np.random.randint(0,100,(5,4))
 8 nd3.sum()                      # 求数组元素的总和
 9 nd3.sum(axis=0)                # 将行的值全加和,得到的是列的个数
10 nd3.sum(axis=1)                # 将列的值全加和,得到的是行的个数
11 12 # 三维的数组
13 nd3 = np.random.randint(0,100,(5,4,3))
14 nd3.sum(axis=-1)               # 求最和一维的和
15 nd3.sum(axis=-1).sum(axis=-1)  # 求最后两维的和
16 nd3.sum(axis=(-1,-2))          # 求最后两维的和,axis支持元祖类型的值
17 18 # 求最大值
19 nd3.max()
20 nd3.min(axis=-1)               # 最后一维
21 np.max(nd3,axis=-1)            # 最后一维
22 23 # 求平均值
24 nd3.mean()
25 26 # 返回的是最小数的下标,第一个出现的
27 np.argmin(np.array([0,1,2,3,4,5,6,7,8,9,10,0,0,]))     # 0
28 # 返回的是最大数的下标,第一个出现的
29 np.argmax(np.array([1,2,3,4,5,6,7,8,9,10,10,10]))      # 9
30 31 # argwhere是条件查询的方法,返回符合条件的索引
32 A = np.random.randint(0,100,(4,4))
33 display(A) 
34      # array([[88, 21, 57, 99],
35      #           [54, 10, 42, 92],
36      #           [93,  0,  1, 88],
37      #           [50, 23, 34, 49]])
38 
39 index = np.argwhere(A.ravel()>=50)
40 index.ravel()                 # array([ 0,  2,  3,  4,  7,  8, 11, 12], dtype=int64)
41 
42 # 要想查找某个制定的值,我们可以先展开数组,再展开索引
43 A.ravel()                     # array([88, 21, 57, 99, 54, 10, 42, 92, 93,  0,  1, 88, 50, 23, 34, 49])
44 A.ravel()[index.ravel()]      # array([88, 57, 99, 54, 92, 93, 88, 50])
45 46 # 另一种方式
47 cond = A.ravel()>=50
48 cond       # array([ True, False,  True,  True,  True, False, False,  True,  True, False, False,  True,  True, False, False, False])
49 #如果索引是bool型,值返回结果为True的
50 A.ravel()[cond]      # array([61, 93, 53, 76, 88, 66, 96, 76, 77, 88, 92, 84, 50, 98])

 

注意:NaN != NaN;NaN + 任何数 = NaN

  

数组元素的循环:

 1 # 列表
 2 list_ = [0, 1, 2]
 3 list_*3           # list会循环3次 , [0, 1, 2, 0, 1, 2, 0, 1, 2]
 4 #list_ + 3        # 会报错
 5 
 6 # 数祖
 7 ndarr =  np.array(range(10))
 8 ndarr             # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
 9 ndarr*3           # array([ 0,  3,  6,  9, 12, 15, 18, 21, 24, 27])  向量 × 标量
10 ndarr+3           # array([ 3,  4,  5,  6,  7,  8,  9, 10, 11, 12])
11 ndarr/3           # array([0, 1, 2, 0, 1, 2, 0, 1, 2, 0])
12 np.tile(ndarr,3)  # 将所有的元素循环3次,array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
13 
14 # 二维数组
15 ndarr2 = np.random.randint(0,10,(3,3))
16 ndarr2
17         #array([[7, 7, 8],
18         #       [2, 2, 5],
19         #       [5, 7, 4]])
20 np.tile(ndarr2,3)
21         #array([[7, 7, 8, 7, 7, 8, 7, 7, 8],
22         #       [2, 2, 5, 2, 2, 5, 2, 2, 5],
23         #       [5, 7, 4, 5, 7, 4, 5, 7, 4]])
24 
25 np.repeat(ndarr2,3)         # array([7, 7, 7, 7, 7, 7, 8, 8, 8, 2, 2, 2, 2, 2, 2, 5, 5, 5, 5, 5, 5, 7, 7, 7, 4, 4, 4])
26 np.repeat(ndarr2,3,axis=0)  # 行增加
27 #     array([[7, 7, 8],
28 #           [7, 7, 8],
29 #           [7, 7, 8],
30 #           [2, 2, 5],
31 #           [2, 2, 5],
32 #           [2, 2, 5],
33 #           [5, 7, 4],
34 #           [5, 7, 4],
35 #           [5, 7, 4]])
36 np.repeat(ndarr2,3,axis=1)  # 列增加
37 #    array([[7, 7, 7, 7, 7, 7, 8 , 8 , 8],
38 #           [2, 2, 2, 2, 2, 2, 5 , 5 , 5],
39 #           [5, 5, 5, 7, 7 , 7, 4 , 4 , 4]])

 

ndarray的矩阵操作:

算术运算符:加减乘除。ndarray.dot():矩阵乘法。ndarray.multiply():普通乘法 。np.add():加法,要求行列相同。np.linalg.inv():逆矩阵。

np.add(nd1,nd2)  ==  nd1+nd2   :   普通的加法,将两个矩阵的对应位置进行相加,行列相同

nd1 + 3   :  普通的加法,将矩阵的每个位置都加3

nd1 - 3   :  普通的加法,将矩阵的每个位置都减3

nd1*nd2  ==  np.multiply(nd1,nd2)  : 是普通的乘法,将两个矩阵的对应位置进行相乘法,不是矩阵的乘法

nd1/2  :  普通的除法,将两个矩阵的对应位置都除以2

np.dot(nd1.T,nd2)   #矩阵乘法np.dot()    4*5 dot  5*4 = 4*4
np.dot(nd1,nd2.T)     #矩阵乘法np.dot()    5*4 dot  4*5 = 5*5

矩阵的算术中没有除法,只有逆矩阵。

满秩矩阵(一定要是一个方阵,一个方阵不一定是满秩矩阵,可能是奇异矩阵:a = np.matrix([[1,2],[3,4]])

逆矩阵 : 矩阵自己 × 自己的逆  = 单位 1

a = np.matrix([[1,2],[3,4]])        -------.>   a_inv = np.linalg.inv(a) -------->    np.dot(a,a_inv)    #  1

广播机制:广播机制值得是数组除以或乘以某一个标量,会使得每一个数组元素都乘以或除以该标量 

 

ndarray的排序:

快速排序。np.sort()与ndarray.sort()都可以,但有区别; np.sort()不改变输入ndarray.sort()本地处理,不占用空间,但改变输入

ndarray.sort(axis=-1,kind='quicksort',order=None)

numpy.sort(a,axis=-1,kind='quicksort',order=None)

axis:排序沿着数组的方向,0表示按行,1表示按列;kind:排序的算法,提供了快排、混排、堆排,'quicksort', 'mergesort', 'heapsort' --->  快速  归并排序  堆排序;order:不是指的顺序,以后用的时候再去分析这个。

部分排序。ndarray.partition()  ==  np.partition(a,k),有的时候我们不是对全部数据感兴趣,我们可能只对最小或最大的一部分感兴趣。当k为正时,我们想要得到最小的k个数;当k为负时,我们想要得到最大的k个数。

ndarr3 = np.random.randint(0,20,10)
ndarr3.sort() # 对原数据产生影响
ndarr3[::-1]  # 降序排列

# 部分排序
# 获取最小的5个数
ndarr4 = np.random.randint(0,10000,100)
ndarr4.partition(5)
ndarr4[:5]
# 获取最大的5个数
ndarr4.partition(-5)
ndarr4[::-1][:5]

 

文件 I/O 创建数组
CSV文件:
#方法一:
保存文件
np.savetxt('gb.csv',A)   #没报错就代表成功 A表示一个一维或者二维的数组即可
读取文件
np.loadtxt('gb.csv')

#方法二:
使用 numpy.save  numpy.load 保存和读取:
保存的是.npy类型的文件
保存文件
np.save('a.npy',A)
读取文件
np.load('a.npy')

 

1.numpy入门介绍

全文结束