python数据分析之numpy（一）

python数据分析之Numpy（一）

一、什么是Numpy？

​ NumPy（Numerical Python）是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix）），支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库 [1] 。

二、创建数组

了解了numpy的概念我们就来感受一下一下它的强大吧！

Numpy三种创建数组的方法

1、调用numpy的array()方法将列表转化为数组

arr01 = np.array([1,2,3])
print("array01的类型：",type(arr01)) #array01的类型： <class 'numpy.ndarray'> 
print(arr01)#[1 2 3]

2、调用numpy的array()方法将range对象转化为数组

arr02 =np.array(range(6))
print("array02的类型：",type(arr02),arr02)#array02的类型： <class 'numpy.ndarray'> [0 1 2 3 4 5]

3、调用用numpy的arange()方法生成数组

arr03 = np.arange(10)
print("array03的类型：",type(arr03),arr03)#array03的类型： <class 'numpy.ndarray'> [0 1 2]

三、数组的数据类型

1、Numpy支持多种数据类型

numpy数组支持多种数据类型：
1、整型
类型 代码
int8 i1
int16 i2
int32 i4
int64 i8

2、浮点型
float16 f2
float32 f4
float64 f8

3、复数：complex_ complex64 complex128

4、bool类型：true false

#01、int32
arr04 = np.arange(3)
print(arr04,arr04.dtype) #[0 1 2] int32

#02、float64
data = [random.random() for i in range(10)]
print(data) #[0.4495169679906501, 0.37812776730917963, 0.27453827162750943]

arr05 = np.array(data)
print(arr05,arr05.dtype) #float64

2、Numpy的round()方法

保留几位小数,但是数据类型不变

arr05 = np.round(arr05,3)
print(arr05,arr05.dtype) #[0.44951697 0.37812777 0.27453827] float64

3、指定创建的数组的数据类型

#int8
arr06 = np.arange(10,dtype="i8")
print(arr06,"数据类型：",arr06.dtype) #[0 1 2 3 4 5 6 7 8 9] 数据类型： int64

#float64
arr07 = np.array(range(10),dtype="float64")
print(arr07,arr07.dtype) #[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] float64

arr08 = np.array([1,1,0,0,1,0,1,1],dtype="bool")
print(arr08,arr08.dtype)  #[ True  True False False  True False  True  True] bool

4、修改数组的数据类型

使用astype()方法修改数组的数据类型

arr09 = np.array([2.1,1.6,10.3],dtype="float")
arr09 = arr09.astype("i1")
print(arr09,arr09.dtype) #[ 2  1 10] int8

arr10 = np.array([1,1,0,1,0,0,1])
print(arr10.dtype) #int32
print(arr10.astype("bool")) #[True True False  True False False  True]

四、数组的形状/维度

1、Numpy的shape属性

#1、使用numpy的shape属性可以返回数组的维度
arr11 = np.array(range(10))
print(arr11,arr11.shape)#这是个一维数组，返回的是(10,)表示他是一维数组，有10个元素

arr12 = np.array([[1,2,3],[4,5,6]])
print(arr12,arr12.shape)  #这是个二维三列数组(2, 3)

arr13 = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(arr13,arr13.shape)  #这也是个二维数组(3, 3)

arr14 = np.array([[[1,2],[2,3],[3,4]],[[4,5],[5,6],[7,8]],[[9,10],[11,12],[13,14]],[[15,16],[17,18],[19,20]]])
print(arr14,arr14.shape) #这是个三维数组(4, 3, 2)，4表示有4块数据，3表示每块有三行，2表示每行有2列数据

2、转化数组维度

reshape()方法

这个方法返回的是一个新的数组，原来的数组不变

arr15 = np.array([[[1,2],[2,3],[3,4]],[[4,5],[5,6],[7,8]],[[9,10],[11,12],[13,14]],[[15,16],[17,18],[19,20]]])
arr16 = arr15.reshape((3,8))#将arr15转化为二维数组
print(arr16,arr16.shape) #(3, 8)

arr17 = arr15.reshape((24,))
print(arr17)

#当不知道一个数组的形状时，转化为一维数组的方法一：
t1 = arr15.shape[0]
t2 = arr15.shape[1]
t3 = arr15.shape[2]
arr18 = arr15.reshape(t1*t2*t3,)
print(arr18)

flatten()方法

直接将多维数组转化为一维数组，他是展开，扁平化的意思

#当不知道一个数组的形状时，转化为一维数组的方法：使用方法flatten()方法
arr19 = arr15.flatten()
print(arr19)

五、数组的计算

1、广播原则

规则1：如果两个数组的维度不相同，那么小维度数组的形状将会在最左边补1.

规则2：如果两个数组的形状在任何一个维度上不匹配，那么数组的形状会沿着维度为1扩展以匹配另外一个数组的形状。

规则3：如果两个数组的形状在任何一个维度上都不匹配并且没有任何一个维度为1,那么会引起异常。

2、数组的计算

数组与数的计算

import numpy as np


#创建一个二维三列数组
arr01 = np.array([[1,2,3],[4,5,6],[7,8,9]])
#1、加
n = 5
arr02 = arr01 + n
print(arr02) #[[ 6  7  8] [ 9 10 11] [12 13 14]]

#2、减
arr03 = arr01 - n
print(arr03)#[[-4 -3 -2] [-1  0  1] [ 2  3  4]]

#3、乘
arr04 = arr01 * n
print(arr04)#[[ 5 10 15] [20 25 30] [35 40 45]]

#4、除
arr05 = arr01 / n
print(arr05)#[[0.2 0.4 0.6] [0.8 1.  1.2] [1.4 1.6 1.8]]

数组与数组的计算

1、数组与数组之间可以进行加、减、乘、除、指数、求倒数、求相反数、位运算等

2、数组与数组计算分两类：

​ ①：相同形状的数组 对应相互加减等
②：不同形状的数组 遵循广播原则

①相同形状的数组

#1、形状相同的数组之间的运算
t1 = np.array(range(2,8)).reshape(2,3)
t2 = np.arange(4,10).reshape(2,3)
t01 = t1 - t2
t02 = t1 + t2
t03 = t1 * t2
t04 = t1 / t2
t05 = t1**2
print("t1:",t1)     #t1: [[2 3 4] [5 6 7]]
print("t2:",t2)     #t2: [[4 5 6] [7 8 9]]
print("t01:",t01)   #t01: [[-2 -2 -2] [-2 -2 -2]]
print("t02:",t02)   #t02: [[ 6  8 10] [12 14 16]]
print("t03:",t03)   #t03: [[ 8 15 24] [35 48 63]]
print("t04:",t04.round(2))  #t04: [[0.5  0.6  0.67] [0.71 0.75 0.78]]
print("t05:",t05)  #t05: [[ 4  9 16] [25 36 49]]

②不同形状的数组

#2、形状不同的数组之间的运算，遵循广播法则

#eg1：
a1 = np.arange(2,8).reshape(2,3)
a2 = np.arange(3)
print("a1:",a1) #a1: [[2 3 4] [5 6 7]]
print("a2:",a2) #a2: [0 1 2]
print("a1+a2:",a1 + a2) #a1+a2: [[2 4 6] [5 7 9]]

#eg2：
b1 = np.arange(1,4).reshape(3,1)
b2 = np.arange(3,6)
print("b1:", b1) #b1: [[1] [2] [3]]
print("b2:", b2) #b2: [3 4 5]
print("b1+b2:",b1 + b2)#b1+b2: [[4 5 6] [5 6 7] [6 7 8]]

#eg3：
c1 = np.array([[1,2,8],[2,3,5],[6,7,10]])
c2 = np.array([1,2,3])
print("c1+c2:",c1 + c2) #c1+c2: [[ 2  4 11] [ 3  5  8] [ 7  9 13]]

eg1结果分析：

1、 a1 = [[2 3 4] [5 6 7]] a2 = [0,1,2] 两个数组的形状为 a1.shape=(2,3),a2.shape=(3,)

2、 根据规则1: 数组a2的维度更小，所以在其左边补1,变为a2.shape -> (1,3)，此时a1.shape=(2,3),a2.shape=(1，3),即a1 = [[2 3 4] [5 6 7]] a2 = [[0 1 2]]

3、 根据规则2: a1,a2的形状还是不匹配，所以a2会沿着维度为1的方向扩展，变成a2.shape=(2,3),

即a1 = [[2 3 4] [5 6 7]],a2 = [[0 1 2] [0 1 2]]，现在两个数组的形状匹配了，可以看到它们的最终形状都为(2,3)

eg2结果分析：
1、 b1 = [[1] [2] [3]] b2 = [3,4,5]两个数组的形状为 b1.shape=(3,1),b2.shape=(3,)

2、 根据规则1:数组b2的维度更小，所以在其左边补1,变为b2.shape -> (1,3)，此时b1.shape=(3,1),b2.shape=(1，3),即b1 = [[1] [2] [3] b2 = [[3 4 5]]

3、 根据规则2:b1,b2的形状还是不匹配，所以b1,b2会沿着维度为1的方向扩展，

变成b1.shape=(3,3),b2.shape=(3,3),即b1 = [[1 1 1] [2 2 2] [3 3 3]],b2 = [[3 4 5] [3 4 5] [3 4 5]]

现在两个数组的形状匹配了，可以看到它们的最终形状都为(3,3)

eg3的分析就交给聪明的读者啦