numpy模块（详解）

• 重点
  • 索引和切片
  • 级联
  • 聚合操作
  • 统计操作
  • 矩阵

什么是数据分析

• 是把隐藏在一些看似杂乱无章的数据背后的信息提炼出来，总结出所研究对象的内在规律
• 数据分析是用适当的方法对收集来的大量数据进行分析，帮助人们做出判断，以便采取适当的行动
  • 商品采购量的多少
  • 总部向各个地区代理的发货量

为什么学习数据分析

• 有岗位的需求
• 是Python数据科学的基础
• 是机器学习课程的基础

数据分析实现流程

• 提出问题
• 准备数据
• 分析数据
• 获得结论
• 成果可视化

数据分析三剑客

• numpy
• pandas
• matplotlib

numpy模块

• NumPy(Numerical Python) 是 Python 语言中做科学计算的基础库。重在于数值计算，也是大部分Python科学计算库的基础，多用于在大型、多维数组上执行的数值运算。
• numpy当成是一个一维或者多维的数组

numpy的创建

• 使用np.array()创建

• 使用plt创建

• 使用np的routines函数创建

• 使用array()创建一个一维数组

import numpy as np
arr = np.array([1,2,3,4,5])

# 结果：
array([1, 2, 3, 4, 5])

• 使用array()创建一个多维数组

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

# 结果:
array([[1, 2, 3],
       [4, 5, 6]])

• 数组和列表的区别是什么？

  • 列表中可以存储不同类型的数据

  • 数组中存储的数据元素类型必须一致

    str > float > int 数据类型的优先级

np.array([[1,2,3],[4,'five',6]])

# 如果在一个整数的数组中插入一个字符串，然后就会将全部的数据元素都转换成字符串
# 结果：
array([['1', '2', '3'],
       ['4', 'five', '6']], dtype='<U11')

• 将外部的一张图片读取加载到numpy数组中，然后尝试改变数组元素的数值查看对原始图片的影响

import matplotlib.pyplot as plt
#图片数据的读取
img_arr = plt.imread('./1.jpg')

#将一个三维的numpy数组显示成一张图片
plt.imshow(img_arr-100)

# img_arr-100 会对每个这个照片中的每一个数值进行减100

​ 可以看出在对这个照片的数值进行修改之后，照片的颜色发生了改变；

下边numpy模块对应的一些方法

• zeros() -------- 生成一个自定义的元素都为0的数组
• ones() -------- 生成一个自定义的元素都为1的数组
• linespace() ---------- 生成多少个一维等差数列
• arange() ---------- 生成以某个值为差的一维等差数列
• random系列 ----------- 生成随机数组，

np.zeros(shape=(3,3))

# 结果：
array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])

np.ones(shape=(3,4)

# 结果
array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

np.linspace(0,100,num=20)   #  一维等差数列

# 结果：
array([  0.        ,   5.26315789,  10.52631579,  15.78947368,
        21.05263158,  26.31578947,  31.57894737,  36.84210526,
        42.10526316,  47.36842105,  52.63157895,  57.89473684,
        63.15789474,  68.42105263,  73.68421053,  78.94736842,
        84.21052632,  89.47368421,  94.73684211, 100.        ])

np.arange(0,100,2)   #  一维等差数列

# 结果：
array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32,
       34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66,
       68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98])

np.random.randint(0,80,size=(5,8))

# 结果：
array([[29,  8, 73,  0, 40, 36, 16, 11],
       [54, 62, 33, 72, 78, 49, 51, 54],
       [77, 69, 13, 25, 13, 30, 30, 12],
       [65, 31, 57, 36, 27, 18, 77, 22],
       [23, 11, 28, 74,  9, 15, 18, 71]])

size里边的值是行和列，相当于二维，里边每增加一个数就会则增加一个维度

np.random.random(size=(3,4))

# 结果：
array([[0.0768555 , 0.85304299, 0.43998746, 0.12195415],
       [0.73173462, 0.13878247, 0.76688005, 0.83198977],
       [0.30977806, 0.59758229, 0.87239246, 0.98302087]])

下面的是一个三维数组：

np.random.random(size=(2,3,4))

# 结果：
array([[[0.88291734, 0.1809206 , 0.35617448, 0.3049914 ],
        [0.72609875, 0.26811569, 0.34519581, 0.35372182],
        [0.26311417, 0.54276554, 0.2561482 , 0.30583742]],

       [[0.0986709 , 0.82136811, 0.41041769, 0.4089922 ],
        [0.5390292 , 0.60816895, 0.5686751 , 0.07936629],
        [0.98708008, 0.36585268, 0.30857405, 0.40176834]]])

• 随机因子(系统时间)：无时无刻都在变化的值
  • 随机因子固定下来，随机性就固定

#固定随机性
np.random.seed(10)#固定时间种子
np.random.randint(0,100,size=(2,3))

# 结果：
array([[ 9, 15, 64],
       [28, 89, 93]])

numpy的常用属性

• shape ------------------ 形状（重点）
• ndim ------------------ 维度数
• size ------------------- 数组的长度
• dtype -------------------- 数组元素的类型（重点）

arr = np.random.randint(0,100,size=(5,6))

# 结果：
array([[88, 11, 17, 46,  7, 75],
       [28, 33, 84, 96, 88, 44],
       [ 5,  4, 71, 88, 88, 50],
       [54, 34, 15, 77, 88, 15],
       [ 6, 85, 22, 11, 12, 92]])

下边是这些属性的作用展示：

arr.shape
# 结果：
	(5, 6)

arr.ndim
# 结果：
	2

arr.size
# 结果：
	30

arr.dtype
# 结果：
	dtype('int32')

查看一下arr是什么类型

type(arr)

# 结果：
numpy.ndarray

numpy的数据类型(数组元素的类型)

• array(dtype=?) 可以设定数据类型
• arr.dtype = '?' 可以修改数据类型

#通过dtype修改数据的数据类型
arr.dtype = 'int16'

# 结果：
dtype('int16')

numpy的索引和切片操作（重点）

• 意义：可以让我们取出numpy数组中任意指定的局部数据

• 索引操作和列表同理

arr = np.random.randint(0,100,size=(3,4))

# 生成的数组
array([[ 1, 61, 28,  6],
       [85, 87, 91,  3],
       [ 6, 98, 91, 54]])

arr[1] 			#取一行
# 结果：
array([85, 87, 91,  3])

arr[[1,2]]	#取多行
# 结果：
array([[ 1, 61, 28,  6],
       [85, 87, 91,  3]])

• 切片操作
  • 切出前两列数据
  • 切出前两行数据
  • 切出前两行的前两列的数据
  • 数组数据翻转
  • 练习：将一张图片上下左右进行翻转操作
  • 练习：将图片进行指定区域的裁剪

#切出前两行数据
arr[0:2]

array([[ 1, 61, 28,  6],
       [85, 87, 91,  3]])

#切出前两列数据
#arr[hang,lie]

arr[:,:2]

array([[ 1, 61],
       [85, 87],
       [ 6, 98]])

#切出前两行的前两列的数据
arr[:2,:2]

array([[ 1, 61],
       [85, 87]])

#列反转
arr[:,::-1]

array([[ 6, 28, 61,  1],
       [ 3, 91, 87, 85],
       [54, 91, 98,  6]])

#行反转
arr[::-1]

array([[ 6, 98, 91, 54],
       [85, 87, 91,  3],
       [ 1, 61, 28,  6]])

#元素反转
arr[::-1,::-1]

array([[54, 91, 98,  6],
       [ 3, 91, 87, 85],
       [ 6, 28, 61,  1]])

img_arr.shape

(554, 554, 3)

#将一张图片反转
plt.imshow(img_arr[::-1,::-1,::-1])

<matplotlib.image.AxesImage at 0x224149be4e0>

变形reshape

arr = np.array([[1,2,3],[4,5,6]])
arr.shape

(2, 3)

#将多维变一维
arr_1 = arr.reshape((6,))

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

#一维变多维
arr_1.reshape((6,1))

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

arr_1.reshape((3,-1))   #-1表示自动计算行或者列数

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

级联操作：待级联的数组维度必须保持一致

• 就是将多个numpy数组进行横向或者纵向的拼接
• axis轴向的理解

arr = np.array([[1,2,3],[4,5,6]])
n_arr = arr
display(arr,n_arr)

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

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

• 匹配级联
  • 进行级联的多个数组的形状是完全一样

# axis=0 等于0表示列，等于1表示行
np.concatenate((arr,n_arr),axis=0)
# 按列匹配级联
array([[1, 2, 3],
       [4, 5, 6],
       [1, 2, 3],
       [4, 5, 6]])

• 不匹配级联
  • 维度一致，但是行列个数不一致
    • 横向级联：保证行数一致
    • 纵向级联：保证列数一致

np.concatenate((a,arr),axis=1)

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

让照片按九宫格显示：

arr_3 = np.concatenate((img_arr,img_arr,img_arr),axis=1)
arr_9 = np.concatenate((arr_3,arr_3,arr_3),axis=0)
plt.imshow(arr_9)

<matplotlib.image.AxesImage at 0x224145d9978>

广播机制

• 广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。

x = np.array([[2,2,3],[1,2,3]])
y = np.array([[1,1,3],[2,2,4]])
display(x,y)

array([[2, 2, 3],
       [1, 2, 3]])

array([[1, 1, 3],
       [2, 2, 4]])

x+y

array([[3, 3, 6],
       [3, 4, 7]])

arr1 = np.array([[0, 0, 0],[1, 1, 1],[2, 2, 2], [3, 3, 3]])
# arr1.shape = (4,3)
arr2 = np.array([1, 2, 3])
display(arr1,arr2)

array([[0, 0, 0],
       [1, 1, 1],
       [2, 2, 2],
       [3, 3, 3]])

array([1, 2, 3])

arr1 + arr2

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

• 广播的规则：
  • 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
  • 输出数组的形状是输入数组形状的各个维度上的最大值。
  • 如果输入数组的某个维度和待计算数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
  • 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。
    
    

常用的聚合操作

• sum,max,min,mean

arr = np.array([[8,20,5],[6,52,45]])

# 对每一行求和
arr.sum(axis=1)
array([ 33, 103])

# 求每一行的最大值
arr.max(axis=1)
array([20, 52])

# 求每一列的最小值
arr.min(axis=0)
array([ 6, 20,  5])

# 求每一列的平均值
arr.mean(axis=0)
array([ 7., 36., 25.])

常用的数学函数

• NumPy 提供了标准的三角函数：sin()、cos()、tan()
• numpy.around(a,decimals) 函数返回指定数字的四舍五入值。
  • 参数说明：
    • a: 数组
    • decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置

arr = np.array([[8,20,5],[6,52,45]])

np.sin(arr)

array([[ 0.98935825,  0.91294525, -0.95892427],
       [-0.2794155 ,  0.98662759,  0.85090352]])

arr = np.array([1.4,4.7,5.2])

array([1.4, 4.7, 5.2])

np.around(arr,decimals=0)    #对小数进行四舍五入

array([1., 5., 5.])

np.around(arr,decimals=-1)    # 最对小数点的前一位进行四舍五入

array([ 0.,  0., 10.])

常用的统计函数

• numpy.amin() 和 numpy.amax()，用于计算数组中的元素沿指定轴的最小、最大值。
• numpy.ptp():计算数组中元素最大值与最小值的差（最大值 - 最小值）。
• numpy.median() 函数用于计算数组 a 中元素的中位数（中值）
• 标准差std():标准差是一组数据平均值分散程度的一种度量。
  • 公式：std = sqrt(mean((x - x.mean())**2))
  • 如果数组是 [1，2，3，4]，则其平均值为 2.5。 因此，差的平方是 [2.25,0.25,0.25,2.25]，并且其平均值的平方根除以 4，即 sqrt(5/4) ，结果为 1.1180339887498949。
• 方差var()：统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())** 2)。换句话说，标准差是方差的平方根。

arr = np.random.randint(60,100,size=(5,3))

array([[92, 75, 93],
       [85, 69, 97],
       [60, 78, 83],
       [63, 89, 76],
       [80, 78, 74]])

np.amin(arr,axis=1)

array([75, 69, 60, 63, 74])

np.ptp(arr,axis=0)

array([32, 20, 23])

np.median(arr,axis=0)

array([80., 78., 83.])

#标准差:std = sqrt(mean((x - x.mean())**2))
arr = np.array([1,2,3,4,5])
((arr - arr.mean())**2).mean()**0.5

1.4142135623730951

arr.std()

1.4142135623730951

#方差：mean((x - x.mean())**2)
arr.var()

2.0

矩阵相关

• 必须要掌握：

  • 矩阵是什么
  • 单位矩阵
  • 转置矩阵
  • 矩阵的乘法运算

• NumPy 中包含了一个矩阵库 numpy.matlib，该模块中的函数返回的是一个矩阵，而不是 ndarray 对象。一个 的矩阵是一个由行（row）列（column）元素排列成的矩形阵列。

• matlib.empty() 函数返回一个新的矩阵，语法格式为：numpy.matlib.empty(shape, dtype)，填充为随机数据

  • 参数介绍：
    • shape: 定义新矩阵形状的整数或整数元组
    • Dtype: 可选，数据类型

import numpy.matlib as matlib
matlib.empty(shape=(5,6))

matrix([[1.16302223e-311, 1.16302228e-311, 1.16302223e-311,
         1.16302226e-311, 1.16302223e-311, 1.16302226e-311],
        [1.16302356e-311, 1.16302355e-311, 1.16302226e-311,
         1.16302222e-311, 1.16302222e-311, 1.16302226e-311],
        [1.16302223e-311, 1.16302223e-311, 1.16302747e-311,
         1.16302356e-311, 1.16302747e-311, 1.16302228e-311],
        [1.16302223e-311, 1.16302223e-311, 1.16302356e-311,
         1.16302449e-311, 1.16302228e-311, 1.16302228e-311],
        [1.16302364e-311, 1.16302364e-311, 1.16302226e-311,
         1.16302278e-311, 1.16302228e-311, 1.16302228e-311]])

• numpy.matlib.zeros()，numpy.matlib.ones()返回填充为0或者1的矩阵

matlib.ones(shape=(3,4))

matrix([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])

• numpy.matlib.eye() 函数返回一个矩阵，对角线元素为 1，其他位置为零。

  • numpy.matlib.eye(n, M,k, dtype)
    • n: 返回矩阵的行数
    • M: 返回矩阵的列数，默认为 n
    • k: 对角线的索引
    • dtype: 数据类型

• 单位矩阵：

  • 行列数一致且对角线值为1其他值为0的矩阵

matlib.eye(n=5,M=4,k=0)

matrix([[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 0., 0., 1.],
        [0., 0., 0., 0.]])

matlib.eye(n=5,M=5,k=2)
matrix([[0., 0., 1., 0., 0.],
        [0., 0., 0., 1., 0.],
        [0., 0., 0., 0., 1.],
        [0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.]])
# 当k的值变化时，矩阵的对角线在移动

• numpy.matlib.identity() 函数返回给定大小的单位矩阵。单位矩阵是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为 1，除此以外全都为 0。

matlib.identity(5)

matrix([[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.]])

• 转置矩阵:行 -> 列，列 -> 行
  • .T

arr = np.random.randint(0,100,size=(5,5))

array([[51, 79, 17, 50, 53],
       [25, 48, 17, 32, 81],
       [80, 41, 90, 12, 30],
       [81, 17, 16,  0, 31],
       [73, 64, 38, 22, 96]]

arr.T

array([[51, 25, 80, 81, 73],
       [79, 48, 41, 17, 64],
       [17, 17, 90, 16, 38],
       [50, 32, 12,  0, 22],
       [53, 81, 30, 31, 96]])

• 矩阵相乘

  • numpy.dot(a, b, out=None)

    • a : ndarray 数组
    • b : ndarray 数组

    

  • 第一个矩阵第一行的每个数字（2和1），各自乘以第二个矩阵第一列对应位置的数字（1和1），然后将乘积相加（ 2 x 1 + 1 x 1），得到结果矩阵左上角的那个值3。也就是说，结果矩阵第m行与第n列交叉位置的那个值，等于第一个矩阵第m行与第二个矩阵第n列，对应位置的每个值的乘积之和。

  • 线性代数基于矩阵的推导：

    • https://www.cnblogs.com/alantu2018/p/8528299.html

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

array([[2, 1],
       [4, 3]])

array([[1, 2],
       [1, 0]])

np.dot(a,b)

array([[3, 4],
       [7, 8]])