python数据分析之numpy_numpy 数据分析

numpy是什么？

NumPy（Numerical Python的简称）是Python数值计算最重要的基础包。大多数提供科学计算的包都是用NumPy的数组作为构建基础。

为什么要使用numpy？

1. NumPy是在一个连续的内存块中存储数据，独立于其他Python内置对象。NumPy的C语言编写的算法库可以操作内存，而不必进行类型检查或其它前期工作。
2. 比起Python的内置序列，NumPy数组使用的内存更少。
   NumPy可以在整个数组上执行复杂的计算，而不需要Python的for循环。

print(list1 > list2)
# 挨个比较元素，若大于，则在对应位置上写False
# 相反，则是True
# 输出结果例如：[False True False False]
1
2
3
4

numpy的强大之处

• numpy可以在不用使用for循环的情况下进行多种运算，数组的加减乘除，甚至是比较，都可以很方便的执行

1. 创建numpy数组的方式

1.1 直接使用np.array(列表)

list1 = [1,2,3,4,5,6,7,8,9]
arr1 = np.array(list1)
arr2 = np.array(list('abcdef'))
print(arr1)
print(arr2)
# 计算arr1
print((arr1 + 1)**2)


# 输出

# [1 2 3 4 5 6 7 8 9]
# ['a' 'b' 'c' 'd' 'e' 'f']
# [  4   9  16  25  36  49  64  81 100]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

我们可以发现，只要array()参数中添加list类型，就可以将普通的list类型转换为numpy数组，进而可以进行方便的运算，不需要循环就能计算每个元素的平方。

1.2.用np.arange(beg,end,step)创建numpy数组

# 创建从0到12的数组
arr3 = np.arange(13)
print(arr3)

# 创建从10，到19的数组
arr4 = np.arange(10,20)
print(arr4)

# 创建10,12,14...步长为2的数组
arr5 = np.arange(10,20,2)
print(arr5)

# [ 0  1  2  3  4  5  6  7  8  9 10 11 12]
# [10 11 12 13 14 15 16 17 18 19]
# [10 12 14 16 18]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

除此之外我们还可以查看数组的形状，用numpy数组的shape元素，这个元素返回一个元组，若返回(5,)则是一个带有5个元素的一维数组，若返回(5,6,)，则是一个5 x 6的数组，以此类推

• 可以reshape方法修改一个numpy数组的形状

list1 = np.arange(12).reshape(3,4)
list2 = np.arange(10,22).reshape(3,4)
list3 = list2 - list1

print(list1)
print('-'*20)
print(list2)
print('-'*20)
print(list3)

# 输出

# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
# --------------------
# [[10 11 12 13]
#  [14 15 16 17]
#  [18 19 20 21]]
# --------------------
# [[10 10 10 10]
#  [10 10 10 10]
#  [10 10 10 10]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

1.3.zeros,zeros_like,ones,ones_like,empty,empyty_like

1.3.1.zeros:创建元素值全是0的数组

1.3.2.zeros_like(numpy数组):根据括号中numpy数组的形状，创建元素全是0的数组

arr6 = np.zeros(10)
arr7 = np.zeros((3,3))
arr8 = np.zeros_like(arr7)

print(arr6)
print(arr7)
print(arr8)

# 输出
# [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
# [[0. 0. 0.]
#  [0. 0. 0.]
#  [0. 0. 0.]]
# [[0. 0. 0.]
#  [0. 0. 0.]
#  [0. 0. 0.]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1.3.3.ones和onse_like:和zeros方式一致，只是元素值全部变为1

arr9 = np.ones(10)
arr10 = np.ones((3,3))
arr11= np.ones_like(arr10)

print(arr9)
print(arr10)
print(arr11)

# 输出
# [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
# [[1. 1. 1.]
#  [1. 1. 1.]
#  [1. 1. 1.]]
# [[1. 1. 1.]
#  [1. 1. 1.]
#  [1. 1. 1.]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1.3.4.empty和empty_like:和zeros方式一致，只是元素值全部变为空值，在这里空值占位符是1

arr13 = np.empty(10)
arr14 = np.empty((3,3))
arr15 = np.empty_like(arr10)
print(arr13)
print(arr14)
print(arr15)


# 输出

# [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
# [[1. 1. 1.]
#  [1. 1. 1.]
#  [1. 1. 1.]]
# [[1. 1. 1.]
#  [1. 1. 1.]
#  [1. 1. 1.]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1.4.eye创建对角矩阵数组

arr12 = np.eye(5)
print(arr12)


# 输出

# [[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.]]
1
2
3
4
5
6
7
8
9
10
11

1.5.full创建满数组

list1 = np.full((3,4),666)
print(list1)


# 输出

# [[666 666 666 666]
#  [666 666 666 666]
#  [666 666 666 666]]
1
2
3
4
5
6
7
8
9

2.numpy数组的数据类型

python中带有list列表，其中可以储存所有类型，但是并不是类型对象储存在列表中，而是把对象的索引储存在list中，当垃圾回收机制检测的时候，需要一个一个遍历，效率很低。而numpy数组则是开辟一整块内存，相当于只有一个对象来储存这些值，所以不需要一一遍历，但是要将那么多索引打包成一个对象，就需要特定的数据类型，所以numpy数组只能储存同一种数据类型。

• dtype（数据类型）是一个特殊的对象，它含有ndarray将一块内存解释为特定数据类型所需的信息，dtype的类型有：
  

list1 = [0,1.1,2.2,3.3,4.4,5.5,6.6]

# 在创建numpy数组的时候指定类型
arr = np.array(list1,dtype = np.int16)
print(arr)

#打印arr的类型dtype
print(arr.dtype)

# 将new_arr的类型转换为float
new_arr = arr.astype(np.float32)

print(new_arr)
print(new_arr.dtype)


# 输出

# [0 1 2 3 4 5 6]
# int16
# [0. 1. 2. 3. 4. 5. 6.]
# float32
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

• 可以发现，不仅在创建numpy数组的时候可以定义类型dtype，而且也可以将已经创建好的numpy数组的类型进行转换

注意

1. 当float转换为int的时候，会自动删除小数点之后的数据，只保留整数位
2. 数字转换成字符串也是可以的

3. numpy数组的索引

numpy有很多种索引类型

3.1. 普通索引和切片索引

普通索引

list1 = np.arange(12).reshape(3,4)
print(list1)
print(list1[1,1])

# 输出从第2行之后，第2列之后的值
print(list1[1:,1:])

# 输出

# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
# 5
# [[ 5  6  7]
#  [ 9 10 11]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

切片索引

# 注意：在numpy中的切片。并没有形成新的对象
# 而是在原来的数组中抠出一块，对切片
# 修改，那么原来的numpy数组也会被修改
list1 = np.arange(12)
print(list1)
print(list1[2])
print(list1[2:])
print(list1[2:7])
print(list1[2:7:2])
print(list1[:7])


# 输出

# [ 0  1  2  3  4  5  6  7  8  9 10 11]
# 2
# [ 2  3  4  5  6  7  8  9 10 11]
# [2 3 4 5 6]
# [2 4 6]
# [0 1 2 3 4 5 6]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.2.花式索引

• arr[数组]，可以返回对应的子集

list1 = np.arange(32).reshape(8,4)
print(list1)
print('-'*20)
# 数组中的数字就是下标
print(list1[[2,6,7,3,7]])


# 输出

# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]
#  [12 13 14 15]
#  [16 17 18 19]
#  [20 21 22 23]
#  [24 25 26 27]
#  [28 29 30 31]]
# --------------------
# [[ 8  9 10 11]
#  [24 25 26 27]
#  [28 29 30 31]
#  [12 13 14 15]
#  [28 29 30 31]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

• 若是需要获取二维数组中某个确定的值，加上这句话

print(list1[[1,2,3],[2,3,0]])

# 输出

# [ 6 11 12]
1
2
3
4
5

• 布尔索引

index = [True,True,False,True,False,True,True,True]
print(list1[index])

# 输出

# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [12 13 14 15]
#  [20 21 22 23]
#  [24 25 26 27]
#  [28 29 30 31]]
1
2
3
4
5
6
7
8
9
10
11

• 在传入的数组中，False对应的值就会消失，True对应的值就会留下

4. numpy自带的数组函数

4.1 通用函数：快速的元素级数组函数

我们在这里把这些函数全部做一下演示

• 一元ufunc

# 取绝对值

# list1:
# [ 1.2 -3.4  5.   6.   nan  9.4]

print(np.abs(list1))


# 输出

# [1.2 3.4 5.  6.  nan 9.4]
1
2
3
4
5
6
7
8
9
10
11

# 向上取整

# list1:
# [ 1.2 -3.4  5.   6.   nan  9.4]

print(np.ceil(list1))


# 输出

# [ 2. -3.  5.  6. nan 10.]
1
2
3
4
5
6
7
8
9
10
11

# 挨个平方

# list1:
# [ 1.2 -3.4  5.   6.   nan  9.4]

print(np.square(list1))


# 输出

# [ 1.44 11.56 25.   36.     nan 88.36]
1
2
3
4
5
6
7
8
9
10
11

# 取list1所有符号

list1 = np.array([1.2,-3.4,5,6,9.4])
print(np.sign(list1))


# 输出

# [ 1. -1.  1.  1.  1.]
1
2
3
4
5
6
7
8
9

# 向下取整

list1 = np.array([1.2,-3.4,5,6,np.nan,9.4])
print(np.floor(list1))


# 输出

# [ 1. -4.  5.  6. nan  9.]
1
2
3
4
5
6
7
8
9

# 四舍五入

# list1:
# [1.2,-3.4,5,6,np.nan,9.4]

print(np.rint(list1))


# 输出

# [ 1. -3.  5.  6. nan  9.]
1
2
3
4
5
6
7
8
9
10
11

# 将数组的整数和小数部分以两个独立的数组的形式返回

# list1:
# [1.2,-3.4,5,6,np.nan,9.4]

print(np.modf(list1))


# 输出

# (array([ 0.2, -0.4,  0. ,  0. ,  nan,  0.4]), array([ 1., -3.,  5.,  6., nan,  9.]))
1
2
3
4
5
6
7
8
9
10
11

# isnan()判断数组里的元素哪一个是nan

# list1:
# [1.2,-3.4,5,6,np.nan,9.4]

print(np.isnan(list1))


# 输出

# [False False False False  True False]
1
2
3
4
5
6
7
8
9
10
11

• 二元ufunc

# where(表达式，f1,f2),类似于三目运算符
# 表达式为True返回f1，表达式为False返回f2

# arr2: [[19  3 19 -1 -2]
#  [ 8  5  3 19  5]
#  [-8 16 -1  6  4]
#  [ 0 17 -3 18  3]]

arr2 = np.where(arr2 == 0,1,arr2)
print(arr2)


# 输出

# [[19  3 19 -1 -2]
#  [ 8  5  3 19  5]
#  [-8 16 -1  6  4]
#  [ 1 17 -3 18  3]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 数组元素依次相加

# arr1: [[ 1 13 18 19 13]
#  [13  9 15  7  5]
#  [ 6 19  6 16 14]
#  [13  8  3  5 11]]
# arr2: [[19  3 19 -1 -2]
#  [ 8  5  3 19  5]
#  [-8 16 -1  6  4]
#  [ 0 17 -3 18  3]]

print(np.add(arr1,arr2))


# 输出

# [[20 16 37 18 11]
#  [21 14 18 26 10]
#  [-2 35  5 22 18]
#  [14 25  0 23 14]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 数组元素依次相减

# arr1: [[ 1 13 18 19 13]
#  [13  9 15  7  5]
#  [ 6 19  6 16 14]
#  [13  8  3  5 11]]
# arr2: [[19  3 19 -1 -2]
#  [ 8  5  3 19  5]
#  [-8 16 -1  6  4]
#  [ 0 17 -3 18  3]]

print(np.subtract(arr1,arr2))


# 输出

# [[-18  10  -1  20  15]
#  [  5   4  12 -12   0]
#  [ 14   3   7  10  10]
#  [ 12  -9   6 -13   8]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 数组内的除法

# arr1: [[ 1 13 18 19 13]
#  [13  9 15  7  5]
#  [ 6 19  6 16 14]
#  [13  8  3  5 11]]
# arr2: [[19  3 19 -1 -2]
#  [ 8  5  3 19  5]
#  [-8 16 -1  6  4]
#  [ 0 17 -3 18  3]]

print(np.divide(arr1,arr2))


# 输出

# [[  0.05263158   4.33333333   0.94736842 -19.          -6.5       ]
#  [  1.625        1.8          5.           0.36842105   1.        ]
#  [ -0.75         1.1875      -6.           2.66666667   3.5       ]
#  [ 13.           0.47058824  -1.           0.27777778   3.66666667]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 整除，去掉小数

# arr1: [[ 1 13 18 19 13]
#  [13  9 15  7  5]
#  [ 6 19  6 16 14]
#  [13  8  3  5 11]]
# arr2: [[19  3 19 -1 -2]
#  [ 8  5  3 19  5]
#  [-8 16 -1  6  4]
#  [ 0 17 -3 18  3]]

print(np.floor_divide(arr1,arr2))


# 输出

# [[  0   4   0 -19  -7]
#  [  1   1   5   0   1]
#  [ -1   1  -6   2   3]
#  [ 13   0  -1   0   3]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 依次次方，arr1的arr3次方

# arr1: [[ 1 13 18 19 13]
#  [13  9 15  7  5]
#  [ 6 19  6 16 14]
#  [13  8  3  5 11]]
# arr2: [[19  3 19 -1 -2]
#  [ 8  5  3 19  5]
#  [-8 16 -1  6  4]
#  [ 0 17 -3 18  3]]

arr3 = np.abs(arr2)
print(np.power(arr1,arr3))


# 输出

# [[         1       2197 -355991552         19        169]
#  [ 815730721      59049       3375  442181591       3125]
#  [   1679616 1637415489          6   16777216      38416]
#  [        13          0         27  766306777       1331]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 取两个数组元素比较的较大的那一个

# arr1: [[ 1 13 18 19 13]
#  [13  9 15  7  5]
#  [ 6 19  6 16 14]
#  [13  8  3  5 11]]
# arr2: [[19  3 19 -1 -2]
#  [ 8  5  3 19  5]
#  [-8 16 -1  6  4]
#  [ 0 17 -3 18  3]]

print(np.maximum(arr1,arr2))


# 输出

# [[19 13 19 19 13]
#  [13  9 15 19  5]
#  [ 6 19  6 16 14]
#  [13 17  3 18 11]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 和maximum效果一致，忽略nan

# arr1: [[ 1 13 18 19 13]
#  [13  9 15  7  5]
#  [ 6 19  6 16 14]
#  [13  8  3  5 11]]
# arr2: [[19  3 19 -1 -2]
#  [-8 16 -1  6  4]
#  [ 0 17 -3 18  3]]

print(np.fmax(arr1,arr2))


# 输出

# [[19 13 19 19 13]
#  [13  9 15 19  5]
#  [ 6 19  6 16 14]
#  [13 17  3 18 11]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 在两个数组元素之间依次取较小的值

# arr1: [[ 1 13 18 19 13]
#  [13  9 15  7  5]
#  [ 6 19  6 16 14]
#  [13  8  3  5 11]]
# arr2: [[19  3 19 -1 -2]
#  [-8 16 -1  6  4]
#  [ 0 17 -3 18  3]]

print(np.minimum(arr1,arr2))


# 输出

# [[ 1  3 18 -1 -2]
#  [ 8  5  3  7  5]
#  [-8 16 -1  6  4]
#  [ 1  8 -3  5  3]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 取模运算

# arr1: [[ 1 13 18 19 13]
#  [13  9 15  7  5]
#  [ 6 19  6 16 14]
#  [13  8  3  5 11]]
# arr2: [[19  3 19 -1 -2]
#  [-8 16 -1  6  4]
#  [ 0 17 -3 18  3]]

print(np.mod(arr1,arr2))


# 输出

# [[ 1  1 18  0 -1]
#  [ 5  4  0  7  0]
#  [-2  3  0  4  2]
#  [ 0  8  0  5  2]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 把arr2的数的符号赋值给arr1的数

# arr1: [[ 1 13 18 19 13]
#  [13  9 15  7  5]
#  [ 6 19  6 16 14]
#  [13  8  3  5 11]]
# arr2: [[19  3 19 -1 -2]
#  [-8 16 -1  6  4]
#  [ 0 17 -3 18  3]]

print(np.copysign(arr1,arr2))


# 输出

# [[  1.  13.  18. -19. -13.]
#  [ 13.   9.  15.   7.   5.]
#  [ -6.  19.  -6.  16.  14.]
#  [ 13.   8.  -3.   5.  11.]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 依次比较，相当于arr1 > arr2

# arr1: [[ 1 13 18 19 13]
#  [13  9 15  7  5]
#  [ 6 19  6 16 14]
#  [13  8  3  5 11]]
# arr2: [[19  3 19 -1 -2]
#  [-8 16 -1  6  4]
#  [ 0 17 -3 18  3]]

print(np.greater(arr1,arr2))


# 输出

# [[False  True False  True  True]
#  [ True  True  True False False]
#  [ True  True  True  True  True]
#  [ True False  True False  True]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 依次比较，相当于arr1 > arr2

# arr1: [[ 1 13 18 19 13]
#  [13  9 15  7  5]
#  [ 6 19  6 16 14]
#  [13  8  3  5 11]]
# arr2: [[19  3 19 -1 -2]
#  [-8 16 -1  6  4]
#  [ 0 17 -3 18  3]]

print(np.greater_equal(arr1,arr2))


# 输出

# [[False  True False  True  True]
#  [ True  True  True False  True]
#  [ True  True  True  True  True]
#  [ True False  True False  True]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4.2.数组统计函数

• 一样，我们也每个都演示一遍

# 获取数组所有元素的平均值

# arr:
# [[  2   1  -5   9]
#  [  2   1   4 -10]
#  [ -2  -5   3  16]
#  [ -2  -3   9   0]
#  [ 18  -1  15   6]]

print(np.mean(arr))


# 输出

# 2.9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 获取数组所有元素相加的值

# arr:
# [[  2   1  -5   9]
#  [  2   1   4 -10]
#  [ -2  -5   3  16]
#  [ -2  -3   9   0]
#  [ 18  -1  15   6]]

print(np.sum(arr))


# 输出

# 58
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 获取所有元素相加的值，当axis=0是按横向相加获取

# arr:
# [[  2   1  -5   9]
#  [  2   1   4 -10]
#  [ -2  -5   3  16]
#  [ -2  -3   9   0]
#  [ 18  -1  15   6]]

print(np.sum(arr,axis=0))


# 输出

# [18 -7 26 21]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 获取所有元素相加的值，当axis=1是按纵向获取

# arr:
# [[  2   1  -5   9]
#  [  2   1   4 -10]
#  [ -2  -5   3  16]
#  [ -2  -3   9   0]
#  [ 18  -1  15   6]]

print(np.sum(arr,axis=1))


# 输出

# [ 7 -3 12  4 38]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# max获取最大值，mix获取最小值,axis控制横纵
# 若没有axis，则默认从数组中的所有值中获取最大、最小值

# arr:
# [[  2   1  -5   9]
#  [  2   1   4 -10]
#  [ -2  -5   3  16]
#  [ -2  -3   9   0]
#  [ 18  -1  15   6]]

print(np.max(arr))
print(np.min(arr))
print(np.max(arr,axis=0))
print(np.max(arr,axis=1))
print(np.min(arr,axis=0))
print(np.min(arr,axis=1))


# 输出

# 18
# -10
# [18  1 15 16]
# [ 9  4 16  9 18]
# [ -2  -5  -5 -10]
# [ -5 -10  -5  -3  -1]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 获取标准差，axis控制横纵

# arr:
# [[  2   1  -5   9]
#  [  2   1   4 -10]
#  [ -2  -5   3  16]
#  [ -2  -3   9   0]
#  [ 18  -1  15   6]]

print(np.std(arr))
print(np.std(arr,axis=0))
print(np.std(arr,axis=1))


# 输出

# 7.2034713853808015
# [7.4188948  2.33238076 6.64529909 8.77268488]
# [4.96865173 5.44862368 8.0311892  4.74341649 7.5       ]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 获取放差，axis控制横纵

# arr:
# [[  2   1  -5   9]
#  [  2   1   4 -10]
#  [ -2  -5   3  16]
#  [ -2  -3   9   0]
#  [ 18  -1  15   6]]

print(np.var(arr))
print(np.var(arr,axis=0))
print(np.var(arr,axis=1))


# 输出

# 51.89
# [55.04  5.44 44.16 76.96]
# [24.6875 29.6875 64.5    22.5    56.25  ]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 所有元素的累计和，以斐波那契数列的方式返回

# arr:
# [[  2   1  -5   9]
#  [  2   1   4 -10]
#  [ -2  -5   3  16]
#  [ -2  -3   9   0]
#  [ 18  -1  15   6]]

print(np.cumsum(arr))
print(np.cumsum(arr,axis=0))
print(np.cumsum(arr,axis=1))


# 输出

# [ 2  3 -2  7  9 10 14  4  2 -3  0 16 14 11 20 20 38 37 52 58]
# [[ 2  1 -5  9]
#  [ 4  2 -1 -1]
#  [ 2 -3  2 15]
#  [ 0 -6 11 15]
#  [18 -7 26 21]]
# [[ 2  3 -2  7]
#  [ 2  3  7 -3]
#  [-2 -7 -4 12]
#  [-2 -5  4  4]
#  [18 17 32 38]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 依次获取所有元素的累计积

# arr:
# [[  2   1  -5   9]
#  [  2   1   4 -10]
#  [ -2  -5   3  16]
#  [ -2  -3   9   0]
#  [ 18  -1  15   6]]

print(np.cumprod(arr))
print(np.cumprod(arr,axis=0))
print(np.cumprod(arr,axis=1))


# 输出

# [        2         2       -10       -90      -180      -180      -720
#       7200    -14400     72000    216000   3456000  -6912000  20736000
#  186624000         0         0         0         0         0]
# [[    2     1    -5     9]
#  [    4     1   -20   -90]
#  [   -8    -5   -60 -1440]
#  [   16    15  -540     0]
#  [  288   -15 -8100     0]]
# [[    2     2   -10   -90]
#  [    2     2     8   -80]
#  [   -2    10    30   480]
#  [   -2     6    54     0]
#  [   18   -18  -270 -1620]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

4.3.all和any函数

arr1 = np.arange(6).reshape(2,3)
arr2 = np.arange(6).reshape(2,3)
arr3 = np.arange(6).reshape(2,3)

# 第二行的每一个数都+2
arr3[1,] = arr3[1,] + 2
print('arr1:',arr1)
print('arr2:',arr2)
print('arr3:',arr3)


# 输出

# arr1: [[0 1 2]
#  [3 4 5]]
# arr2: [[0 1 2]
#  [3 4 5]]
# arr3: [[0 1 2]
#  [5 6 7]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# all(): arr1和arr2所有值相等，返回True
# any():arr1和arr2只要有一个或以上的值相等就返回True
# 只能挨个比较，不是子集的关系，第一个和第一个比
# 第二个和第二个比，依次类推

# arr1: [[0 1 2]
#  [3 4 5]]
# arr2: [[0 1 2]
#  [3 4 5]]
# arr3: [[0 1 2]
#  [5 6 7]]

print((arr1 == arr2).all())
print((arr1 == arr2).any())
print((arr3 == arr2).all())
print((arr3 == arr2).any())


# 输出

# True
# True
# False
# True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

4.4.添加和删除函数

• 演示一遍这些函数

# append()向数组后面添加，始终返回一个一维数组
# 即使向二维数组后添加也是返回一维数组

# arr:
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

arr = np.append(arr,100)
print(arr)


# 输出

# [  0   1   2   3   4   5   6   7   8   9  10  11 100]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# concatenete(arr1,arr2)数组拼接
# 两种方式，横向拼接和纵向拼接

arr1 = np.arange(12).reshape(3,4)
arr2 = np.arange(15).reshape(3,5)

print('arr1:',arr1)
print('arr2:',arr2)
print('-'*60)

# axis=1按列相拼，也就是横向拼接
arr3 = np.concatenate((arr1,arr2),axis=1)
print('arr3:',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 12 13 14]]
# ------------------------------------------------------------
# arr3: [[ 0  1  2  3  0  1  2  3  4]
#  [ 4  5  6  7  5  6  7  8  9]
#  [ 8  9 10 11 10 11 12 13 14]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# delete()删除列/行

# arr3: [[ 0  1  2  3  0  1  2  3  4]
#  [ 4  5  6  7  5  6  7  8  9]
#  [ 8  9 10 11 10 11 12 13 14]]

print(np.delete(arr3,0,axis=0))
print(np.delete(arr3,0,axis=1))


# 输出

# [[ 4  5  6  7  5  6  7  8  9]
#  [ 8  9 10 11 10 11 12 13 14]]
# [[ 1  2  3  0  1  2  3  4]
#  [ 5  6  7  5  6  7  8  9]
#  [ 9 10 11 10 11 12 13 14]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

5.唯一化和集合函数

• 看上面的一些解释多少有些晦涩，我们来演示一遍

arr1 = np.array([1,2,3,4,5,6,7,8,9,2,3,6,9])
arr2 = np.array([6,7,8,9,10,11,12])

# 为arr1去重
print(np.unique(arr1))

# 求arr1和arr2的交集
print(np.intersect1d(arr1,arr2))

# 求arr1和arr2的并集
print(np.union1d(arr1,arr2))

# 挨个遍历arr1，若在arr2中，返回True,否则返回False
print(np.in1d(arr1,arr2))

# 元素在arr1中，且不在arr2中
print(np.setdiff1d(arr1,arr2))


# 输出

# [1 2 3 4 5 6 7 8 9]
# [6 7 8 9]
# [ 1  2  3  4  5  6  7  8  9 10 11 12]
# [False False False False False  True  True  True  True False False  True
#   True]
# [1 2 3 4 5]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

5.1.随机数生成函数

numpy.random模块对Python内置的random进行了补充。我们使用numpy.random可以很方便根据需要产生大量样本值。而python内置的random模块则一次生成一个样本值.

• 演示一遍

# 均匀分布创建浮点数数组，范围0-1
# 参数传的是维度，2x3的数组

arr= np.random.rand(2,3)
print(arr)


# 输出

# [[0.39095862 0.87433126 0.47691229]
#  [0.95286477 0.13711325 0.23346156]]
1
2
3
4
5
6
7
8
9
10
11

# 标准正态分布创建浮点数数组，范围0-1
# 平均数0，标准差1
# 参数传的是维度，2x3的数组

arr = np.random.randn(2,3)
print(arr)


# 输出

# [[ 1.23115722 -0.81990953 -1.06117641]
#  [-1.24637525  1.1233126   0.18161635]]
1
2
3
4
5
6
7
8
9
10
11
12

# 用randint创建随机数数组
# 传入low,high,shape

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


# 输出

# [[80 16  6 69]
#  [ 2 49 57 17]
#  [80 48 80 50]]
1
2
3
4
5
6
7
8
9
10
11
12

# 产生均匀分布的数组
# 传入low,high,shape

arr = np.random.uniform(10,20,(3,4))
print(arr)


# 输出

# [[18.89839661 11.89371107 15.38962327 10.07877318]
#  [11.21368381 14.14041887 17.4691856  14.13228736]
#  [12.8568047  19.40181514 18.39326788 15.46812332]]
1
2
3
4
5
6
7
8
9
10
11
12

# 从指定正态分布中抽取样本
# 传入分布中心，标准差，shape

arr = np.random.normal(10,1,(3,4))
print(arr)


# 输出

# [[11.44570986  9.90496341  8.98104181  9.7312621 ]
#  [ 9.75793514 11.45184151  7.60661017  9.94691071]
#  [ 9.95302056  9.97370994  9.35911962 10.30159322]]
1
2
3
4
5
6
7
8
9
10
11
12

# 随机数种子

arr = np.random.seed(12)
arr = np.random.randint(10,20,(3,4))
print(arr)


# 输出

# [[16 11 12 13]
#  [13 10 16 11]
#  [14 15 19 12]]
1
2
3
4
5
6
7
8
9
10
11
12

还有三个函数

• 演示一下

# 给定数字，则生成范围内的随机数
# 给定数组，则打乱数组顺序返回

arr = np.random.permutation(10)
print(arr)
arr = np.random.permutation([1,2,3,4,5,6,7,8,9])
print(arr)


# 输出

# [3 9 7 1 2 4 8 5 0 6]
# [8 6 9 5 3 1 7 2 4]
1
2
3
4
5
6
7
8
9
10
11
12
13

# 打乱一个序列的原有顺序

arr = np.arange(10)
np.random.shuffle(arr)
print(arr)


# 输出

# [5 2 3 4 0 6 1 7 8 9]
1
2
3
4
5
6
7
8
9
10

# 这个已经不陌生了，生成随机整型数组
# randint(beg,end,shape)

arr = np.random.randint(10,20,6)
print(arr)

# 输出

# [16 12 13 12 16 14]
1
2
3
4
5
6
7
8
9

6. 数组排序函数

# 两种sort排序
# 1. numpy数组自带sort(axis=)函数，排序原始数组，没有返回值
# 2. np.sort(arr,axis=),有返回值，不影响原始数组

arr = np.random.randint(0,10,(3,5))
print(arr)
arr.sort()
print(arr)
arr.sort(axis=0)
print(arr)

new_arr = np.sort(arr,axis=1)


# 输出

# [[5 0 0 5 4]
#  [0 3 7 9 6]
#  [8 6 1 4 9]]
# [[0 0 4 5 5]
#  [0 3 6 7 9]
#  [1 4 6 8 9]]
# [[0 0 4 5 5]
#  [0 3 6 7 9]
#  [1 4 6 8 9]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# argsort函数(很重要) argsort函数返回的是数组值从小到大的索引值

arr = np.random.randint(0,10,(3,5))
print('arr:',arr)
arr_index = np.argsort(arr)
print('arr_index:',arr_index)


# 输出

# arr: [[8 3 9 5 1]
#  [6 3 2 3 1]
#  [9 3 2 2 8]]
# arr_index: [[4 1 3 0 2]
#  [4 2 1 3 0]
#  [2 3 1 4 0]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

7.广播

• 代码演示

arr1 = np.arange(45).reshape(3,5,3)
print('arr1:',arr1)
arr2 = np.arange(15).reshape(5,3)
print('arr2:',arr2)
arr3 = arr1 + arr2
print('arr3:',arr3)


# 输出

# arr1: [[[ 0  1  2]
#   [ 3  4  5]
#   [ 6  7  8]
#   [ 9 10 11]
#   [12 13 14]]

#  [[15 16 17]
#   [18 19 20]
#   [21 22 23]
#   [24 25 26]
#   [27 28 29]]

#  [[30 31 32]
#   [33 34 35]
#   [36 37 38]
#   [39 40 41]
#   [42 43 44]]]
# arr2: [[ 0  1  2]
#  [ 3  4  5]
#  [ 6  7  8]
#  [ 9 10 11]
#  [12 13 14]]
# arr3: [[[ 0  2  4]
#   [ 6  8 10]
#   [12 14 16]
#   [18 20 22]
#   [24 26 28]]

#  [[15 17 19]
#   [21 23 25]
#   [27 29 31]
#   [33 35 37]
#   [39 41 43]]

#  [[30 32 34]
#   [36 38 40]
#   [42 44 46]
#   [48 50 52]
#   [54 56 58]]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49