数据分析01 /numpy模块

数据分析01 /数据分析之numpy模块

数据分析01 /数据分析之numpy模块

数据分析：是把隐藏在一些看似杂乱无章的数据背后的信息提炼出来，总结出所研究对象的内在规律；数据分析是用适当的方法对收集来的大量数据进行分析，帮助人们做出判断，以便采取适当的行动

数据分析三剑客：numpy / pandas / matplotlib

1. numpy简介

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

2. numpy的创建

使用np.array()创建

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

代码示例：

import numpy as np
arr = np.array([1,2,3,4,5])
print(arr)
# 结果：
array([1, 2, 3, 4, 5])

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

代码示例：

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

使用plt创建
使用np的routines函数创建
数组和列表的区别

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

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

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

代码示例：
```
np.array([[1,2,3],[4,'five',6]])
# 结果：都转换成了字符串
array([['1', '2', '3'],
       ['4', 'five', '6']], dtype='<U11')
```

3. numpy的方法

zeros()

代码示例：

import numpy as np
arr = np.zeros(shape=(3,4))
print(arr)
# 结果：
array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])

ones()

代码示例：

import numpy as np
arr = np.ones(shape=(3,4))
print(arr)
# 结果：
array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

linespace() / 一维等差数列

import numpy as np
arr = np.linspace(0,100,num=20)
print(arr)
# num：表示个数
# 结果：
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.        ])

arange() / 一维等差数列

import numpy as np
arr = np.arange(0,100,2)
print(arr)
# 结果：
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])

random系列

1.random.randint：整数

import numpy as np
arr = np.random.randint(0,80,size=(5,8))
print(arr)
# 结果：
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]])

2.random.random：0~1之间的小数

import numpy as np
arr = np.random.random(size=(3,4))
print(arr)
# 结果：
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]])

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

# 固定随机性
import numpy as np
np.random.seed(10)  # 固定时间种子
np.random.randint(0,100,size=(2,3))
# 结果：
array([[ 9, 15, 64],
       [28, 89, 93]])

4. numpy的常用属性

创建一个数组

import numpy as np
arr = np.random.randint(0,100,size=(5,6))
print(arr)
# 结果：
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]])

shape/形状（重点）
```
arr.shape
# 结果：(5, 6)
```
ndim/维度数
```
arr.ndim
# 结果：2
```
size/数组的长度
```
arr.size
# 结果：30
```

dtype/数组元素的类型（重点）

arr.dtype
# 结果：dtype('int32')
type(arr)
# 结果：numpy.ndarray

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

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

代码示例：

# 通过dtype修改数据的数据类型
arr.dtype = 'int16'
arr.dtype
# 结果：dtype('int16')

6. numpy的索引和切片操作

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

索引：操作和列表同理

arr[1]   # 取一行
arr[[1,2,3]]   # 取多行

切片：

1.切出前两行数据
```
arr[0:2]
```
2.切出前两列数据
```
arr[:,0:2]
```
反转

1.列反转
```
arr[:,::-1]
```
2.行反转
```
arr[::-1]
```
3.元素反转
```
arr[::-1,::-1]
```

应用：将下载下来的一张图片反转

# 查看图片的形状
img_arr.shape   # (554, 554, 3)
# 将一张图片反转
plt.imshow(img_arr[::-1,::-1,::-1])

7. 变形reshape

创建一个数组

arr = np.array([[1,2,3],[4,5,6]])
arr.shape
print(arr)
# 结果：
array([[1, 2, 3],
       [4, 5, 6]])

将多维变一维

arr_1 = arr.reshape((6,))
print(arr_1)
# 结果：
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]])

8. 级联操作

概念：就是将多个numpy数组进行横向或者纵向的拼接，待级联的数组维度必须保持一致

定义两个数组：

arr = array([[1, 2, 3],
       		[4, 5, 6]])
n_arr = array([[1, 2, 3],
              [4, 5, 6]])
a = array([[1, 2],
       [3, 4]])

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

import numpy as np
np.concatenate((arr,n_arr),axis=0)  # axis=0表示列，axis=1表示行
# 结果：
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)

9. 广播机制

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

两相同shape数组示例：

定义两个数组：

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

进行相加：x+y

# 结果：
array([[3, 3, 6],
       [3, 4, 7]])

两不同shape数组示例：

定义两个数组：

arr1 = array([[0, 0, 0],
              [1, 1, 1],
              [2, 2, 2],
              [3, 3, 3]])
arr2 = array([1, 2, 3])

进行相加：arr1 + arr2

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

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

10. 常用的聚合操作

定义一个数组：

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

sum/求和

arr.sum(axis=1)
# 结果：array([ 6, 15])

max/最大值

arr.max(axis=1)
# 结果：array([ 3, 6])

min/最小值
```
arr.min(axis=1)
# 结果：array([1, 4])
```

mean/平均值

arr.mean(axis=1)
# 结果：array([2., 5.])

11. 常用的数学函数

常用的数学函数：

1.NumPy 提供了标准的三角函数：sin()、cos()、tan()

2.numpy.around(a,decimals) 函数返回指定数字的四舍五入值。

参数说明：a: 数组；decimals: 舍入的小数位数。默认值为0。如果为负，整数将四舍五入到小数点左侧的位置

示例：

arr = np.array([[1,2,3],[4,5,7]])
# 三角函数sin()：
np.sin(arr)
# 结果：
array([[ 0.84147098,  0.90929743,  0.14112001],
       [-0.7568025 , -0.95892427, -0.2794155 ]])
# 四舍五入：
arr = np.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.])

12. 常用的统计函数

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]])
# 定轴最小值:numpy.amin()：
np.amin(arr,axis=1)
# 结果：
array([75, 69, 60, 63, 74])
# 定轴最大值与最小值差：numpy.ptp()
np.ptp(arr,axis=0)
# 结果：
array([32, 20, 23])
# 定轴中值：numpy.median()
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
# 方式二：
arr.std()
# 方差：mean((x - x.mean())**2)
arr.var()

13. 矩阵相关

矩阵：矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合
单位矩阵：从左上角到右下角的对角线称为主对角线上的元素均为1。除此以外全都为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: 数据类型
示例：
```
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.]])
```

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.]])

转置矩阵：行转化列，列转化行

示例：

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列，对应位置的每个值的乘积之和。