numpy 库中的一些语法

一、创建Array

1.使用np.array() 由 python list 创建

numpy设计初衷是用与运算的，所以对数据类型进行统一优化
数组：一组【有序】的【类型相同】的数据集合
列表：一组有序的数据的集合
导入numpy库并且改名为np

import numpy as np

注意：

1. numpy默认所有的元素类型是相同的
2. 如果传进来的列表包含不同的类型，则统一为同一类型，优先级： str>float>int

2.使用np的routines函数创建

包含以下常见创建方法：

np.ones(shape,dtype=None,order="C") 
	eg: a1 = np.ones(shape=(3,4),dtype=np.int)
	`array([[1, 1, 1, 1], 
			[1, 1, 1, 1], 
			[1, 1, 1, 1]])`
		a2 = np.ones(shape=(3,3,5))
	array([[[1., 1., 1., 1., 1.],
        	[1., 1., 1., 1., 1.],
        	[1., 1., 1., 1., 1.]],

	       [[1., 1., 1., 1., 1.],
	        [1., 1., 1., 1., 1.],
	        [1., 1., 1., 1., 1.]],

	       [[1., 1., 1., 1., 1.],
	        [1., 1., 1., 1., 1.],
	        [1., 1., 1., 1., 1.]]])

np.zeros(shape,dtype=float,order='C')
eg: np.zeros(shape=(3,4),dtype=np.int)
array([[0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0]])

np.full(shape,fill_value,dtype=None,order='C') 
eg: np.full(shape=(2,3),fill_value=6)
array([[6, 6, 6],
       [6, 6, 6]])

1. shape 创建一个几行几列的矩阵
2. dtype array中数据的数据类型
3. order 对排序进行优化，不需要动
4. np.zeros用0来构造数组
5. np.full 可以使用其他数字来制定数组

np.eye(N,M=None,k=0,dtype=float)对角线为1，其他位置为0
eg: np.eye(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
eg:np.eye(N=5)
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])

np.linspace(start,stop,num=50,endpoint=True,retstep=Flase,dtype=None)
等差数列 关注个数
eg:np.linspace(1,10,3,endoint=False)
array([1., 4., 7.])

np.arange([start,]stop,[setp,]dtype=None) 
等差数列 关注步长
eg:np.arange(1,10,step=2)

1. np.eye 单位矩阵
2. np.liinspace()等差数列，关注个数
3. np.arange() 等差数列 关注步长

np.random.randint(low,high=None,size=None,dtype="l")   
eg:np.random.randint(0,100,size=(3,3))
array([[68,  6, 44],
       [84, 55, 65],
       [44, 28, 84]])

np.random.random(size=None)
eg:np.random.random(size=(3,3))
array([[0.02660097, 0.31529823, 0.32264427],
       [0.06529793, 0.78513825, 0.71073933],
       [0.01590269, 0.28727021, 0.48274496]])
eg:np.random.random(size=(2,2))*100
array([[94.36916264, 53.52048437],
       [27.39634173, 49.80292413]])

numpy 数组的乘法是跟数组内的每一个元素相乘

# 生产一个3*3的矩阵，数据范围是-100到100
eg:np.random.random(size=(3,3))*200-100
array([[-25.3259995 , -80.97630561,  20.6635042 ],
       [ -2.81754949,  73.50729074,  20.40845749],
       [-51.94769768,  41.75444872,  21.89615879]])

正态分布函数

标准正态分布
np.random.randn(d0,d1,....,dn) 
eg:np.random.randn(100)

普通正态分布 生成0-1随机数，左闭右开
loc = 0.0 期望值
scale = 1.0 标准方差
np.random.normal(loc=175,scale=10,size=100))

二，ndarray的属性

四个笔记参数：

• ndim：维度
• shape：形状（各位都的长度）
• size: 总长度
• dtype：元素类型

三.ndarray的基本操作

通过下标访问 
访问第一个元素	n1[0]
访问最后一个元素	n1[-1]
通过下表访问多个元素 	n1[[1,2]]

生成一组随机（索引）
shuffle_index = np.random.permutation(10)
array([4, 0, 8, 5, 6, 1, 3, 9, 2, 7])

n2 = np.arange(0,1000,step=100)
array([  0, 100, 200, 300, 400, 500, 600, 700, 800, 900])

n2[shuffle_index]
array([400, 0, 800, 500, 600, 100, 300, 900, 200, 700])

也可以使用Ture，Flase 方法返回True对应的数据

n3  = [[False,True,False,True,False]]
array([4, 5, 7])

数据过滤

n3[n3>6]
array([9, 7])

BOOL列表访问的时候，其长度必须和访问的数组对应维度的长度一致
numpy 特有的高维数组的访问方式

n3[(1,1,2)]

二维数组的行列访问

行访问与以为数组元素访问完全一致
列访问，先把行访问做切片处理

n = np.random.randint(0,100,size=(3,4,5))
array([[[27, 28, 52, 32,  5],
        [34,  6, 39, 68, 52],
        [88, 65, 40, 18, 13],
        [99, 51,  2, 76,  3]],

       [[84, 25,  9, 41, 63],
        [84, 63, 11, 99,  4],
        [58, 57,  9, 71, 79],
        [61,  6, 70, 23, 67]],

       [[ 0, 67, 97, 65, 58],
        [89, 89, 43, 99,  9],
        [91, 55, 65, 99, 89],
        [ 0, 32, 45, 20, 72]]])

n[[0,1]]
array([[[27, 28, 52, 32,  5],
        [34,  6, 39, 68, 52],
        [88, 65, 40, 18, 13],
        [99, 51,  2, 76,  3]],

       [[84, 25,  9, 41, 63],
        [84, 63, 11, 99,  4],
        [58, 57,  9, 71, 79],
        [61,  6, 70, 23, 67]]])
n[:,[0,1]]
array([[[27, 28, 52, 32,  5],
        [34,  6, 39, 68, 52]],

       [[84, 25,  9, 41, 63],
        [84, 63, 11, 99,  4]],

       [[ 0, 67, 97, 65, 58],
        [89, 89, 43, 99,  9]]])
n[:,:,[0,1]]
array([[[27, 28],
        [34,  6],
        [88, 65],
        [99, 51]],

       [[84, 25],
        [84, 63],
        [58, 57],
        [61,  6]],

       [[ 0, 67],
        [89, 89],
        [91, 55],
        [ 0, 32]]])
#【注意】不能同时使用了两个列表

n2[::-1]
二维数组行反序
n2[:,::-1]
数组列反序

图像也可以通过数组处理

import matplotlib.pyplot as plt
%matplotlib inline
image = plt.imread('ss.jfif')
image.shape
(622, 700, 3)
plt.imshow(image) 正常显示
plt.imshow(image[::-1]) 倒像，行翻转

plt.inshow(image[:,::-1])
列反序，图片y轴翻转

2.切片

一维与列表完全一致，多为时同理

3.变形

使用reshape函数，函数参数是一个tuple！

n = np.random.randint(0,100,size=(10))
array([28, 25, 33, 78, 15, 87, 76, 21, 70,  1])
n.shape
(10,)
n.reshape((10,1))
array([[28],
       [25],
       [33],
       [78],
       [15],
       [87],
       [76],
       [21],
       [70],
       [ 1]])
n.reshape((5,2))
array([[28, 25],
       [33, 78],
       [15, 87],
       [76, 21],
       [70,  1]])
 # -1 自动填充未被指定数值的行或列的值
 

4.级联

np.concatenate()级联需要注意的点：
级联的参数是列表，一定要加中括号或小括号
维度必须相同
形状相符
重点：级联的方向默认是shape这个tuple的第一个值所代表的维度方向
可通过axis参数改变级联的方向

n1 = np.random.randint(0,10,size=5)
n2 = np.random.randint(10,20,size=5)
(array([5, 6, 7, 3, 3]), array([13, 11, 14, 17, 17]))
np.concatenate((n1,n2))
array([ 3,  7,  6,  1,  5, 13, 16, 12, 14, 10])

n1 = np.random.randint(0,10,size=(5,5))
n2 = np.random.randint(10,20,size=(5,5))
array([[5, 8, 4, 3, 7],
       [1, 9, 6, 0, 4],
       [2, 1, 8, 5, 1],
       [2, 2, 6, 7, 7],
       [2, 8, 9, 2, 5]])
array([[10, 17, 14, 16, 19],
       [17, 16, 18, 12, 18],
       [18, 15, 17, 11, 14],
       [19, 16, 13, 16, 13],
       [18, 11, 11, 17, 14]])
np.concatenate((n1,n2),axis=1)
array([[ 5,  8,  4,  3,  7, 10, 17, 14, 16, 19],
       [ 1,  9,  6,  0,  4, 17, 16, 18, 12, 18],
       [ 2,  1,  8,  5,  1, 18, 15, 17, 11, 14],
       [ 2,  2,  6,  7,  7, 19, 16, 13, 16, 13],
       [ 2,  8,  9,  2,  5, 18, 11, 11, 17, 14]])

注意：级联的方向的长度必须一致
np.hstack 与 np.vstack（制定级联方向）
水平级联与垂直级联，处理自己，进行维度的变更

5. 切分

np.split
np.vsplit
np.hsplit
indices_or_sections 拆分方式，可以设置为整数
indices_or_sections [0:3,3:4,4:] <=> [3,4]
[m,n] 《=》 0:m, m:n, n:
np.split(n2,axis=0,indices_or_sections=2)

6. 副本

所有赋值运算不会ndarray的任何元素创建副本，对赋值后的对象的操作也对原来对象生效
可使用copy（）函数创建副本
n = n1.copy（）

四、ndarray的聚合操作

求和：np.sum
最大最小值：np.max/np.min
any() 有True返回True
all() 有False返回False

3. 其他聚合操作
Function Name    NaN-safe Version    Description
	np.sum    np.nansum    Compute sum of elements
	np.prod    np.nanprod    Compute product of elements
	np.mean平均值    np.nanmean    Compute mean of elements
	np.std标准差    np.nanstd    Compute standard deviation
	np.var方差    np.nanvar    Compute variance
	np.min    np.nanmin    Find minimum value
	np.max    np.nanmax    Find maximum value
	np.argmin    np.nanargmin    Find index of minimum value
	np.argmax    np.nanargmax    Find index of maximum value
	np.median    np.nanmedian    Compute median of elements
	np.percentile    np.nanpercentile    Compute rank-based statistics of elements
	np.any    N/A    Evaluate whether any elements are true
	np.all    N/A    Evaluate whether all elements are true
	np.power 幂运算

中位数必须使用np.median(n)
np.argwhere() 求索引位置
ng.argmax() 最大值索引
ng.argmin() 最小值索引
numpy 默认的聚合是所有元素的聚合指标
可以使用axis 控制维度上的聚合指标
使用元祖来指定多个维度的聚合指标
n.sum(axis=(0,1))

五、ndarray的矩阵操作

1. 基本矩阵操作

矩阵相加 直接
n1 + n2
矩阵相乘并不遵守乘法法则
矩阵乘法,保证第一个矩阵的列与第二个矩阵的行相等即可
矩阵的乘法 np.dot()
矩阵的除法可以借助与被除数矩阵的逆矩阵来运算完成
逆矩阵：n1 = np.linalg.inv(n)
np.dot(m,n1)

2. 广播机制

numpy 运算原则
n = np.array(l1)
n+1
这样n里所有元素都加1
【重要】ndarray广播机制的两天规则
规则一：为缺失的元素补充1
规则二:假定确实元素用已有值填充

a = np.arange(3).reshape((3, 1)) 
b = np.arange(3) 
display(a, b)
array([[0],
       [1],
       [2]])
array([0, 1, 2])
a + b
array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4]])

六、ndarray的排序

1.快速排序
np.sort()不改变输入
ndarray.sort() 本地处理，不占用空间，但改变输入
2. 部分排序
np.partition(a,k)

有的时候我们不是对全部数据感兴趣，我们可能只对最小或最大的一部分感兴趣。

当k为正时，我们想要得到最小的k个数
当k为负时，我们想要得到最大的k个数

data = np.random.permutation(10000)
array([1716, 7921, 6115, ..., 7934, 2485, 5195])
np.partition(data, -10)[-10:]
array([9990, 9991, 9992, 9994, 9996, 9999, 9995, 9997, 9993, 9998])