Numpy

数据分析：是把隐藏在一些看似杂乱无章的数据背后的信息提炼出来，总结出所研究对象的内在规律

numpy 简介

NumPy（Numerical Python）是Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

模块导入：import numpu as np

ndarray 创建数组

shift + Tab 打开帮助文档

一维数组：np.array(序列) 数组内可存放任意容器型数据类型及 range() 对象

np.array([1, 2, 3])    # 列表转换为数组
# [1, 2, 3]

二维数组：np.array(序列嵌套) 容器嵌套几层就是几维

np.array([[1, 2, 3], [4, 5, 6]])
# [[1, 2, 3]
#  [4, 5, 6]]

注意：numpy默认数组的所有元素的类型是相同的，如果传进来的序列中包含不同的类型，则强转为同一类型，优先级：str > float > int

等差数组：np.arange(start, stop, step, dtype=None)（类似range）
- start（可选）：起始值，默认值为 0
- stop：结束值，实际取值要 +1
- step（可选）：步长值，设浮点型小数，默认值为 1

单值：np.arange(5) 			# [0 1 2 3 4]
双值：np.arange(1, 10, 2)		# [1 3 5 7 9]
三值：np.arange(2, 0, -0.5)	# (6, 5, 4)

等差数列：在指定的间隔内返回均匀间隔的数字

语法：np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
- start：序列的起始点
- stop：序列的终点，实际取值要 +1
- num（可选）：生成的样本数，默认值 50
- endpoint（可选）：属性设置是否包括结束值，endpoint=False不包括，默认True包括
- retstep：如果为真，则返回（数组，步长）
- dtype（可选）：输出数组的类型，如果未给定dtype，则从其他输入参数中推断数据类型

np.linspace(0, 10, 10, endpoint=False)
# [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

zeros 全0 、ones 全1数组
- 全0的一维数组：np.zeros(列)
- 全0的二维数组：np.zeros((行, 列))

np.zeros(3)		# [0. 0. 0.]
np.zeros((2,3))
# [[0. 0. 0.]
#  [0. 0. 0.]]

单位矩阵：返回一个n行 * n列的对角阵，对角线元素为1，其余为0

np.identity(3)	# 三行三列
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]

随机数组：np.random.randint(low, high=None, size=None, dtype='int')
- low：随机范围的最小值
- high：随机范围的最大值
- size：范围的个数，可设为指定行列

np.random.seed(10)  # 设定值则不再变化
np.random.randint(0, 50, (2,4))
# [[13  7 34 43]
#  [15 43 31 48]]
np.random.random((2,3))	# 随机0到1之间，指定两行三列
# [[0.56344919 0.82741278 0.35153991]
#  [0.83255027 0.86214153 0.61376901]]

ndarray的索引切片

使用下标和切片形式来访问数组中的某个或多个元素

索引：用于非连贯性的元素取值

取单行：[行]（单值默认是行索引）

取指定多行：[[行, 行]]

取单元素：[行][列] 等价 [行, 列]

取多个元素：[[行,行],[列,列]]（一个行对应一个列）

a = np.array(([1,2,3],[4,5,6],[7,8,9]))
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
a[0]		# [1 2 3]
a[0][2]     # 3
a[0,2]		# 3
a[[0,2,1],[2,1,0]]     # [3 8 4]
a[[0,2]]	# 取第一行和最后一行

切片：用于有规律或连贯性的元素取值（切片尾索引要 +1）

取行：[行:行] （几行到几行）

取切块：[行:行,列:列]（以逗号分隔维度，左边行切片，右边列切片）

嵌套切片：[[行,行],列:列]

a = np.array(([1,2,3],[4,5,6],[7,8,9]))
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
a[:2]		# 取前两行
a[:,2]		# 取最后一列
a[1:,:2]	# 取后二行的前两列
a[[0,2],1:]	# 混合嵌套索引加切片
# [[2 3]
#  [8 9]]

步长：同切片逗号机制，一维数组操作同列表切片

行倒序：[::-1]（所有行位置反转，列元素反转）

列倒序：[:,::-1]（所有列位置反转，行元素反转）

全部倒叙：[::-1,::-1]（按对角线反转）

a = np.array(([1,2,3],[4,5,6],[7,8,9]))
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
a[[0,2],::2]	# 指定行，列切片步长
# [[1 3]
#  [7 9]]
a[::2,[0,2]]	# 行切片步长，指定列
# [[1 3]
#  [7 9]]

naarray的元素增改

追加：np.arange(a, 元素)
插入：np.insert(a, 索引, 元素)

注意：都返回为新数组；可增加多个元素写为[元素,元素] ；如果是二维数组则合并成一维数组后再增加

a = np.arange(8)      # [0,1,2,3,4,5,6,7]
np.append(a,8)      	# 追加单元素8
np.append(a,[9,10])     # 追加9和10
np.insert(a,2,[4,5])	# 在索引2插入4和5

修改：使用下标的形式修改原数组的元素值

a = np.array([[1,2,3],[4,5,6]])
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
a[0,2] = 9		# 改第0行第2列的元素为9
a[1:,1:] = [1,2]	# 修改的元素对应复用
# [[1 2 3]
#  [4 1 2]
#  [7 1 2]]
a[1:,1:] = [1,2],[3,4]	# 改为二维数组对应的值
# [[1 2 3]
#  [4 1 2]
#  [7 3 4]]

ndarray的常用操作

ndarray的属性

维度：a.ndim（返回数组是几维）

形状：a.shape（返回一个元组：(行, 列, 维度)）

总长度：a.size

元素类型：a.dtype（int32表示32位的整型）

排序求值

axis：0 求每列的和，1 求每行的和，默认所有元素（以下参数同可使用）

求和：a.sum(axis=None)
最大最小值：a.max()/a.min()
平均值：a.mean()
排序：a.sort()（升序）

其他操作

最大值、最小值元素的下标：a.argmax()/a.argmin()
返回排序后元素的原下标：a.argsort()（从小到大）

改变数组的形状

改变形状（必须匹配现有元素的个数）

改变原数组：a.shape = 行, 列（-1表示自动计算，行与列只能有一个）
返回新数组：a.reshape(行, 列) 单参数为行

a = np.arange(1,9)		# [ 1  2  3  4  5  6  7  8]
a1 = a.reshape(-1,4)	# 行自动计算，指定4列
# [[1 2 3 4]
#  [5 6 7 8]]

改变形状进行增减元素

改变原数组：a.resize(行, 列)（元素不够用零补充）
返回新数组：np.resize(a, (行, 列))（元素不够用循环原元素补充）

a = np.array([[1, 2, 3], [4, 5, 6]])
np.resize(a,(3,4))		# 循环原始数据补充
# [[1 2 3 4]
#  [5 6 1 2]
#  [3 4 5 6]]

数组转置：b.T（使原先的行变成列，一维数组不变）

b = np.array(([1,2,3],[4,5,6],[7,8,9]))
# [[1 2 3]			# [[1 4 7]
#  [4 5 6]	  -->	#  [2 5 8]
#  [7 8 9]]			#  [3 6 9]]

数组的级联：np.concatenate((a1,a2),axis=1)

a：两个数组
axis：级联的轴向（0：与列拼接，1：与行拼接）

a = np.random.randint(10, 50, (2,3))
# [[13 17 34]
#  [15 43 31]]
np.concatenate((a,a),axis=1) 
# [[13 17 34 13 17 34]
#  [15 43 31 15 43 31]]

注意：

维度必须相同
级联的参数是列表：一定要加中括号或小括号
形状相符：在维度保持一致的前提下，如果进行与行级联，俩的数组行数必须一致，列亦是

数组的运算

所有算数运算符都可使用，可返回新数组

数组与标量的运算：分别对每个元素进行运算

a = np.array([[1,2,3],[4,5,6]])
a - 2			# 每一位都减2
# [[-1  0  1]
#  [ 2  3  4]]
2 ** a			# 分别计算每一位
# [[ 2  4  8]
#  [16 32 64]]

数组与数组的运算
- 等长数组相运算：返回新数组为两个数组对应位置上元素相运算的结果
- 不等长数组相运算：只允许单元素数组（同与标量运算）

a = np.array([1,2,3,4])	# [1,2,3,4]
a + a	# [5 5 5 5]
a ** a	# [1 4 9 16]
a * np.array([2])	# [2 4 6 8]

数组的内积运算

内积：两数组互与对应位上的数相乘，所有位上的乘积相加的和

计算两个数组的内积：np.dot(数组1, 数组2)

x = np.array((1,2,3))
y = np.array((4,5,6))
print(np.dot(x, y))		# 32
print(sum(x * y))		# 32

测试元素

测试两个数组的对应元素是否足够接近：测试两个数组中对应位置上元素在允许的误差范围内是否相等，并可以接收绝对误差参数和相对误差参数

isclose()：函数用来测试每一对元素是否相等并返回包含若干True/False的列表
allclose()：函数用来测试所有对应位置上的元素是否都相等并返回单个True或False

语法：isclose(a1, a2, rtol=1e-05, atol=1e-08)（allcolse同语法）
- a：两个数组
- rtol：设置相对误差参数
- atol：设置绝对误差参数

x=np.array([1,2,3,4.001,5])
y=np.array([1,1.999,3,4.01,5.1])
np.allclose(x,y)            # false
np.allclose(x,y,rtol=0.2)   # True
np.isclose(x,y)  # [ True False True False False]
np.isclose(x,y,atol=0.2)    # [ True  True  True  True  True]