Numpy知识详解之属性操作详解

Numpy知识详解之属性操作详解

一、ndarray对象维度操作

1.数据共享的视图变维

reshape()和ravel()

# 1.数据共享的视图变维  reshape()和ravel()
arr5 = np.arange(1,10)
print(arr5) # 输出结果：[1 2 3 4 5 6 7]
arr6 = arr5.reshape(3,3)  # 视图变维 变成2行4列
print(arr6) # 输出结果：[[1 2 3]
            #          [4 5 6]
            #           [7 8 9]]
arr7 = arr6.ravel() # 视图变维 变成一维数组
print(arr7) # 输出结果：[1 2 3 4 5 6 7 8 9]

# 数组变维前后共享同一份数据，无论哪个数组数据改变，其它数组数据均改变
arr5[2]=10
print(arr5) # 输出结果：[ 1  2 10  4  5  6  7  8  9]
print(arr6) # 输出结果：[[ 1  2 10]
            #          [ 4  5  6]
            #          [ 7  8  9]]

print(arr7) # 输出结果：[ 1  2 10  4  5  6  7  8  9]

2.数据独立的复制变维

flatten()

# 2.复制变维    flatten()
arr8 = arr7.flatten()
print(arr8)  # 输出结果：[ 1  2 10  4  5  6  7  8  9]
# 数组变维后，与原数组不共享数据，无论哪个数组数据进行改变，不会影响其它数组数据
arr7[0]=100
print(arr7)  # 输出结果：[100   2  10   4   5   6   7   8   9]
print(arr8)  # 输出结果：[ 1  2 10  4  5  6  7  8  9]

3.直接变维

resize()

# 3.直接变维
arr8.resize(1,4,2)
print(arr8) # 输出结果：[[[ 1  2]
            #           [10  4]
            #            [ 5  6]
            #            [ 7  8]]]

二、ndarray数组切片操作

数组对象[起始位置:终止位置:步长] 起始位置为0，默认步长为1。

1.一维数组切片操作

# 一维数组
arr9 = np.arange(1,10)
# 正向切片 步长为正数
print(arr9[1:5:1]) # 输出结果：[2 3 4 5]
print(arr9[:5:2]) # 输出结果：[1 3 5]
print(arr9[1::2]) # 输出结果：[2 4 6 8]
print(arr9[2:6]) # 输出结果：[3 4 5 6]
print(arr9[::]) # 输出结果：[1 2 3 4 5 6 7 8 9]
# 逆向切片 步长为负数
print(arr9[-1:-5:-1]) # 输出结果：[9 8 7 6]
print(arr9[-2::-2]) # 输出结果：[8 6 4 2]
print(arr9[:-5:-1]) # 输出结果：[9 8 7 6]
print(arr9[::-1]) # 输出结果：[9 8 7 6 5 4 3 2 1]
print(arr9[-1:-5]) # 输出结果：[] 默认步长为1，格式不正确

2.二维数组切片操作

# 二维数组
arr10 = np.arange(1,10)
arr10.resize(3,3)
print(arr10) # 输出结果：[[1 2 3]
                      # [4 5 6]
                      # [7 8 9]]
# 用逗号进行划分行、列的区域范围，逗号左边是负责行的范围，逗号右边是行的范围
print(arr10[1:2,1:2]) # 输出结果：[[5]]
print(arr10[1:,:1]) # 输出结果：[[4]
                       #       [7]]

print(arr10[:2,2:]) # 输出结果：[[3]
                       #       [6]]
print(arr10[:,:]) # 输出结果：[[1 2 3]
                       #     [4 5 6]
                       #      [7 8 9]]

3.三维数组切片操作

# 三维数组
arr11 = np.arange(1,28)
arr11.resize(3,3,3) # 变为3页3行3列的三维数组
print(arr11) # 输出结果：[[[ 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]]]
# 用逗号进行划分页、行、列的区域范围，第一个逗号左边是负责页的范围，第一个逗号和第二个逗号之间是行的范围，第二个逗号右边是列的范围
print(arr11[1:2, 1:2, 1:2]) # 输出结果：[[[14]]]
print(arr11[1:,:2,2:]) # 输出结果：[[[12]
                            #      [15]]
                            #      [[21]
                            #       [24]]]
print(arr11[:,1:,:]) # 输出结果：[[[ 4  5  6]
                            #   [ 7  8  9]]
                            #   [[13 14 15]
                            #    [16 17 18]]
                            #   [[22 23 24]
                            #    [25 26 27]]]
print(arr11[:,:,:])  # 输出结果：[[[ 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]]]

三、ndarray数组的掩码操作

1.基于bool值的掩码

基于bool值的掩码,可以从大数据集中筛选数据子集。

# 基于bool数组的掩码  可以从大数据集中筛选数据子集
arr12 = np.arange(1,21)
# 形成一个bool数组，是5的倍数的为true,不是为false
mask = arr12%5==0
print(mask) # 输出结果：[False False False False  True False False False False  True False False
                #       False False  True False False False False  True]

# 根据mask数组里面的值，true就输出，false不输出
print(arr12[mask]) # 输出结果：[ 5 10 15 20]
# 可以直接将掩码数组写进索引列表
print(arr12[arr12%5==0]) # 输出结果：[ 5 10 15 20]
# 可以进行多条件筛选
mask1 = (arr12%2==0)&(arr12%5==0)
print(arr12[mask1]) # 输出结果：[10 20]

2.基于索引的掩码

基于索引的掩码，可以将数据集中的数据按照指定规则进行变换，如：排序。

# 基于索引的掩码 可以将数据集中的数据按照指定规则进行变换，如：排序
fruits = np.array(['apple','orange','banana','pineapple'])
price_sort =[1,2,0,3]
# 按照索引数组中的索引位置进行排序，如price_sort数组第一个数字为1，代表将fruits数字中索引为1的元素，也就是orange排在第一位，以此类推
print(fruits[price_sort]) # 输出结果：['orange' 'banana' 'apple' 'pineapple']

四、多维数组的合并与拆分

拆分数组时，需要注意两点：

1.进行拆分时需要注意能够进行均分，例如：2行4列的数组，可以平均拆成2和4个数组，但是不能拆成3个数组。

2.需要根据拆分数组的数量，设置相对应数量的变量进行接收，例如：2行4列的数组拆分成2个数组，需要设置2个变量进行接收。

1.水平方向

hstack(合并数组的元组)

hsplic(需要被拆分的数组，拆分数组的个数)

# 水平方向
# hstack(合并数组的元组) 水平方向合并多维数组
# hsplic(需要被拆分的数组，拆分数组的个数)
arr13 = np.arange(1,5)
arr13.resize(2,2)
print(arr13) # 输出结果：[[1 2]
                     #  [3 4]]
arr14 = np.arange(5,9)
arr14.resize(2,2)
print(arr14) # 输出结果：[[5 6]
                    #   [7 8]]
arr15 = np.hstack((arr13,arr14))
print(arr15) # 输出结果：[[1 2 5 6]
                    #   [3 4 7 8]]

a,b= np.hsplit(arr15,2)
c,d,e,f= np.hsplit(arr15,4)
print(a) # 输出结果：[[1 2]
                  # [3 4]]
print(b) # 输出结果：[[5 6]
                  # [7 8]]
print(c) # 输出结果：[[1]
                  #  [3]]
print(d) # 输出结果：[[2]
                  #  [4]]
print(e) # 输出结果：[[5]
                  # [7]]
print(f) # 输出结果：[[6]
                  # [8]]

2.垂直方向

vstack(合并数组的元组)

vsplit(需要被拆分的数组，拆分数组的个数)

# 垂直方向
# vstack(合并数组的元组) 垂直方向合并多维数组
# vsplit(需要被拆分的数组，拆分数组的个数)
arr16 = np.arange(1,5)
arr16.resize(2,2)
print(arr16) # 输出结果：[[1 2]
                      # [3 4]]
arr17 = np.arange(5,9)
arr17.resize(2,2)
print(arr17) # 输出结果：[[5 6]
                      # [7 8]]
arr18 = np.vstack((arr16,arr17))
print(arr18) # 输出结果：[[1 2]
                      #  [3 4]
                      #  [5 6]
                      #  [7 8]]
a1,b1 = np.vsplit(arr18,2)
c1,d1,e1,f1 = np.vsplit(arr18,4)
print(a1) # 输出结果：[[1 2]
                  #  [3 4]]
print(b1) # 输出结果：[[5 6]
                  #  [7 8]]
print(c1) # 输出结果：[[1 2]]
print(d1) # 输出结果：[[3 4]]
print(e1) # 输出结果：[[5 6]]
print(f1) # 输出结果：[[7 8]]

3.深度方向(三维数组)

dstack(合并数组的元组)

dsplit(需要被拆分的数组，拆分数组的个数)

# 深度方向(三维数组)
# dstack(合并数组的元组) 深度方向合并多维数组
# dsplit(需要被拆分的数组，拆分数组的个数)
arr19 = np.arange(1,5)
arr19.resize(2,2)
print(arr19) # 输出结果：[[1 2]
                      # [3 4]]
arr20 = np.arange(5,9)
arr20.resize(2,2)
print(arr20) # 输出结果：[[5 6]
                      # [7 8]]
arr21 = np.dstack((arr19,arr20))
print(arr21) # 输出结果：[[[1 5]
                  #       [2 6]]
                  #     [[3 7]
                  #      [4 8]]]
a2,b2 = np.dsplit(arr21,2)
print(a2) # 输出结果：[[[1]
                  #   [2]]
                  #   [[3]
                  #    [4]]]
print(b2) # 输出结果：[[[5]
                  #    [6]]
                  #   [[7]
                  #    [8]]]

3.长度不等的数组组合

首先将短的数组通过pad函数补充元素到与长的数组长度相同，然后进行组合。

np.pad(需要填充的数组,pad_width=(头部补充元素个数,尾部补充元素个数),mode=“元素类型”,constant_values=用于填充的值)

# 长度不等的数组组合
# pad(需要填充的数组,pad_width=(头部补充元素个数,尾部补充元素个数),mode="元素类型",constant_values=用于填充的值)
arr22 = np.array([1,2,3,4,5])
arr23 = np.array([8,9,10])
# 填充arr23数组，头部补0个元素，尾部补2个元素，补的元素为常量类型，元素值为-1
arr24 = np.pad(arr23,pad_width=(0,2),mode='constant',constant_values=-1)
print(arr24) # 输出结果：[ 8  9 10 -1 -1]

4.多维数组组合和拆分相关函数

np.concatenate(需要合并数组的元组, axis=数字)

np.split(需要拆分的原数组, 拆分数组的数量, axis=数字)

注意：通过axis作为关键字参数指定组合或拆分的方向，取值如下：

​ 若数组都是二维数组：

​ 0：垂直方向组合或拆分

​ 1：水平方向组合或拆分

​ 若待组合数组都是三维数组：

​ 0：垂直方向组合或拆分

​ 1：水平方向组合或拆分

​ 2：深度方向组合或拆分

arr25 = np.arange(1,5).reshape(2,2)
arr26 = np.arange(5,9).reshape(2,2)
arr27 = np.concatenate((arr25,arr26),axis=0)
print(arr27) # [[1 2]
             #   [3 4]
             #   [5 6]
             #   [7 8]]
arr28,arr29=np.split(arr27,2,axis=0)
print(arr28) # 输出结果：[[1 2]
                   #     [3 4]]
print(arr29) # 输出结果：[[5 6]
                   #     [7 8]]

五、ndarray数组其它属性

• shape 维度
• dtype 元素类型
• size 元素数量
• ndim 维数
• itemsize 元素字节数
• nbytes 总字节数 = size x itemsize
• real 复数数组的实部数组
• imag 复数数组的虚部数组
• T 数组对象的转置视图
• flat 扁平迭代器

complex_arr = np.array([[1+1j,2+2j,3+3j,],
                       [4+8j,5+10j,6+12j],
                       [7+21j,8+24j,9+27j]])
print(complex_arr.shape)
print(complex_arr.size)
print(complex_arr.dtype)
print(complex_arr.ndim)
print(complex_arr.itemsize)
print(complex_arr.nbytes)
print(complex_arr.real)
print(complex_arr.imag)
print(complex_arr.T)
print(complex_arr.flat)