开个新坑,为下学期的大数据专业做准备
就从数据分析的基本工具Numpy开始吧~

数组的创建

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
import numpy as np

np.array([1,2,3])                       # 创建一个一维数组
np.array([1,2,3],dtype=float)           # float类型的二维列表
np.array([[1,2,3],[4,5,6],[7,8,9]])     # 创建一个二维数组

np.arange(6)                            # 按顺序创建数组 [0 1 2 3 4 5]
np.arange(1,6,3)                        # 创建1-6之间步长为3的数组 [1 4]

np.linspace(1,6,3,dtype=int)            # 创建1-6之间数列长度为3的数组 [1 3 6]
np.logspace(2,3,num=3,dtype=int)                  # 创建10^2-10^3之间数列长度为4的数组[ 100 316 1000]

np.zeros([2,10])                # 创建一个2x10的二维数组,所有元素都为0
np.ones([2,10])                 # 创建一个2x10的二维数组，所有元素都为1

a = np.array([[1,2,3],[4,5,6],[7,8,9]])
np.ones_like(a)                 # 创建一个"形状"和a数组相同,所有元素都是1的数组
np.zeros_like(a)                # 作用同ones_like,但所有元素都是0

# 创建一个4x4的数组,可设置对角线数值为1
np.eye(4)
#### [[1. 0. 0. 0.]
####  [0. 1. 0. 0.]
####  [0. 0. 1. 0.]
####  [0. 0. 0. 1.]]

np.eye(4,k=1)
#### [[0. 1. 0. 0.]
####  [0. 0. 1. 0.]
####  [0. 0. 0. 1.]
####  [0. 0. 0. 0.]]

np.eye(4,k=-1)
#### [[0. 0. 0. 0.]
####  [1. 0. 0. 0.]
####  [0. 1. 0. 0.]
####  [0. 0. 1. 0.]]

# 创建以指定元素为对角线的数组
np.diag([1,2,3,4],k=1)
#### [[0 1 0 0 0]
####  [0 0 2 0 0]
####  [0 0 0 3 0]
####  [0 0 0 0 4]
####  [0 0 0 0 0]]

数组的几种属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
d1 = np.array([1,2,3])
d1.dtype                     # 获取数组元素的类型 int32
d1.astype(float)             # 临时修改数组元素类型为float

d2 = np.array([[1,2,3],[4,5,6]])
d2.shape                     # 获取数组的"形状"  (2, 3)
d2.size                      # 获取数组的大小 6
d2.ndim                      # 获取数组的维度 2

d3 = np.arange(24)
d4 = d3.reshape(2,3,4)       # 改变数组的"形状"
#### [[[ 0  1  2  3]
####   [ 4  5  6  7]
####   [ 8  9 10 11]]
####
####  [[12 13 14 15]
####   [16 17 18 19]
####   [20 21 22 23]]]

数组的索引和切片

  1. 一维数组的索引

    1
    2
    3
    4
    5
    s1 = np.array([0,10,20,30,40,50])
    s1[3]                       # 获取下标为3的元素 30
    s1[[3]]                     # 获取下标为3的元素,格式为数组 [30]
    s1[[1,3]]                   # 取出下标为1和3的元素组成新的数组 [10 30]
    s1[0] = 100                 # 修改元素值

  2. 二维数组的索引

    • 以整数为下标
      1
      2
      3
      4
      5
      s2 = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
      s2[0]                       # 获取第一行列表 [1 2 3]
      s2[0][1]                    # 第一行第二个元素 2
      s2[0,1]                     # 第一行第二个元素 2
      s2[0] = 100                 # 将第一行全部赋100
    • 以列表为下标
      1
      2
      3
      4
      5
      6
      7
      s2[[1,2]]                   # 取第2,3行的列表[[4 5 6],[7 8 9]]
      s2[[2,3],[1,2]]             # 取[2,1]和[3,2]的元素组成新列表[8 12]
      s2[[2,1,2,1]]               # 取第2,1,2,1行元素组成新的二维列表 ↓
      #### [[7 8 9]
      ####  [4 5 6]
      ####  [7 8 9]
      ####  [4 5 6]]
    • 以数组为下标
      • 一维数组的例子 
        1
        2
        3
        4
        5
        v = np.array([1,3,4])
        s3 = np.array([0,10,20,30,40])
        s3[v]               # 以数组1,3,4为下标,将s3中所对应下标的元素取出 [10 30 40]
        t = s3 == 40        # 判断s3,等于40则为True,返回一个列表 [False False False False True]
        s3[t]               # 返回t为True所在下标的元素列表 [40]
      • 二维数组的例子 
        1
        2
        3
        4
        5
        s4 = np.array([[0,1,2,3,4],
                      [5,6,7,8,9]])
        t = s4 % 2 == 0     # 找出s4中能被2整除的偶数 ↓
        #### [[ True False  True False  True]
        ####  [False  True False  True False]]

切片

  1. 一维数组的切片
    1
    2
    s5 = np.array([1,2,3,4,5])
    s5[2:4]             # 将下标2-4之间的元素切片 [3 4 5]
  2. 二维数组的切片
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    s6 = np.array([[1,2,3],
                   [4,5,6],
                   [7,8,9],
                   [10,11,12]])
    s6[1:3]             # 将下标1-2的列表切片取出 ↓
    # [[4 5 6]
    #  [7 8 9]]
    s6[1:3,2:3]         # 输出如下 ↓
    # [[5 6]
    #  [8 9]]
    s6[::2,::2]         # 每隔一个取一个 输出如下 ↓
    # [[1 3]
    #  [7 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
26
27
28
29
np.arange(10).reshape((2,5))     # 将一维数组格式化为2x5的二维数组
# [[0 1 2 3 4]
#  [5 6 7 8 9]]

a = np.arange(10)
b = np.reshape(a,(2,5))         # 将a格式化为2x5
# [[0 1 2 3 4]
#  [5 6 7 8 9]]

c = b.reshape(-1,2)             # (-1,2)代表行数不变,列数变为2
# [[0 1]
#  [2 3]
#  [4 5]
#  [6 7]
#  [8 9]]

np.reshape(b,(10,))             # (10,)代表格式化为一维数组,0轴有10个元素
# [0 1 2 3 4 5 6 7 8 9]

np.reshape(b,(1,10))            # (1,10)代表0轴1个元素,这个元素包含10个元素
# [[0 1 2 3 4 5 6 7 8 9]]

b.shape = (1,10)                # 通过改变shape的值来改变数组的形状

b.flatten()                     # 将二维数组b"扁平化"为一维数组,或np.flatten(b)
# [0 1 2 3 4 5 6 7 8 9]

d = np.ravel(b)                 # 与np.flatten(b)效果相同
# [0 1 2 3 4 5 6 7 8 9]

最后一行中b和d的数据是共享的,一个修改之后,另一个的数据也会改变

数组的组合

以以下两个二维数组为例

1
2
3
4
5
6
7
8
9
a = np.arange(9).reshape((3,3))
# [[0 1 2]
#  [3 4 5]
#  [6 7 8]]

b = np.arange(12).reshape((3,4))
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
  1. 水平组合
    1
    2
    3
    4
    5
    6
    np.hstack((a,b))
    # [[ 0  1  2  0  1  2  3]
    #  [ 3  4  5  4  5  6  7]
    #  [ 6  7  8  8  9 10 11]]

    np.concatenate((a,b),axis=1) # 沿1轴方向进行组合,结果与上面相同
  2. 垂直组合
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    # np.vstack((a,b)) 会报错,因为列数不同
    np.vstack((a,b.T)) # b.T将b转置,使其与a的列数相同,则可以组合
    # [[ 0  1  2]
    #  [ 3  4  5]
    #  [ 6  7  8]
    #  [ 0  4  8]
    #  [ 1  5  9]
    #  [ 2  6 10]
    #  [ 3  7 11]]
    np.concatenate((a,b),axis=1) # 沿0轴方向进行组合,结果与上面相同

数组的分割

以以下二维数组为例

1
2
3
4
5
a = np.arange(24).reshape(4,6)
# [[ 0  1  2  3  4  5]
#  [ 6  7  8  9 10 11]
#  [12 13 14 15 16 17]
#  [18 19 20 21 22 23]]
  1. 沿1轴水平分割
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    b= np.split(a,2,axis=1) # 沿1轴方向将a切分成两部分
    # [array([[ 0,  1,  2],
    #         [ 6,  7,  8],
    #         [12, 13, 14],
    #         [18, 19, 20]]), 
    #  array([[ 3,  4,  5],
    #         [ 9, 10, 11],
    #         [15, 16, 17],
    #         [21, 22, 23]])]
    b = np.hsplit(a,2) # 与上述结果相同
  2. 沿0轴垂直分割
    1
    2
    3
    4
    5
    6
    b= np.split(a,2,axis=0) # 沿0轴方向将a切分成两部分
    # [array([[ 0,  1,  2,  3,  4,  5],
    #         [ 6,  7,  8,  9, 10, 11]]), 
    #  array([[12, 13, 14, 15, 16, 17],
    #         [18, 19, 20, 21, 22, 23]])]
    b = np.vsplit(a,2) # 与上述结果相同

数组的运算

  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
    27
    28
    29
    30
    a = np.array([1,2,3])
    b = np.array([4,5,6])

    # 将每一项都加减乘或除一个数
    a * 10      # [10 20 30]
    a + 10      # [11 12 13]
    a - 10      # [-9 -8 -7]
    a / 10      # [0.1 0.2 0.3]

    # 数组之间对应项之间加减乘除
    a + b       # [5 7 9]
    a - b       # [-3 -3 -3]
    a * b       # [ 4 10 18]
    a / b       # [0.25 0.4 0.5]

    ## 形状不同的情况
    a = np.array([1,2,3])
    b = np.array([[1,2,3],
                  [4,5,6]])
    c = np.array([[1],
                  [2]])

    # a数组自动扩展为2维与b进行计算,这称为"广播"
    a + b       
    # [[2 4 6]
    #  [5 7 9]]

    c + b   # 对c数组进行向右广播
    # [[2 3 4]
    #  [6 7 8]]
  2. 比较运算
    1
    2
    np.array([1,2,3]) > np.array([3,1,2])   # 对应项之间进行比较 [False  True  True]
    # np.array([1,2,3]) > np.array([3,1]) 数组形状不相同,会报错
  3. numpy的逻辑运算
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    a = np.array([False,True])
    b = np.array([True,False])
    np.logical_or(a,b)      # 逻辑或 [ True  True]
    np.logical_and(a,b)     # 逻辑与 [False False]

    c = np.array([1,2,3])
    d = np.array([4,5,6])
    ### any
    np.any(c > d)           # 只要c的中有任何一个大于d的对应项,则为True  此处为False
    (c > d).any()           # 与上述效果相同
    ### all
    np.all(c < d)           # 只有c中所有元素都小于d的对应项,才为True,此处为True
    (c < d).all()           # 与上述效果相同
  4. 通用函数


 上一页

Android Kotlin

 评论

载入天数...载入时分秒...