【python实用派---第四章 python进阶之numpy库】

CSQ1660622007

已于 2023-03-18 17:06:45 修改

阅读量341

点赞数 1

文章标签： python numpy

于 2022-11-28 20:16:17 首次发布

本文链接：https://blog.csdn.net/CSQ1660622007/article/details/127409197

版权

python实用派

第一章 python是什么？初始化
 第二章 python基础内容(1)
第三章 python基础内容(2)
第四章 python进阶之numpy库
第五章 python进阶之pandas库
第六章 python进阶之求解器应用–gurobi求解器
第七章 python进阶之求解器应用–cplex求解器
第八章 python进阶之数据可视化篇
第九章 python进阶之爬虫篇

推荐一些网站
Python数据分析
 菜鸟教程
 CSDN
博客园
 知乎
 幻海
…

一. 初识Numpy

Numerical Python的简称，

学习原因：

数据矢量化，操作、运算、高效处理大数组数据
基于NumPy的算法要⽐纯Python快10到100倍（甚⾄更快），并且使⽤的内存更少
实现绘图等功能时，numpy数组更方便进行操作

NumPy本身并没有提供多么⾼级的数据分析功能，理解NumPy数组以及⾯向数组的计算将有助于你更加⾼效地使⽤诸如pandas之类的⼯具。
首先，安装numpy包，可通过以下cmd命令

pip install numpy

亦可通过pycharm简单直接安装。

1. ndarray

NumPy最重要的⼀个特点就是其N维数组对象ndarray，最简单常用的是用来存放向量或矩阵。
在numpy中，可以通过array来创建ndarray对象。

import numpy as np 
a = np.array([1,2,3])  
print (a)
b = np.array([1,2,3], [4,5,6])
#输出结果：
[1 2 3] # 一维数组
[[1 2 3]
 [4 5 6]]  # 二维数组，或者说是矩阵

可以从输出结果中看出，ab是ndarray对象。
numpy 支持的数据类型比 Python 内置的类型要多很多，包括但不限于整数，浮点数，复数等类型

2. numpy数组属性

数组或者说矩阵有很多的属性，通过numpy的属性调用可以很方便的进行查看。包括秩、维度等信息。

ndarray.ndim	秩，即轴的数量或维度的数量
ndarray.shape	数组的维度，对于矩阵，n 行 m 列
ndarray.size	数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype	ndarray 对象的元素类型
ndarray.itemsize	ndarray 对象中每个元素的大小，以字节为单位
......

例如

a = np.array([[1,2,1],[3,2,1],[4,5,2],[7,4,2]])
print(a.ndim,a.shape,a.size)
#输出结果：
2 (4, 3) 12

二. numpy数组操作

1. 创建数组

最简单普遍的方法，将一个列表转为ndarray

data1 = [1,2,54,1,3]
arr1 = np.array(data1, dtype = float, order = 'C')
data2 = [[1,2.2,3], [3,2.3,4], [3,5,6]]
arr2 = np.array(data2, dtype = float, order = 'C')
print(arr1,'\n',arr2)
#输出结果：
[ 1.  2. 54.  1.  3.] 
 [[1.  2.2 3. ]
 [3.  2.3 4. ]
 [3.  5.  6. ]]

np.empty() 方法用来创建一个指定形状（shape）、数据类型（dtype）

np.empty(shape, dtype = float, order = 'C')

arr1 = np.empty(4)
print(arr1)
#输出结果：
[9.38059353e-312 9.38055361e-312 9.38059353e-312 9.38055455e-312] # 一组垃圾值

np.zeros() 方法，创建指定大小的数组，数组元素以 0 来填充：

np.zeros(shape, dtype = float, order = 'C')
arr1 = np.zeros((5,3))
print(arr1)
#输出结果：
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]] # 5行3列的零阵

np.ones()方法，创建指定形状的数组，数组元素以 1 来填充：

np.ones(shape, dtype = None, order = 'C')
arr1 = np.ones((3,3))
print(arr1)
#输出结果：
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]

从数值范围创建数组，arange 函数

np.arange(start, stop, step, dtype)

arr1 = np.arange(10)
print(arr1)
#输出结果：
[0 1 2 3 4 5 6 7 8 9]

创建随机数组

np.random.seed(10)

随机种子问题，在numpy中生成的随机数会根据随机种子的变化进行变化，也就是说其实相同随机种子生成随机数是相同的。
即numpy生成的随机数是伪随机数。

生成均匀分布的随机数

np.random.rand()  0.0到1.0的随机数
1. 当函数括号内没有参数时，则返回一个浮点数；
2. 当函数括号内有一个参数时，则返回秩为1的数组，不能表示向量和矩阵；
3. 当函数括号内有两个及以上参数时，则返回对应维度的数组，能表示向量或矩阵；

np.random.randint(low，high，size，dtype) 任意值范围的整数
参数包括下限上限和维度大小
如：
arr1 = np.random.rand(5)
print(arr1)
arr2 = np.random.randint(2,10,(2,3))
print(arr2)
#输出结果：
[0.85364799 0.52408892 0.39656741 0.01404099 0.694457  ]
[[8 4 5]
 [8 7 4]]

生成正态分布的随机数

np.random.randn(): 生成符合标准正态分布的随机值,参数与rand一样

np.random.normal(loc,scale,size): 任意平均和标准差的正态分布
例如：
arr1 = np.random.randn(2,3)
print(arr1)
arr2 = np.random.normal(2,3,(2,3))
print(arr2)
#输出结果：
[[ 0.26625833  2.27958012 -0.64669878]
 [-0.01635724  0.12323795 -0.57266114]]
[[ 2.24149188  1.13420682 -0.98789745]
 [ 2.0806294   4.9890554   1.74845624]]

生成0~1之间均匀分布的随机数组

np.random.random(size)
例如：
arr1 = np.random.random(2,3)
print(arr1)
# 输出结果：
[[0.35176817 0.15739158 0.14806865]
 [0.64514549 0.96350656 0.74906913]]

生成二项式的随机数

np.random.binomial(n，p，size)
n个样本，每个样本为1的概率为p

arr1 = np.random.binomial(6,0.3,(3,3))
print(arr1)
#输出结果：
[[0 3 3]
 [3 2 3]
 [3 3 3]]

在这里插入一个函数，用于打乱数组中元素

np.random.shuffle(array)

……

2. 操作数组

首先搞清楚一个概念
二维数组中，轴0是行 轴1是列

索引
在索引数组时，与列表的索引有相似之处
主要有如下两种方式

arr1 = np.array([[0,1,2],[2,3,5],[8,9,7]])
a = arr1[1][1:]
b = arr1[1,1:]
print(a)
print(b)
#输出结果：
arr1 = np.array([[0,1,2],[2,3,5],[8,9,7]])
a = arr1[1][1:]
b = arr1[1,1:]
print(a)
print(b)

当只传入一个索引时表示根据行进行索引

此外还有布尔型索引，如下：

names =	np.array(['Bob', 'Joe',	'Will',	'Bob', 'Will', 'Joe', 'Joe'])
data = np.random.random((7,3))
print(data)
print(data[names=='Bob'])
#输出结果：
data
[[0.45883304 0.40009091 0.04369823]
 [0.65280035 0.13590858 0.22567336]
 [0.70409829 0.62968559 0.62654572]
 [0.70934663 0.35361712 0.04988245]
 [0.71362283 0.30990566 0.36194346]
 [0.67490236 0.44211051 0.01873732]
 [0.13475554 0.79391254 0.56470123]]
data[names=='Bob']
[[0.45883304 0.40009091 0.04369823]
 [0.70934663 0.35361712 0.04988245]]

花式索引

arr = np.array([[1,1.1,1.111],[2,2.2,2.22],[3,3.3,3.33]])
print(arr[[2,0]])
print(arr[:,[2,0]])
#输出结果：
arr[[2,0]]:
[[3.    3.3   3.33 ]
 [1.    1.1   1.111]]
arr[:,[2,0]]:
[[1.111 1.   ]
 [2.22  2.   ]
 [3.33  3.   ]]

重塑数组

reshape方法

array.reshape(arr, newshape, order='C') # array表示一个数组

arr1 = np.arange(12)
arr2 = arr1.reshape(3,4)
arr3 = arr1.reshape(2,6)
print(arr1)
print(arr2)
print(arr3)
# 输出结果：
arr1
[ 0  1  2  3  4  5  6  7  8  9 10 11]
arr2
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
arr3
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]

转置

array.T

arr1 = np.arange(12)
arr2 = arr1.reshape(3,4)
arr3 = arr2.T
print(arr2)
print(arr3)
# 输出结果：
arr2
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
arr3
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

满秩方阵求逆

np.linalg.inv()

arr1 = np.array([[1,2],[3,4]])
invA = np.linalg.inv(arr1)
print(invA)
# 输出结果：
[[-2.   1. ]
 [ 1.5 -0.5]]

方阵求行列式值

np.linalg.det(array)

arr1 = np.array([[1,2],[3,4]])
invA = np.linalg.det(arr1)
print(invA)
# 输出结果：
-2.0

展平数组，即压缩为一维数组

array.ravel(order='C')# 'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。

arr1 = np.arange(12)
arr2 = arr1.reshape(3,4)
arr3 = arr2.ravel(order='C')
arr4 = arr2.ravel(order='F')
print(arr2)
print(arr3)
print(arr4)
#输出结果：
arr2:
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
arr3:
[ 0  1  2  3  4  5  6  7  8  9 10 11]
arr4:
[ 0  4  8  1  5  9  2  6 10  3  7 11]

3. 数学函数

广播式运算
如果两个数组 a 和 b 形状相同，那么 a（加减乘除）b 的结果就是 a 与 b 数组对应位运算。这要求维数相同，且各维度的长度相同。
当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制

加减乘除(按位运算，对应位置进行计算)

arr1 = np.array([[1,2,3],[4,5,6],[7,8,9]])
arr2 = np.array([[1,1,1],[2,2,2],[3,3,3]])
print(arr1+arr2)
[[ 2  3  4]
 [ 6  7  8]
 [10 11 12]]
print(arr1-arr2)
[[0 1 2]
 [2 3 4]
 [4 5 6]]
print(arr1*arr2)
[[ 1  2  3]
 [ 8 10 12]
 [21 24 27]]
print(arr1/arr2)
[[1.         2.         3.        ]
 [2.         2.5        3.        ]
 [2.33333333 2.66666667 3.        ]]

当运算中的 2 个数组的形状不同时 广播

arr1 = np.array([[1,2,3],[4,5,6],[7,8,9]])
arr2 = np.array([1,1,1])
print(arr1+arr2)
[[ 2  3  4]
 [ 5  6  7]
 [ 8  9 10]]
print(arr1-arr2)
[[0 1 2]
 [3 4 5]
 [6 7 8]]
print(arr1*arr2)
[[1 2 3]
 [4 5 6]
 [7 8 9]]
print(arr1/arr2)
[[1. 2. 3.]
 [4. 5. 6.]
 [7. 8. 9.]]

矩阵运算
矩阵乘法np.dot()

arr1 = np.array([[1,2,3],
				 [4,5,6],
				 [7,8,9]])
arr2 = np.array([[1,1,1],
				 [2,2,2],
				 [3,3,3]])
arr3 = np.dot(arr1,arr2)
print(arr3)
[[14 14 14]
 [32 32 32]
 [50 50 50]]

三角函数
np.sin(array)
np.cos(array)
np.tan(array)
其他一些函数
np.sqrt(a) 对每个元素开方
np.abs(a) 对每个元素取绝对值

4. 数组统计信息

axis=0表示沿着行轴方向，axis=0表示沿着列轴方向

函数	代码
求和	array.sum(axis) axis=0为行，1为列，空为全部
求平均	array.mean(axis) axis=0为行，1为列，空为全部
最大值	array.max(axis) axis=0为行，1为列，空为全部
最小值	array.min(axis) axis=0为行，1为列，空为全部
最大值所在索引	array.argmax(axis) axis=0为行，1为列，空为全部
最小值所在索引	array.argmin(axis) axis=0为行，1为列，空为全部
标准差	array.std(axis) axis=0为行，1为列，空为全部
方差	array.var(axis) axis=0为行，1为列，空为全部
所有元素的累计积	array.cumprod(axis) axis=0为行，1为列，空为全部
所有元素的累计和	array.cumsum(axis) axis=0为行，1为列，空为全部

三. 进阶操作

1. numpy.where()

numpy.where() 函数返回输入数组中满足给定条件的元素的索引。

arr1 = np.array([[1,2,3],
				 [4,5,6],
				 [7,8,9]])
pos = np.where(arr1>5)
print(pos)
print(arr1[pos])
#输出结果：
(array([1, 2, 2, 2], dtype=int64), array([2, 0, 1, 2], dtype=int64))

[6 7 8 9]

2. 连接数组

函数	说明
np.concatenate((array1,array2,…),axis)	连接沿现有轴的数组序列
np.stack((array1,array2,…),axis)	沿着新的轴加入一系列数组。
np.hstack((array1,array2,…))	水平堆叠序列中的数组（列方向）
np.vstack((array1,array2,…))	竖直堆叠序列中的数组（行方向）

arr1 = np.array([[1,2,3],
				 [4,5,6],
				 [7,8,9]])
arr2 = np.array([[10,11,12],
				 [13,14,15],
				 [16,17,18]])
arr3 = np.concatenate((arr1,arr2), axis=0)
arr4 = np.concatenate((arr1,arr2), axis=1)
print(arr3)
print(arr4)
#输出结果：
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]
 [13 14 15]
 [16 17 18]]
[[ 1  2  3 10 11 12]
 [ 4  5  6 13 14 15]
 [ 7  8  9 16 17 18]]

arr1 = np.array([[1,2,3],
				 [4,5,6],
				 [7,8,9]])
arr2 = np.array([[10,11,12],
				 [13,14,15],
				 [16,17,18]])
arr3 = np.stack((arr1,arr2), axis=0)
arr4 = np.stack((arr1,arr2), axis=1)
print(arr3)
print(arr4)
#输出结果：
[[[ 1  2  3]
  [ 4  5  6]
  [ 7  8  9]]

 [[10 11 12]
  [13 14 15]
  [16 17 18]]]
  
[[[ 1  2  3]
  [10 11 12]]

 [[ 4  5  6]
  [13 14 15]]

 [[ 7  8  9]
  [16 17 18]]]

arr1 = np.array([[1,2,3],
				 [4,5,6],
				 [7,8,9]])
arr2 = np.array([[10,11,12],
				 [13,14,15],
				 [16,17,18]])
arr3 = np.vstack((arr1,arr2))
arr4 = np.hstack((arr1,arr2))
print(arr3)
print(arr4)
#输出结果：
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]
 [13 14 15]
 [16 17 18]]
[[ 1  2  3 10 11 12]
 [ 4  5  6 13 14 15]
 [ 7  8  9 16 17 18]]