numpy数组常用处理函数

机器学习
机器学习初步

numpy数组常用处理函数

  • numpy 数组是python机器学习常用的数据结构，在这里简单记下常见的使用方法和一些初学时遇到的问题
  1. 注意事项
  • 使用数组时不要犯低级错误，注意行数和列数，不要搞反了。
  • np.array转化宽度不一致的数组时会出现未知错误，使用时要谨慎。
  • numpy使用元组作为引用，容易和多维数组按层拆分搞混，多维数组不支持元组索引（numpy也支持按层拆分）如：a[1,2]和b[1][2]。
  • 注意矩阵乘法转置。
  • 注意numpy不是默认二维数组， 若矩阵为向量，则只有shape[0](即向量长度为shape[0]而不是它作为矩阵时的shape[1]): [1,2,3,4] 看作矩阵： shape:[1,4] 看作向量：shape:[4]
  • 在维度不匹配的时候可以加上shape先判断。
  • 矩阵第一个参数为行数，第二个为列数…申请空白2维矩阵:(0,2)
  • 添加新行：
    np.append(red,[vx],axis=0)此处的vx必须升维到与大矩阵相同，axis表示添加一行
    或yellow=np.r_[yellow,[vx]]，道理同上
  1. python代码 
    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
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    a = [1,2,3] 
    b = [4,5,6] 
    c = [4,5,6,7,8] 
    zipped = zip(a,b) # 打包为元组的列表 [(1, 4), (2, 5), (3, 6)] 
     zip(a,c) # 元素个数与最短的列表一致 [(1, 4), (2, 5), (3, 6)] 
     zip(*zipped) 
     # 与 zip 相反，可理解为解压，返回二维矩阵式 [(1, 2, 3), (4, 5, 6)]
    X=np.array([[1,2,3][4,5,6]])
    a=np.arange(9).reshape(3,3)
    a
    Out[31]: 
    array([[0, 1, 2],
           [3, 4, 5],
           [6, 7, 8]])
    '''
    注意，由于数组可以为高维，所以在此处需要用元组来包裹其尺寸。
    '''
    Z0 = np.zeros((2,2))  # Create an array of all zeros
    print Z0              # Prints "[[ 0.  0.]
                         #          [ 0.  0.]]"
                         
    z1=np.empty((2,))
    b = np.ones((1,2))   # Create an array of all ones
    print b              # Prints "[[ 1.  1.]]"
    c = np.full((2,2), 7) # Create a constant array
    print c               # Prints "[[ 7.  7.]
                          #          [ 7.  7.]]"
    I = np.eye(2)        # Create a 2x2 identity matrix
    print I              # Prints "[[ 1.  0.]
                         #          [ 0.  1.]]"
    e = np.random.random((2,2)) 
    # Create an array filled with random values
    print e                     
    # Might print "[[ 0.91940167  0.08143941]
    #  [ 0.68744134  0.87236687]]"
    扩展矩阵函数tile()
    np.tile(a,(m,n))
    >>>x=np.array([0,0,0])
    >>> x
    [[0, 0, 0]]
    >>> tile(x,(3,1))           #即将x扩展3个，j=1,表示其列数不变
    matrix([[0, 0, 0],
            [0, 0, 0],
            [0, 0, 0]])
    >>> tile(x,(2,2))           #x扩展2次，j=2,横向扩展
    matrix([[0, 0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0, 0]])
    '''
    矩阵合并函数
    '''
    hstack : Stack arrays in sequence horizontally (column wise).
    vstack : Stack arrays in sequence vertically (row wise).
    dstack : Stack arrays in sequence depth wise (along third axis).
    concatenate : Join a sequence of arrays together.
    r_ : Translates slice objects to concatenation along the first 
    axis.
    c_ : Translates slice objects to concatenation along the second 
    axis.
    '''
    使用np.c_[]和np.r_[]分别添加行和列
    注：该方法只能将两个矩阵合并，不会改变原矩阵的维度
    '''
    np.c_[a,b]
    '''
    将b以列的形式拼接至a的后面
    '''
    ### 推荐用法：
    newarray=numpy.insert(arr, obj, values, axis=None) 
    '''
    arr：被插入的矩阵
    obj：要被插入的行（列）位置，将会插入到它的前一行（列）
    values：插入值（矩阵）
    axis：轴值，若未填入则矩阵会被展开,为0则插入行，1则插入列。
    '''
    array([[0, 1, 2],
           [3, 4, 5],
           [6, 7, 8]])
    '''
    取矩阵的某一行
    '''
    a[1]
    Out[32]: array([3, 4, 5])
    '''
    取矩阵的某一列
    '''
    a[:,1]
    Out[33]: array([1, 4, 7])
    a.reshape(3, 4, -1)
    a.T # 转置
    a.transpose() # 转置
    numpy.linalg.inv(a) # 求逆
    a.diagonal([offset, axis1, axis2]) # 对角元
    np.linalg.norm(np_c1 - np_c2) #计算点c1和c2之间的欧式距离（一个点为一行）
    numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, 
    dtype=None)
    # 返回均匀相隔的一组数据(num个)：
    Out:[start,start+step…]

对数据点按标记值创建分类组

1
2
3
4
5
6
7
8
9
10
import numpy as np # 注：必须要numpy才能成功
x = np.array([1, 2, 3, 4])
y = np.array([1, 0, 0, 2])
test = x[y == 0]
print(test)
'''
输出：[2 3]
'''

shuffle_data函数（对整个数据集进行洗牌，但x与y绑定）

1
2
3
4
5
6
7
8
9
10
11
12
import numpy as np 
def shuffle_data(train_data, train_target):
    batch_size= len(train_target)
    index = [i for i in range(0, batch_size)]
    np.random.shuffle(index)
    batch_data = []
    batch_target = []
    for i in range(0, batch_size):
        batch_data.append(train_data[index[i]])
        batch_target.append(train_target[index[i]])
    return batch_data, batch_target

填充

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
# 直接用
lenth=10
a=np.array([[6,6],
           [6,6]])
a=np.pad(a,((0,0),(0,lenth-a.shape[1])),
         'constant', constant_values=0)
'''
[[6 6 0 0 0 0 0 0 0 0]
 [6 6 0 0 0 0 0 0 0 0]]
'''
# 其他详细操作
a=np.array([[6,6],
           [6,6]])
b=np.pad(a,((1,2),(3,4)),
         'constant', constant_values=(0, 1))
print(b)
'''
[[0 0 0 0 0 1 1 1 1]
 [0 0 0 6 6 1 1 1 1]
 [0 0 0 6 6 1 1 1 1]
 [0 0 0 1 1 1 1 1 1]
 [0 0 0 1 1 1 1 1 1]]
'''
a=np.array([[6,6],
           [6,6]])
b=np.pad(a,((0,0),(0,4)),
         'constant', constant_values=( 0))
print(b)
'''
[[6 6 0 0 0 0]
 [6 6 0 0 0 0]]
'''

二进制保存

1
2
3
4
5
6
7
m=np.array(n)
m.tofile('test/m.bin')
...
m=fromfile('test/m.bin',dtype=np.float).reshape(-1,x,x)
np.save('test/m.npy',m)
m=np.load('test/m.npy')