精华内容
下载资源
问答
  • numpy总结
    千次阅读
    2021-01-18 11:46:34

    Python从入门到精通2–numpy总结

    在这里插入图片描述

    文章目录

    1.查看numpy版本

    import numpy as np
    print(np.__version__)
    
    1.19.2
    

    2.创建十个全为0的一维数组

    np.zeros(10)
    
    array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
    

    3.修改数据类型为整数

    np.zeros(10,dtype = 'int')
    
    array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
    

    4.创建固定步长的数

    np.arange(0,100,5)
    
    array([ 0,  5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80,
           85, 90, 95])
    

    5.列表创建数组

    List = [1,2,3,4,5,6,7,8,9]
    result = np.array(List)
    result
    
    array([1, 2, 3, 4, 5, 6, 7, 8, 9])
    

    6.创建全是1的矩阵

    #方法1
    np.ones((3,3))
    #方法2
    np.array([[ 1., 1., 1.],
           [ 1., 1., 1.],
           [ 1., 1., 1.]])
    
    array([[1., 1., 1.],
           [1., 1., 1.],
           [1., 1., 1.]])
    

    7.创建布尔类型的True

    np.full((2,2), True, dtype=bool)
    
    array([[ True,  True],
           [ True,  True]])
    

    8.创建等差数列

    备注:从5开始,50结束,共10个数据

    np.linspace(start=5,stop=50,num=10)
    
    array([ 5., 10., 15., 20., 25., 30., 35., 40., 45., 50.])
    

    9.创建等差数列

    np.arange(start = 5, stop = 55, step = 5,dtype = 'int32')
    
    array([ 5, 10, 15, 20, 25, 30, 35, 40, 45, 50])
    

    10.创建3x3矩阵

    备注:矩阵元素均为0—10之间的随机数

    np.random.randint(0,10,(3,3))
    
    array([[5, 3, 3],
           [2, 0, 4],
           [7, 6, 2]])
    

    11.创建3x3矩阵

    备注:矩阵元素均为服从标准正态分布的随机数

    np.random.randn(3, 3)
    
    array([[ 0.77191714,  1.99485092,  0.36574655],
           [-2.35963788, -0.18879237,  1.00267285],
           [-1.20021396, -0.87413623, -0.17664144]])
    

    12.将第五题的result修改为3x3矩阵

    result = result.reshape(3,3)
    

    13.对上一题生成的result取转置

    result.T
    
    array([[1, 4, 7],
           [2, 5, 8],
           [3, 6, 9]])
    

    14.查看数据类型

    result.dtype
    #dtype('int64')
    
    dtype('int32')
    

    15.查看内存占用

    #方法一:直接查看
    print(result.nbytes)
    #方法2手动计算
    print(result.itemsize * 9)
    
    36
    36
    

    16.将数据类型修改为float

    result = result.astype(float)
    

    17.提取第三行第三列的元素

    result[2,2]
    
    9.0
    

    18.将第三行第三列的元素放大十倍

    result[2,2] = result[2,2] * 10
    

    19.提取result中的所有偶数

    result[result % 2 == 0]
    
    array([ 2.,  4.,  6.,  8., 90.])
    

    20.将result中所有奇数修改为666

    result[result % 2 == 1] = 666
    

    21.创建主对角线都是5的5x5矩阵

    result = np.diag([5,5,5,5,5])
    result
    
    array([[5, 0, 0, 0, 0],
           [0, 5, 0, 0, 0],
           [0, 0, 5, 0, 0],
           [0, 0, 0, 5, 0],
           [0, 0, 0, 0, 5]])
    

    22.交换第一列与第二列

    a = result[:, [1,0,2,3,4]]
    

    23.交换第一行与第二行

    b = result[[0,1,2,4,3], :]
    

    24.判断两个矩阵是否有任何元素不同(使用22,23两题得到的矩阵)

    print((a == b).all())
    
    False
    

    25.计算两个矩阵不同元素的个数(使用22,23两题得到的矩阵)

    len(np.argwhere(a != b))
    
    8
    

    26.找到两个矩阵不同元素的位置(使用22,23两题得到的矩阵)

    np.argwhere(a != b)
    
    array([[0, 0],
           [0, 1],
           [1, 0],
           [1, 1],
           [3, 3],
           [3, 4],
           [4, 3],
           [4, 4]], dtype=int64)
    

    27.矩阵乘法(使用22,23两题得到的矩阵)

    np.dot(a,b)
    
    array([[ 0, 25,  0,  0,  0],
           [25,  0,  0,  0,  0],
           [ 0,  0, 25,  0,  0],
           [ 0,  0,  0,  0, 25],
           [ 0,  0,  0, 25,  0]])
    

    28.矩阵对应元素相乘(使用22,23两题得到的矩阵)

    print(np.multiply(a,b))
    print('========方法2========')
    print(a * b) #方法2
    
    [[ 0  0  0  0  0]
     [ 0  0  0  0  0]
     [ 0  0 25  0  0]
     [ 0  0  0  0  0]
     [ 0  0  0  0  0]]
    ========方法2========
    [[ 0  0  0  0  0]
     [ 0  0  0  0  0]
     [ 0  0 25  0  0]
     [ 0  0  0  0  0]
     [ 0  0  0  0  0]]
    

    29.计算行列式(使用21题生成的矩阵)

    np.linalg.det(result)
    
    3124.999999999999
    

    30.矩阵求逆(使用21题生成的矩阵)

    np.linalg.inv(result)
    
    array([[0.2, 0. , 0. , 0. , 0. ],
           [0. , 0.2, 0. , 0. , 0. ],
           [0. , 0. , 0.2, 0. , 0. ],
           [0. , 0. , 0. , 0.2, 0. ],
           [0. , 0. , 0. , 0. , 0.2]])
    

    31.将22与23题生成的np.array对象修改为np.matrix对象

    a = np.matrix(a)
    b = np.matrix(b)
    

    32.计算上一题生成的两个np.matrix格式矩阵的对应元素乘积(对比异同)

    np.multiply(a,b)
    
    matrix([[ 0,  0,  0,  0,  0],
            [ 0,  0,  0,  0,  0],
            [ 0,  0, 25,  0,  0],
            [ 0,  0,  0,  0,  0],
            [ 0,  0,  0,  0,  0]])
    

    33.对31题生成的两个np.matrix格式矩阵做矩阵乘法(对比异同)

    a * b
    
    matrix([[ 0, 25,  0,  0,  0],
            [25,  0,  0,  0,  0],
            [ 0,  0, 25,  0,  0],
            [ 0,  0,  0,  0, 25],
            [ 0,  0,  0, 25,  0]])
    

    34.将两个矩阵按照行拼接

    np.hstack((a,b))
    
    matrix([[0, 5, 0, 0, 0, 5, 0, 0, 0, 0],
            [5, 0, 0, 0, 0, 0, 5, 0, 0, 0],
            [0, 0, 5, 0, 0, 0, 0, 5, 0, 0],
            [0, 0, 0, 5, 0, 0, 0, 0, 0, 5],
            [0, 0, 0, 0, 5, 0, 0, 0, 5, 0]])
    

    35.将两个矩阵按照列拼接

    np.vstack((a,b))
    
    matrix([[0, 5, 0, 0, 0],
            [5, 0, 0, 0, 0],
            [0, 0, 5, 0, 0],
            [0, 0, 0, 5, 0],
            [0, 0, 0, 0, 5],
            [5, 0, 0, 0, 0],
            [0, 5, 0, 0, 0],
            [0, 0, 5, 0, 0],
            [0, 0, 0, 0, 5],
            [0, 0, 0, 5, 0]])
    

    36.思考下面代码运行后new的结果

    new = np.pad(result,pad_width = 1,constant_values=1)
    

    37.找到new中大于1的元素的位置

    np.argwhere(new > 1)
    
    array([[1, 1],
           [2, 2],
           [3, 3],
           [4, 4],
           [5, 5]], dtype=int64)
    

    38.将new中大于1的元素修改为9

    new[new > 1] = 8
    new
    
    array([[1, 1, 1, 1, 1, 1, 1],
           [1, 8, 0, 0, 0, 0, 1],
           [1, 0, 8, 0, 0, 0, 1],
           [1, 0, 0, 8, 0, 0, 1],
           [1, 0, 0, 0, 8, 0, 1],
           [1, 0, 0, 0, 0, 8, 1],
           [1, 1, 1, 1, 1, 1, 1]])
    

    39.对new按列求和

    np.sum(new, 0)
    
    array([ 7, 10, 10, 10, 10, 10,  7])
    

    40.对new按行求和

    np.sum(new, 1)
    
    array([ 7, 10, 10, 10, 10, 10,  7])
    
    import numpy as np
    import pandas as pd
    import warnings
    warnings.filterwarnings("ignore")
    

    41 生成指定格式数据

    备注:使用numpy生成6行6列的二维数组,值为1-100随机数

    data = np.random.randint(1,100, [6,6])
    data
    
    array([[64, 81,  4, 42, 31, 32],
           [73, 24, 12, 93, 67, 87],
           [95,  1, 61, 60, 63, 45],
           [56, 22, 75, 50, 63, 38],
           [67, 82, 39, 64, 12, 77],
           [77, 41, 52, 53,  7,  7]])
    

    42 找到每列的最大值

    np.amax(data, axis=0)
    
    array([95, 82, 75, 93, 67, 87])
    

    43 找到每行的最小值

    np.amin(data, axis=1)
    
    array([ 4, 12,  1, 22, 12,  7])
    

    44 提取data每个元素的出现次数

    np.unique(data,return_counts=True)
    
    (array([ 1,  4,  7, 12, 22, 24, 31, 32, 38, 39, 41, 42, 45, 50, 52, 53, 56,
            60, 61, 63, 64, 67, 73, 75, 77, 81, 82, 87, 93, 95]),
     array([1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
            1, 1, 2, 1, 1, 1, 1, 1], dtype=int64))
    

    45 获取data每行元素的大小排名

    data.argsort()
    
    array([[2, 4, 5, 3, 0, 1],
           [2, 1, 4, 0, 5, 3],
           [1, 5, 3, 2, 4, 0],
           [1, 5, 3, 0, 4, 2],
           [4, 2, 3, 0, 5, 1],
           [4, 5, 1, 2, 3, 0]], dtype=int64)
    

    46 将数组按行重复一次

    np.repeat(data, 2, axis=0)
    
    array([[64, 81,  4, 42, 31, 32],
           [64, 81,  4, 42, 31, 32],
           [73, 24, 12, 93, 67, 87],
           [73, 24, 12, 93, 67, 87],
           [95,  1, 61, 60, 63, 45],
           [95,  1, 61, 60, 63, 45],
           [56, 22, 75, 50, 63, 38],
           [56, 22, 75, 50, 63, 38],
           [67, 82, 39, 64, 12, 77],
           [67, 82, 39, 64, 12, 77],
           [77, 41, 52, 53,  7,  7],
           [77, 41, 52, 53,  7,  7]])
    

    47 去除数组的重复行

    np.unique(data,axis = 0)
    
    array([[56, 22, 75, 50, 63, 38],
           [64, 81,  4, 42, 31, 32],
           [67, 82, 39, 64, 12, 77],
           [73, 24, 12, 93, 67, 87],
           [77, 41, 52, 53,  7,  7],
           [95,  1, 61, 60, 63, 45]])
    

    48 不放回抽样

    备注:从data的第一行中不放回抽3个元素

    np.random.choice(data[0:1][0], 3, replace=False)
    
    array([31, 42, 81])
    

    49 提取data第二行中不含第三行的元素的元素

    a = data[1:2]
    b = data[2:3]
    index=np.isin(a,b)
    array=a[~index]
    array
    
    array([73, 24, 12, 93, 67, 87])
    

    50 判断data是否有空行

    (~data.any(axis=1)).any()
    
    False
    

    51 将每行升序排列

    data.sort(axis = 1)
    data
    
    array([[ 4, 31, 32, 42, 64, 81],
           [12, 24, 67, 73, 87, 93],
           [ 1, 45, 60, 61, 63, 95],
           [22, 38, 50, 56, 63, 75],
           [12, 39, 64, 67, 77, 82],
           [ 7,  7, 41, 52, 53, 77]])
    

    52 将data的数据格式修改为float

    data1 = data.astype(float)
    

    53 将小于5的元素修改为nan

    data1[data1 < 5] = np.nan
    data1
    
    array([[nan, 31., 32., 42., 64., 81.],
           [12., 24., 67., 73., 87., 93.],
           [nan, 45., 60., 61., 63., 95.],
           [22., 38., 50., 56., 63., 75.],
           [12., 39., 64., 67., 77., 82.],
           [ 7.,  7., 41., 52., 53., 77.]])
    

    54 删除data1含有nan的行

    data1 = data1[~np.isnan(data1).any(axis=1), :]
    
    data1
    
    array([[12., 24., 67., 73., 87., 93.],
           [22., 38., 50., 56., 63., 75.],
           [12., 39., 64., 67., 77., 82.],
           [ 7.,  7., 41., 52., 53., 77.]])
    

    55 找出data1第一行出现频率最高的值

    vals, counts = np.unique(data1[0,:], return_counts=True)
    print(vals[np.argmax(counts)])
    
    12.0
    

    56 找到data1中与100最接近的数字

    a = 100
    data1.flat[np.abs(data1 - a).argmin()]
    
    93.0
    

    57 data1每一行的元素减去每一行的平均值

    data1 - data1.mean(axis=1, keepdims=True)
    
    array([[-47.33333333, -35.33333333,   7.66666667,  13.66666667,
             27.66666667,  33.66666667],
           [-28.66666667, -12.66666667,  -0.66666667,   5.33333333,
             12.33333333,  24.33333333],
           [-44.83333333, -17.83333333,   7.16666667,  10.16666667,
             20.16666667,  25.16666667],
           [-32.5       , -32.5       ,   1.5       ,  12.5       ,
             13.5       ,  37.5       ]])
    

    58 将data1归一化至区间[0,1]

    a = np.max(data1) - np.min(data1)
    (data1 - np.min(data1)) / a
    
    array([[0.05813953, 0.19767442, 0.69767442, 0.76744186, 0.93023256,
            1.        ],
           [0.1744186 , 0.36046512, 0.5       , 0.56976744, 0.65116279,
            0.79069767],
           [0.05813953, 0.37209302, 0.6627907 , 0.69767442, 0.81395349,
            0.87209302],
           [0.        , 0.        , 0.39534884, 0.52325581, 0.53488372,
            0.81395349]])
    

    59 将data1标准化

    mu = np.mean(data1, axis=0)
    sigma = np.std(data1, axis=0)
    (data1 - mu) / sigma
    
    array([[-0.22941573, -0.23111136,  1.09030457,  1.31008094,  1.30769231,
             1.61229232],
           [ 1.60591014,  0.84740834, -0.52145001, -0.7145896 , -0.53846154,
            -0.96737539],
           [-0.22941573,  0.92444546,  0.80587729,  0.59549133,  0.53846154,
             0.03582872],
           [-1.14707867, -1.54074243, -1.37473184, -1.19098267, -1.30769231,
            -0.68074565]])
    

    60 将data1存储至本地

    np.savetxt('test.txt',data1)
    
    import numpy as np
    import pandas as pd
    import warnings
    warnings.filterwarnings("ignore")
    

    61.如何获得两个数组之间的相同元素

    输入:

    arr1 = np.random.randint(10,6,6)

    arr2 = np.random.randint(10,6,6)

    arr1 = np.random.randint(1,10,10)
    arr2 = np.random.randint(1,10,10)
    
    print("arr1: %s"%arr1)
    print("arr2: %s"%arr2)
    np.intersect1d(arr1,arr2)
    
    arr1: [1 7 4 9 2 3 8 8 2 9]
    arr2: [5 7 7 2 3 7 4 8 4 1]
    
    
    
    
    
    array([1, 2, 3, 4, 7, 8])
    

    62.如何从一个数组中删除另一个数组存在的元素

    输入:

    arr1 = np.random.randint(1,10,10)

    arr2 = np.random.randint(1,10,10)

    arr1 = np.random.randint(1,10,10)
    arr2 = np.random.randint(1,10,10)
    print("arr1: %s"%arr1)
    print("arr2: %s"%arr2)
    np.setdiff1d(arr1,arr2)
    
    arr1: [3 7 6 4 4 8 6 2 4 6]
    arr2: [7 2 2 4 5 5 3 7 2 1]
    
    
    
    
    
    array([6, 8])
    

    63.如何修改一个数组为只读模式

    输入:

    arr1 = np.random.randint(1,10,10)

    arr1 = np.random.randint(1,10,10)
    arr1.flags.writeable = False
    
    #尝试修改会报错!
    arr1[0] = 6
    
    ---------------------------------------------------------------------------
    
    ValueError                                Traceback (most recent call last)
    
    <ipython-input-69-ddcf305e5efb> in <module>
          1 #尝试修改会报错!
    ----> 2 arr1[0] = 6
    
    
    ValueError: assignment destination is read-only
    

    64.如何将list转为numpy数组

    输入:

    a = [1,2,3,4,5]

    a = [1,2,3,4,5]
    np.array(a)
    

    65.如何将pd.DataFrame转为numpy数组

    输入:

    df = pd.DataFrame({‘A’:[1,2,3],‘B’:[4,5,6],‘C’:[7,8,9]})

    df = pd.DataFrame({'A':[1,2,3],'B':[4,5,6],'C':[7,8,9]})
    print(df)
    print(df.values)
    

    66.如何使用numpy进行描述性统计分析

    输入:

    arr1 = np.random.randint(1,10,10)

    arr2 = np.random.randint(1,10,10)

    arr1 = np.random.randint(1,10,10)
    arr2 = np.random.randint(1,10,10)
    
    print("arr1的平均数为:%s" %np.mean(arr1))
    print("arr1的中位数为:%s" %np.median(arr1))
    print("arr1的方差为:%s" %np.var(arr1))
    print("arr1的标准差为:%s" %np.std(arr1))
    print("arr1,arr的相关性矩阵为:%s" %np.cov(arr1,arr2))
    print("arr1,arr的协方差矩阵为:%s" %np.corrcoef(arr1,arr2))
    

    67.如何使用numpy进行概率抽样

    输入:

    arr = np.array([1,2,3,4,5])

    arr = np.array([1,2,3,4,5])
    np.random.choice(arr,10,p = [0.1,0.1,0.1,0.1,0.6])
    

    68.如何创建副本

    输入:

    arr = np.array([1,2,3,4,5])

    #对副本数据进行修改,不会影响到原始数据
    arr = np.array([1,2,3,4,5])
    arr1 = arr.copy()
    

    69.如何对数组切片

    输入:
    arr = np.arange(10)

    备注:从索引2开始到索引8停止,间隔为2

    arr = np.arange(10)
    a = slice(2,8,2)
    arr[a] #等价于arr[2:8:2]
    
    array([2, 4, 6])
    

    70.如何使用NumPy操作字符串

    输入:

    str1 = [‘I love’]

    str2 = [’ Python’]

    #拼接字符串
    str1 = ['I love']
    str2 = [' Python']
    print(np.char.add(str1,str2))
    
    #大写首字母
    str3 = np.char.add(str1,str2)
    print(np.char.title(str3))
    
    ['I love Python']
    ['I Love Python']
    

    71.如何对数据向上/下取整

    输入:

    arr = np.random.uniform(0,10,10)

    arr = np.random.uniform(0,10,10)
    print(arr)
    ###向上取整
    print(np.ceil(arr))
    ###向下取整
    print(np.floor(arr) )
    
    [7.93163895 0.25298605 8.03086361 6.60320156 8.03587266 2.22664371
     9.18459953 9.2502519  7.75398358 4.22163385]
    [ 8.  1.  9.  7.  9.  3. 10. 10.  8.  5.]
    [7. 0. 8. 6. 8. 2. 9. 9. 7. 4.]
    

    72.如何取消默认科学计数显示数据

    np.set_printoptions(suppress=True)
    

    73.如何使用NumPy对二维数组逆序

    输入:

    arr = np.random.randint(1,10,[3,3])

    arr = np.random.randint(1,10,[3,3])
    print(arr)
    print('列逆序')
    print(arr[:, -1::-1])
    print('行逆序')
    print(arr[-1::-1, :])
    
    [[3 1 1]
     [8 7 2]
     [4 4 8]]
    列逆序
    [[1 1 3]
     [2 7 8]
     [8 4 4]]
    行逆序
    [[4 4 8]
     [8 7 2]
     [3 1 1]]
    

    74.如何使用NumPy根据位置查找元素

    输入:

    arr1 = np.random.randint(1,10,5)

    arr2 = np.random.randint(1,20,10)

    备注:在arr2中根据arr1中元素以位置查找

    arr1 = np.random.randint(1,10,5)
    arr2 = np.random.randint(1,20,10)
    print(arr1)
    print(arr2)
    print(np.take(arr2,arr1))
    
    [9 6 5 4 9]
    [13 14  4 16  4 10 15  6  5  3]
    [ 3 15 10  4  3]
    

    75.如何使用numpy求余数

    输入:

    a = 10

    b = 3

    np.mod(a,b)
    
    ---------------------------------------------------------------------------
    
    TypeError                                 Traceback (most recent call last)
    
    <ipython-input-76-2a4695c40758> in <module>
    ----> 1 np.mod(a,b)
    
    
    TypeError: unsupported operand type(s) for %: 'slice' and 'int'
    

    76.如何使用NumPy进行矩阵SVD分解

    输入:

    A = np.random.randint(1,10,[3,3])

    np.linalg.svd(A)
    

    77.如何使用NumPy多条件筛选数据

    输入:

    arr = np.random.randint(1,20,10)

    arr = np.random.randint(1,20,10)
    print(arr[(arr>1)&(arr<7)&(arr%2==0)])
    
    [4]
    

    78.如何使用NumPy对数组分类

    输入:

    arr = np.random.randint(1,20,10)

    备注:将大于等于7,或小于3的元素标记为1,其余为0

    arr = np.random.randint(1,20,10)
    print(arr)
    print(np.piecewise(arr, [arr < 3, arr >= 7], [-1, 1]))
    
    [17 16  1  1  7  2  5  3 13 16]
    [ 1  1 -1 -1  1 -1  0  0  1  1]
    

    79如何使用NumPy压缩矩阵

    输入:

    arr = np.random.randint(1,10,[3,1])

    备注:从数组的形状中删除单维度条目,即把shape中为1的维度去掉

    arr = np.random.randint(1,10,[3,1])
    print(arr)
    print(np.squeeze(arr))
    
    [[7]
     [9]
     [1]]
    [7 9 1]
    

    80.如何使用numpy求解线性方程组

    输入:

    A = np.array([[1, 2, 3], [2, -1, 1], [3, 0, -1]])

    b = np.array([9, 8, 3])

    求解Ax = b

    A = np.array([[1, 2, 3], [2, -1, 1], [3, 0, -1]])
    b = np.array([9, 8, 3])
    x = np.linalg.solve(A, b)
    print(x)
    
    [ 2. -1.  3.]
    
    更多相关内容
  • Numpy 总结

    2018-03-11 23:12:10
     numpy概述numpy(Numerical Python)提供了python对多维数组对象ndarray(应该是N-dimension array)的支持,具有矢量运算能力,快速、节省空间。numpy支持高级大量的维度数组与矩阵运算,此外也针对数组运算提供...
     NUMPY

    原始地址: http://blog.csdn.net/cxmscb/article/details/54583415  

    1. numpy概述

    numpy(Numerical Python)提供了python对多维数组对象ndarray(应该是N-dimension array的支持,具有矢量运算能力,快速、节省空间。numpy支持高级大量的维度数组与矩阵运算,此外也针对数组运算提供大量的数学函数库。

    2. 创建ndarray数组

    ndarray:N维数组对象(矩阵),所有元素必须是相同类型。
    ndarray属性:ndim属性,表示维度个数;shape属性,表示各维度大小;dtype属性,表示数据类型。

    创建ndarray数组函数:


    import numpy;
    
    print '使用列表生成一维数组'
    data = [1,2,3,4,5,6]
    x = numpy.array(data)
    print x #打印数组
    print x.dtype #打印数组元素的类型
    
    print '使用列表生成二维数组'
    data = [[1,2],[3,4],[5,6]]
    x = numpy.array(data)
    print x #打印数组
    print x.ndim #打印数组的维度
    print x.shape #打印数组各个维度的长度。shape是一个元组
    
    print '使用zero/ones/empty创建数组:根据shape来创建'
    x = numpy.zeros(6) #创建一维长度为6的,元素都是0一维数组
    print x
    x = numpy.zeros((2,3)) #创建一维长度为2,二维长度为3的二维0数组
    print x
    x = numpy.ones((2,3)) #创建一维长度为2,二维长度为3的二维1数组
    print x
    x = numpy.empty((3,3)) #创建一维长度为2,二维长度为3,未初始化的二维数组
    print x
    
    print '使用arrange生成连续元素'
    print numpy.arange(6) # [0,1,2,3,4,5,] 开区间
    print numpy.arange(0,6,2)  # [0, 2,4]
    
    3. 指定ndarray数组元素的类型

    NumPy数据类型:

    print '生成指定元素类型的数组:设置dtype属性'
    x = numpy.array([1,2.6,3],dtype = numpy.int64)
    print x # 元素类型为int64
    print x.dtype
    x = numpy.array([1,2,3],dtype = numpy.float64)
    print x # 元素类型为float64
    print x.dtype
    
    print '使用astype复制数组,并转换类型'
    x = numpy.array([1,2.6,3],dtype = numpy.float64)
    y = x.astype(numpy.int32)
    print y # [1 2 3]
    print x # [ 1.   2.6  3. ]
    z = y.astype(numpy.float64)
    print z # [ 1.  2.  3.]
    
    print '将字符串元素转换为数值元素'
    x = numpy.array(['1','2','3'],dtype = numpy.string_)
    y = x.astype(numpy.int32)
    print x # ['1' '2' '3']
    print y # [1 2 3] 若转换失败会抛出异常
    
    print '使用其他数组的数据类型作为参数'
    x = numpy.array([ 1., 2.6,3. ],dtype = numpy.float32);
    y = numpy.arange(3,dtype=numpy.int32);
    print y # [0 1 2]
    print y.astype(x.dtype) # [ 0.  1.  2.]
    

    4. ndarray的矢量化计算

    包括矢量运算,矢量和标量运算。代码示例如下:

    print 'ndarray数组与标量/数组的运算'
    x = numpy.array([1,2,3]) 
    print x*2 # [2 4 6]
    print x>2 # [False False  True]
    y = numpy.array([3,4,5])
    print x+y # [4 6 8]
    print x>y # [False False False]
    

    5. ndarray数组的基本索引和切片

    一维数组的索引:与Python的列表索引功能相似

    多维数组的索引:

    ·      arr[r1:r2, c1:c2]

    ·      arr[1,1] 等价 arr[1][1]

    ·      [:] 代表某个维度的数据

    代码示例:

    print 'ndarray的基本索引'
    x = numpy.array([[1,2],[3,4],[5,6]])
    print x[0] # [1,2]
    print x[0][1] # 2,普通python数组的索引
    print x[0,1] # 同x[0][1],ndarray数组的索引
    x = numpy.array([[[1, 2], [3,4]], [[5, 6], [7,8]]])
    print x[0] # [[1 2],[3 4]]
    y = x[0].copy() # 生成一个副本
    z = x[0] # 未生成一个副本
    print y #  [[1 2],[3 4]]
    print y[0,0] # 1
    y[0,0] = 0 
    z[0,0] = -1
    print y # [[0 2],[3 4]]
    print x[0] # [[-1 2],[3 4]]
    print z # [[-1 2],[3 4]]
    
    print 'ndarray的切片'
    x = numpy.array([1,2,3,4,5])
    print x[1:3] # [2,3] 右边开区间
    print x[:3] # [1,2,3] 左边默认为 0
    print x[1:] # [2,3,4,5] 右边默认为元素个数
    print x[0:4:2] # [1,3] 下标递增2
    x = numpy.array([[1,2],[3,4],[5,6]])
    print x[:2] # [[1 2],[3 4]]
    print x[:2,:1] # [[1],[3]]
    x[:2,:1] = 0 # 用标量赋值
    print x # [[0,2],[0,4],[5,6]]
    x[:2,:1] = [[8],[6]] # 用数组赋值
    print x # [[8,2],[6,4],[5,6]]
    

    6. ndarray数组的布尔索引和花式索引

    布尔索引:使用布尔数组作为索引。arr[condition],condition为一个条件/多个条件组成的布尔数组。

    布尔型索引代码示例:

    print 'ndarray的布尔型索引'
    x = numpy.array([3,2,3,1,3,0])
    # 布尔型数组的长度必须跟被索引的轴长度一致
    y = numpy.array([True,False,True,False,True,False]) 
    print x[y] # [3,3,3] 
    print x[y==False] # [2,1,0]
    print x>=3 # [ True False  True False  True  False]
    print x[~(x>=3)] # [2,1,0]
    print (x==2)|(x==1) # [False  True False  True False False]
    print x[(x==2)|(x==1)] # [2 1]
    x[(x==2)|(x==1)] = 0
    print x # [3 0 3 0 3 0]
    

    花式索引:使用整型数组作为索引。示例如下:

    print 'ndarray的花式索引:使用整型数组作为索引'
    x = numpy.array([1,2,3,4,5,6])
    print x[[0,1,2]] # [1 2 3]
    print x[[-1,-2,-3]] # [6,5,4]
    x = numpy.array([[1,2],[3,4],[5,6]])
    print x[[0,1]] # [[1,2],[3,4]]
    print x[[0,1],[0,1]] # [1,4] 打印x[0][0]和x[1][1]
    print x[[0,1]][:,[0,1]] # 打印01行的01列 [[1,2],[3,4]]
    # 使用numpy.ix_()函数增强可读性
    print x[numpy.ix_([0,1],[0,1])] #同上 打印01行的01列 [[1,2],[3,4]]
    x[[0,1],[0,1]] = [0,0]
    print x # [[0,2],[3,0],[5,6]]
    

    7. ndarray数组的转置和轴对换

    数组的转置/轴对换只会返回源数据的一个视图,不会对源数据进行修改。代码示例:

    print 'ndarray数组的转置和轴对换'
    k = numpy.arange(9) #[0,1,....8]
    m = k.reshape((3,3)) # 改变数组的shape复制生成2维的,每个维度长度为3的数组
    print k # [0 1 2 3 4 5 6 7 8]
    print m # [[0 1 2] [3 4 5] [6 7 8]]
    # 转置(矩阵)数组:T属性 : mT[x][y] = m[y][x]
    print m.T # [[0 3 6] [1 4 7] [2 5 8]]
    # 计算矩阵的内积 xTx
    print numpy.dot(m,m.T) # numpy.dot点乘
    # 高维数组的轴对象
    k = numpy.arange(8).reshape(2,2,2)
    print k # [[[0 1],[2 3]],[[4 5],[6 7]]]
    print k[1][0][0]
    # 轴变换 transpose 参数:由轴编号组成的元组
    m = k.transpose((1,0,2)) # m[y][x][z] = k[x][y][z]
    print m # [[[0 1],[4 5]],[[2 3],[6 7]]]
    print m[0][1][0]
    # 轴交换 swapaxes (axes:轴),参数:一对轴编号
    m = k.swapaxes(0,1) # 将第一个轴和第二个轴交换 m[y][x][z] = k[x][y][z]
    print m # [[[0 1],[4 5]],[[2 3],[6 7]]]
    print m[0][1][0]
    # 使用轴交换进行数组矩阵转置
    m = numpy.arange(9).reshape((3,3))
    print m # [[0 1 2] [3 4 5] [6 7 8]]
    print m.swapaxes(1,0) # [[0 3 6] [1 4 7] [2 5 8]]
    

    8. ndarray通用函数

    通用函数(ufunc)是一种对ndarray中的数据执行元素级运算的函数。一元ufunc:


    print '一元ufunc示例'
    x = numpy.arange(6)
    print x # [0 1 2 3 4 5]
    print numpy.square(x) # [ 0  1  4  9 16 25]
    x = numpy.array([1.5,1.6,1.7,1.8])
    y,z = numpy.modf(x)
    print y # [ 0.5  0.6  0.7  0.8]
    print z # [ 1.  1.  1.  1.]
    

    二元ufunc

    print '二元ufunc示例'
    x = numpy.array([[1,4],[6,7]])
    y = numpy.array([[2,3],[5,8]])
    print numpy.maximum(x,y) # [[2,4],[6,8]]
    print numpy.minimum(x,y) # [[1,3],[5,7]]
    

    9. NumPywhere函数使用

    np.where(condition, x, y),第一个参数为一个布尔数组,第二个参数和第三个参数可以是标量也可以是数组。代码示例:

    print 'where函数的使用'
    cond = numpy.array([True,False,True,False])
    x = numpy.where(cond,-2,2)
    print x # [-2  2 -2  2]
    cond = numpy.array([1,2,3,4])
    x = numpy.where(cond>2,-2,2)
    print x # [ 2  2 -2 -2]
    y1 = numpy.array([-1,-2,-3,-4])
    y2 = numpy.array([1,2,3,4])
    x = numpy.where(cond>2,y1,y2) # 长度须匹配
    print x # [1,2,-3,-4]
    
    print 'where函数的嵌套使用'
    y1 = numpy.array([-1,-2,-3,-4,-5,-6])
    y2 = numpy.array([1,2,3,4,5,6])
    y3 = numpy.zeros(6)
    cond = numpy.array([1,2,3,4,5,6])
    x = numpy.where(cond>5,y3,numpy.where(cond>2,y1,y2))
    print x # [ 1.  2. -3. -4. -5.  0.]
    

    10. ndarray常用的统计方法

    可以通过这些基本统计方法对整个数组/某个轴的数据进行统计计算。

    print 'numpy的基本统计方法'
    x = numpy.array([[1,2],[3,3],[1,2]]) #同一维度上的数组长度须一致
    print x.mean() # 2
    print x.mean(axis=1) # 对每一行的元素求平均
    print x.mean(axis=0) # 对每一列的元素求平均
    print x.sum() #同理 12
    print x.sum(axis=1) # [3 6 3]
    print x.max() # 3
    print x.max(axis=1) # [2 3 2]
    print x.cumsum() # [ 1  3  6  9 10 12]
    print x.cumprod() # [ 1  2  6 18 18 36]
    

    用于布尔数组的统计方法:

    ·      sum : 统计数组/数组某一维度中的True的个数

    ·      any: 统计数组/数组某一维度中是否存在一个/多个True

    ·      all:统计数组/数组某一维度中是否都是True

    排序: sort

    代码示例:

    print '用于布尔数组的统计方法'
    x = numpy.array([[True,False],[True,False]])
    print x.sum() # 2
    print x.sum(axis=1) # [1,1]
    print x.any(axis=0) # [True,False]
    print x.all(axis=1) # [False,False]
    print '.sort的就地排序'
    x = numpy.array([[1,6,2],[6,1,3],[1,5,2]])
    x.sort(axis=1) 
    print x # [[1 2 6] [1 3 6] [1 2 5]]
    #非就地排序:numpy.sort()可产生数组的副本
    

    11. ndarray数组的去重以及集合运算

    代码示例:(方法返回类型为一维数组(1d))

    print 'ndarray的唯一化和集合运算'
    x = numpy.array([[1,6,2],[6,1,3],[1,5,2]])
    print numpy.unique(x) # [1,2,3,5,6]
    y = numpy.array([1,6,5])
    print numpy.in1d(x,y) # [ True  True False  True  True False  True  True False]
    print numpy.setdiff1d(x,y) # [2 3]
    print numpy.intersect1d(x,y) # [1 5 6]
    

    12. numpy中的线性代数

    import numpy.linalg 模块。线性代数(linearalgebra)常用的numpy.linalg模块函数:

    print '线性代数'
    import numpy.linalg as nla
    print '矩阵点乘'
    x = numpy.array([[1,2],[3,4]])
    y = numpy.array([[1,3],[2,4]])
    print x.dot(y) # [[ 5 11][11 25]]
    print numpy.dot(x,y) # # [[ 5 11][11 25]]
    print '矩阵求逆'
    x = numpy.array([[1,1],[1,2]])
    y = nla.inv(x) # 矩阵求逆(若矩阵的逆存在)
    print x.dot(y) # 单位矩阵 [[ 1.  0.][ 0.  1.]]
    print nla.det(x) # 求行列式
    

    13. numpy中的随机数生成

    import numpy.random模块

    print 'numpy.random随机数生成'
    import numpy.random as npr
    
    x = npr.randint(0,2,size=100000) #抛硬币
    print (x>0).sum() # 正面的结果
    print npr.normal(size=(2,2)) #正态分布随机数数组 shape = (2,2)
    

    14. ndarray数组重塑

    代码示例:

    print 'ndarray数组重塑'
    x = numpy.arange(0,6) #[0 1 2 3 4]
    print x #[0 1 2 3 4]
    print x.reshape((2,3)) # [[0 1 2][3 4 5]]
    print x #[0 1 2 3 4]
    print x.reshape((2,3)).reshape((3,2)) # [[0 1][2 3][4 5]]
    y = numpy.array([[1,1,1],[1,1,1]])
    x = x.reshape(y.shape)
    print x # [[0 1 2][3 4 5]]
    print x.flatten() # [0 1 2 3 4 5]
    x.flatten()[0] = -1 # flatten返回的是拷贝
    print x # [[0 1 2][3 4 5]]
    print x.ravel() # [0 1 2 3 4 5]
    x.ravel()[0] = -1 # ravel返回的是视图(引用) 
    print x # [[-1 1 2][3 4 5]]
    print "维度大小自动推导"
    arr = numpy.arange(15)
    print arr.reshape((5, -1)) # 15 / 5 = 3
    

    15. ndarray数组的拆分与合并

    print '数组的合并与拆分'
    x = numpy.array([[1, 2, 3], [4, 5, 6]])
    y = numpy.array([[7, 8, 9], [10, 11, 12]])
    print numpy.concatenate([x, y], axis = 0)  
    # 竖直组合 [[ 1  2  3][ 4  5  6][ 7  8  9][10 11 12]]
    print numpy.concatenate([x, y], axis = 1)  
    # 水平组合 [[ 1  2  3  7  8  9][ 4  5  6 10 11 12]]
    print '垂直stack与水平stack'
    print numpy.vstack((x, y)) # 垂直堆叠:相对于垂直组合
    print numpy.hstack((x, y)) # 水平堆叠:相对于水平组合
    # dstack:按深度堆叠
    print numpy.split(x,2,axis=0) 
    # 按行分割 [array([[1, 2, 3]]), array([[4, 5, 6]])]
    print numpy.split(x,3,axis=1) 
    # 按列分割 [array([[1],[4]]), array([[2],[5]]), array([[3],[6]])]
    
    # 堆叠辅助类
    import numpy as np
    arr = np.arange(6)
    arr1 = arr.reshape((3, 2))
    arr2 = np.random.randn(3, 2)
    print 'r_用于按行堆叠'
    print np.r_[arr1, arr2]
    '''
    [[ 0.          1.        ]
     [ 2.          3.        ]
     [ 4.          5.        ]
     [ 0.22621904  0.39719794]
     [-1.2201912  -0.23623549]
     [-0.83229114 -0.72678578]]
    '''
    print 'c_用于按列堆叠'
    print np.c_[np.r_[arr1, arr2], arr]
    '''
    [[ 0.          1.          0.        ]
     [ 2.          3.          1.        ]
     [ 4.          5.          2.        ]
     [ 0.22621904  0.39719794  3.        ]
     [-1.2201912  -0.23623549  4.        ]
     [-0.83229114 -0.72678578  5.        ]]
    '''
    print '切片直接转为数组'
    print np.c_[1:6, -10:-5]
    '''
    [[  1 -10]
     [  2  -9]
     [  3  -8]
     [  4  -7]
     [  5  -6]]
    '''
    
    

    16. 数组的元素重复操作

    代码示例:

    print '数组的元素重复操作'
    x = numpy.array([[1,2],[3,4]])
    print x.repeat(2) # 按元素重复 [1 1 2 2 3 3 4 4]
    print x.repeat(2,axis=0) # 按行重复 [[1 2][1 2][3 4][3 4]]
    print x.repeat(2,axis=1) # 按列重复 [[1 1 2 2][3 3 4 4]]
    x = numpy.array([1,2])
    print numpy.tile(x,2) # tile瓦片:[1 2 1 2]
    print numpy.tile(x, (2, 2))  # 指定从低维到高维依次复制的次数。 
    # [[1 2 1 2][1 2 1 2]]
    




    展开全文
  • NumPy总结与思维导图

    2022-01-04 22:26:42
    NumPy的主要对象是同构多维数组。它是一个元素表(通常是数字),所有类型都相同,由非负整数元组索引。在NumPy维度中称为轴。 基础知识 数组创建 基本操作 索引、切片和迭代 形状操纵 拷贝和视图 功能和方法...

    简介

    NumPy的主要对象是同构多维数组。它是一个元素表(通常是数字),所有类型都相同,由非负整数元组索引。在NumPy维度中称为轴。
    以下都是根据利用python进行数据分析一书做的总结

    基础知识

    在这里插入图片描述

    数组创建

    在这里插入图片描述

    基本操作

    在这里插入图片描述

    索引、切片和迭代

    在这里插入图片描述

    形状操纵

    在这里插入图片描述

    拷贝和视图

    在这里插入图片描述

    功能和方法概述

    在这里插入图片描述

    广播(Broadcasting)规则

    详细教程请参考
    NumPy中的广播(broadcasting)机制
    在这里插入图片描述

    花式索引和索引技巧

    在这里插入图片描述

    利用数组进行数据处理

    在这里插入图片描述

    用于数组的文件输入输出

    在这里插入图片描述

    线性代数

    在这里插入图片描述

    更多详细教程
    NumPy基础
    NumPy中文网
    NumPy documentation

    展开全文
  • datawhale中的numpy总结

    2020-12-16 23:21:33
    datawhale开源项目中的numpy总结,帮助大家更好的记忆numpy函数,也可以打印出来贴在床头背诵(误)
  • numpy总结与思维导图

    千次阅读 多人点赞 2018-12-23 21:17:31
    numpy语法总结 numpy基础思维导图 部分解释 高阶部分 熟悉使用技巧 数据处理 统计分析 总结 引言 本文基于《基于python进行数据分析》与 实验楼 中的numpy实验,针对其中的一些基础知识与问题,结合自己的一些...

    引言

    本文基于《基于python进行数据分析》与实验楼 中的numpy实验,针对其中的一些基础知识与问题,结合自己的一些经验,进行了汇总,在这里写下一个总结。

    什么是numpy?

    NumPy是高性能科学计算和数据分析的基础包。部分功能如下:

    • ndarray, 具有矢量算术运算和复杂广播能力的快速且节省空间的多维数组。
    • 用于对整组数据进行快速运算的标准数学函数(无需编写循环)。
    • 用于读写磁盘数据的工具以及用于操作内存映射文件的工具。
    • 线性代数、随机数生成以及傅里叶变换功能。
    • 用于集成C、C++、Fortran等语言编写的代码的工具。

    numpy优势

    我们可以看下面的图:
    在这里插入图片描述
    这张图来自百度百科,我们可以发现的是array类型数据存储方式是连续的,并且直接指代,而列表的线反而显得杂乱无章,还需要通过寻址来存储,这就导致了numpy在计算的时候虽然类型单一,但没有太多循环的限制,还有可执行向量化操作与解决了GIL全局解释器锁,都给它的速度带来了质的飞越。

    另外我记得在看哪本书中提到过,python列表实际上是数组,具体来说,它们是具有指数过度分配的动态数组,可分离的顺序表。python创始人龟叔在编写cpython解释器的过分分配非常保守,只给了1.125倍的速率,这在大部分语言里,是比较低的。
    (书不记得哪本了,翻找了很多的资料,在quora上找到一个讨论帖,可以一看 How-are-Python-lists-implemented-internally)

    关于numpy的缺点,可以看这篇博文:
    numpy 矩阵运算的陷阱

    ndarray的类型

    类型类型代码说明
    int8、uint8i1、u1有符号和无符号8位整型(1字节)
    int16、uint16i2、u2有符号和无符号16位整型(2字节)
    int32、uint32i4、u4有符号和无符号32位整型(4字节)
    int64、uint64i8、u8有符号和无符号64位整型(8字节)
    float16f2半精度浮点数
    float32f4、f单精度浮点数
    float64f8、d双精度浮点数
    float128f16、g扩展精度浮点数
    complex64c8分别用两个32位表示的复数
    complex128c16分别用两个64位表示的复数
    complex256c32分别用两个128位表示的复数
    bool?布尔型
    objectOpython对象
    stringSn固定长度字符串,每个字符1字节,如S10
    unicodeUn固定长度Unicode,字节数由系统决定,如U10

    是不是有点晕?我做完表也有点。其实不需要考虑这么多,只要知道它支持很多种格式,有整形、浮点型、复数这三个就差不多了。其它的用得少。


    numpy语法总结


    numpy基础思维导图

    在这里插入图片描述
    图中大部分是我对一些基础性的东西进行的总结,大部分是印象流,大概过一遍就差不太多了。下面我就挑一些出来分析:

    部分解释

    1. 正态分布:
    什么是正态分布?大体来讲就是如下公式:
    f ( x ) = 1 2 π σ e − ( x − μ ) 2 2 σ 2 f(x) = \frac{1}{\sqrt{2\pi }\sigma }e^{-\frac{(x-\mu )^{2}}{2\sigma ^{2}}} f(x)=2π σ1e2σ2(xμ)2

    具体的我们可以看如下链接:
    The Standard Normal Distribution

    然后当我们懂了什么是正态分布,下面就可以自己来模拟一个图了:

    import matplotlib.pyplot as plt
    import numpy as np
    
    # 生成均匀分布的随机数
    x2 = np.random.normal(1.75, 1, 100000000)
    # 创建画布
    plt.figure(figsize=(20, 10), dpi=100)
    # 绘制直方图
    plt.hist(x2, 1000)
    # 显示图像
    plt.show()
    

    图形如下:
    在这里插入图片描述

    2. 垂直拼合数组与水平合并

    # 生成示例数组
    a = np.random.randint(10, size=(3, 3))
    b = np.random.randint(10, size=(3, 3))
    a, b
    """
    (array([[7, 0, 8],
            [9, 4, 7],
            [3, 3, 8]]), array([[8, 5, 6],
            [6, 0, 1],
            [6, 9, 4]]))
    """
    
    np.vstack((a, b))	# 垂直合并
    """
    array([[7, 0, 8],
           [9, 4, 7],
           [3, 3, 8],
           [8, 5, 6],
           [6, 0, 1],
           [6, 9, 4]])
    """
    
    np.hstack((a, b))	# 水平合并
    """
    array([[7, 0, 8, 8, 5, 6],
           [9, 4, 7, 6, 0, 1],
           [3, 3, 8, 6, 9, 4]])
    """
    

    3. 返回每列最大每行最小

    print(a)
    np.min(a, axis=1)	# 返回每行最小值
    """
    [[7 0 8]
     [9 4 7]
     [3 3 8]]
    Out[30]:
    array([0, 4, 3])
    """
    
    np.max(a, axis=0)	# 返回每列最大值
    """
    array([9, 4, 8])
    """
    np.max(a,axis=1)	# 返回每行最小值
    

    4. 矩阵求逆:

    A = np.array([[1, 2],
                  [3, 4]])
    np.linalg.inv(A)
    """
    array([[-2. ,  1. ],
           [ 1.5, -0.5]])
    """
    

    5. 均匀分布:
    均匀分布就不用说了,可以见下图:

    # 生成均匀分布的随机数
    x1 = np.random.uniform(-1, 1, 100000000)
    # 1)创建画布
    plt.figure(figsize=(10, 10), dpi=100)
    # 2)绘制直方图
    plt.hist(x1, 5000)
    # 3)显示图像
    plt.show()
    

    在这里插入图片描述

    高阶部分

    熟悉使用技巧

    1. 创建一个 0-10 的一维数组,并将 (1, 9] 之间的数全部反转成负数:

    Z = np.arange(11)
    Z[(1 < Z) & (Z <= 9)] *= -1
    Z
    """
    array([ 0,  1, -2, -3, -4, -5, -6, -7, -8, -9, 10])
    """
    

    2. 找出两个一维数组中相同的元素:

    Z1 = np.random.randint(0,10,10)
    Z2 = np.random.randint(0,10,10)
    print("Z1:", Z1)
    print("Z2:", Z2)
    np.intersect1d(Z1,Z2)	# 返回Z1和Z2中的交集
    """
    Z1: [6 3 7 9 2 0 1 1 3 3]
    Z2: [0 4 8 1 5 8 5 0 6 5]
    array([0, 1, 6])
    """
    

    3. 创建一个长度为10的随机一维数组,并将其按升序排序:

    Z = np.random.random(10)
    Z.sort()
    Z
    """
    array([0.06298303, 0.12848206, 0.26675583, 0.36847405, 0.6276631 ,
           0.73499294, 0.73732823, 0.83748245, 0.85359826, 0.91563148])
    """
    

    4. 使用 NumPy 打印昨天、今天、明天的日期:

    yesterday = np.datetime64('today', 'D') - np.timedelta64(1, 'D')
    today     = np.datetime64('today', 'D')
    tomorrow  = np.datetime64('today', 'D') + np.timedelta64(1, 'D')
    print("yesterday: ", yesterday)
    print("today: ", today)
    print("tomorrow: ", tomorrow)
    
    """
    yesterday:  2018-12-21
    today:  2018-12-22
    tomorrow:  2018-12-23
    """
    

    5. 使用五种不同的方法去提取一个随机数组的整数部分:

    Z = np.random.uniform(0,10,10)		# 均匀分布的随机数
    print("原始值: ", Z)
    print ("方法 1: ", Z - Z%1)			# 减去余数
    print ("方法 2: ", np.floor(Z))		# 逐元素的返回输入的下限
    print ("方法 3: ", np.ceil(Z)-1)		# 计算大于等于改值的最小整数
    print ("方法 4: ", Z.astype(int))	# Z.astype
    print ("方法 5: ", np.trunc(Z))		# 按元素方式返回输入的截断值
    """
    原始值:  [1.53413298 2.71912419 9.74111772 3.67325886 7.62381231 3.74703012
     8.33338283 0.4819538  5.48684884 1.8034668 ]
    方法 1:  [1. 2. 9. 3. 7. 3. 8. 0. 5. 1.]
    方法 2:  [1. 2. 9. 3. 7. 3. 8. 0. 5. 1.]
    方法 3:  [1. 2. 9. 3. 7. 3. 8. 0. 5. 1.]
    方法 4:  [1 2 9 3 7 3 8 0 5 1]
    方法 5:  [1. 2. 9. 3. 7. 3. 8. 0. 5. 1.]
    """
    

    6. 打印每个 NumPy 标量类型的最小值和最大值:

    for dtype in [np.int8, np.int32, np.int64]:
       print("The minimum value of {}: ".format(dtype), np.iinfo(dtype).min)
       print("The maximum value of {}: ".format(dtype),np.iinfo(dtype).max)
    for dtype in [np.float32, np.float64]:
       print("The minimum value of {}: ".format(dtype),np.finfo(dtype).min)
       print("The maximum value of {}: ".format(dtype),np.finfo(dtype).max)
    
    """
    The minimum value of <class 'numpy.int8'>:  -128
    The maximum value of <class 'numpy.int8'>:  127
    The minimum value of <class 'numpy.int32'>:  -2147483648
    The maximum value of <class 'numpy.int32'>:  2147483647
    The minimum value of <class 'numpy.int64'>:  -9223372036854775808
    The maximum value of <class 'numpy.int64'>:  9223372036854775807
    The minimum value of <class 'numpy.float32'>:  -3.4028235e+38
    The maximum value of <class 'numpy.float32'>:  3.4028235e+38
    The minimum value of <class 'numpy.float64'>:  -1.7976931348623157e+308
    The maximum value of <class 'numpy.float64'>:  1.7976931348623157e+308
    """
    

    7. 将多个 1 维数组拼合为单个 Ndarray:

    Z1 = np.arange(3)
    Z2 = np.arange(3,7)
    Z3 = np.arange(7,10)
    
    Z = np.array([Z1, Z2, Z3])
    print(Z)
    
    np.concatenate(Z)	# 拼接数组,等价于np.hstack
    """
    [array([0, 1, 2]) array([3, 4, 5, 6]) array([7, 8, 9])]
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    """
    

    8. 统计随机数组中各元素的数量:

    Z = np.random.randint(0,100,25).reshape(5,5)
    print(Z)
    
    np.unique(Z, return_counts=True) # 返回值中,第 2 个数组对应第 1 个数组元素的数量
    """
    [[82 85 81 61 38]
     [57 38 59 49 42]
     [78 12 20 62 40]
     [61 83  0 77 77]
     [ 0  0 33 98 35]]
    (array([ 0, 12, 20, 33, 35, 38, 40, 42, 49, 57, 59, 61, 62, 77, 78, 81, 82,
            83, 85, 98]),
     array([3, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1],
           dtype=int64))
    """
    

    9. 求解给出矩阵的逆矩阵并验证:

    matrix = np.array([[1., 2.], [3., 4.]])
    inverse_matrix = np.linalg.inv(matrix)
    # 验证原矩阵和逆矩阵的点积是否为单位矩阵
    assert np.allclose(np.dot(matrix, inverse_matrix), np.eye(2))
    inverse_matrix
    """
    array([[-2. ,  1. ],
           [ 1.5, -0.5]])
    """
    

    10. 使用numpy打印九九乘法表:

    np.fromfunction(lambda i, j: (i + 1) * (j + 1), (9, 9))
    """
    array([[ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.],
           [ 2.,  4.,  6.,  8., 10., 12., 14., 16., 18.],
           [ 3.,  6.,  9., 12., 15., 18., 21., 24., 27.],
           [ 4.,  8., 12., 16., 20., 24., 28., 32., 36.],
           [ 5., 10., 15., 20., 25., 30., 35., 40., 45.],
           [ 6., 12., 18., 24., 30., 36., 42., 48., 54.],
           [ 7., 14., 21., 28., 35., 42., 49., 56., 63.],
           [ 8., 16., 24., 32., 40., 48., 56., 64., 72.],
           [ 9., 18., 27., 36., 45., 54., 63., 72., 81.]])
    """
    

    数据处理

    1. 从随机一维数组中找出距离给定数值(0.5)最近的数:

    Z = np.random.uniform(0,1,20)
    print("随机数组: \n", Z)
    z = 0.5
    m = Z.flat[np.abs(Z - z).argmin()]
    m
    随机数组: 
     [0.39218162 0.64186848 0.632319   0.18066358 0.2528439  0.54158502
     0.28428427 0.79862388 0.92999625 0.01324922 0.13933463 0.27016034
     0.86881073 0.77176662 0.26133043 0.41437033 0.39728876 0.00655049
     0.59573444 0.74698036]
    0.5415850245865528
    

    2. 使用 Z-Score 标准化算法对数据进行标准化处理:

    Z = X − m e a n ( X ) s d ( X ) Z = \frac{X-\mathrm{mean}(X)}{\mathrm{sd}(X)} Z=sd(X)Xmean(X)

    # 根据公式定义函数
    def zscore(x, axis = None):
        xmean = x.mean(axis=axis, keepdims=True)
        xstd  = np.std(x, axis=axis, keepdims=True)
        zscore = (x-xmean)/xstd
        return zscore
    
    # 生成随机数据
    Z = np.random.randint(10, size=(5,5))
    print(Z)
    zscore(Z)
    """
    [[9 3 3 1 6]
     [6 4 7 8 4]
     [6 1 9 2 7]
     [8 5 8 6 1]
     [5 1 1 5 4]]
    array([[ 1.61062648, -0.69026849, -0.69026849, -1.45723348,  0.46017899],
           [ 0.46017899, -0.306786  ,  0.84366149,  1.22714398, -0.306786  ],
           [ 0.46017899, -1.45723348,  1.61062648, -1.07375098,  0.84366149],
           [ 1.22714398,  0.0766965 ,  1.22714398,  0.46017899, -1.45723348],
           [ 0.0766965 , -1.45723348, -1.45723348,  0.0766965 , -0.306786  ]])
    """
    

    3. 使用 Min-Max 标准化算法对数据进行标准化处理:

    Y = Z − min ⁡ ( Z ) max ⁡ ( Z ) − min ⁡ ( Z ) Y = \frac{Z-\min(Z)}{\max(Z)-\min(Z)} Y=max(Z)min(Z)Zmin(Z)

    # 根据公式定义函数
    def min_max(x, axis=None):
        min = x.min(axis=axis, keepdims=True)
        max = x.max(axis=axis, keepdims=True)
        result = (x-min)/(max-min)
        return result
    
    # 生成随机数据
    Z = np.random.randint(10, size=(5,5))
    print(Z)
    min_max(Z)
    """
    [[5 2 6 1 9]
     [0 6 1 2 6]
     [7 9 9 6 8]
     [6 3 4 7 5]
     [3 2 3 7 8]]
    array([[0.55555556, 0.22222222, 0.66666667, 0.11111111, 1.        ],
           [0.        , 0.66666667, 0.11111111, 0.22222222, 0.66666667],
           [0.77777778, 1.        , 1.        , 0.66666667, 0.88888889],
           [0.66666667, 0.33333333, 0.44444444, 0.77777778, 0.55555556],
           [0.33333333, 0.22222222, 0.33333333, 0.77777778, 0.88888889]])
    """
    

    4. 使用 L2 范数对数据进行标准化处理:

    L 2 = x 1 2 + x 2 2 + … + x i 2 L_2 = \sqrt{x_1^2 + x_2^2 + \ldots + x_i^2} L2=x12+x22++xi2

    # 根据公式定义函数
    def l2_normalize(v, axis=-1, order=2):
        l2 = np.linalg.norm(v, ord = order, axis=axis, keepdims=True)
        l2[l2==0] = 1
        return v/l2
    
    # 生成随机数据
    Z = np.random.randint(10, size=(5,5))
    print(Z)
    l2_normalize(Z)
    """
    [[3 1 8 2 7]
     [1 3 2 2 1]
     [4 3 0 8 4]
     [2 8 0 3 5]
     [1 0 1 0 9]]
    array([[0.26620695, 0.08873565, 0.70988521, 0.1774713 , 0.62114956],
           [0.22941573, 0.6882472 , 0.45883147, 0.45883147, 0.22941573],
           [0.39036003, 0.29277002, 0.        , 0.78072006, 0.39036003],
           [0.19802951, 0.79211803, 0.        , 0.29704426, 0.49507377],
           [0.10976426, 0.        , 0.10976426, 0.        , 0.98787834]])
    """
    

    统计分析

    1. 使用numpy计算变量的相关系数:

    Z = np.array([
        [1, 2, 1, 9, 10, 3, 2, 6, 7], # 特征 A
        [2, 1, 8, 3, 7, 5, 10, 7, 2], # 特征 B
        [2, 1, 1, 8, 9, 4, 3, 5, 7]]) # 特征 C
    
    np.corrcoef(Z)
    """
    array([[ 1.        , -0.05640533,  0.97094584],
           [-0.05640533,  1.        , -0.01315587],
           [ 0.97094584, -0.01315587,  1.        ]])
    """
    

    2. 使用numpy计算矩阵的特征值和特征向量:

    M = np.matrix([[1,2,3], [4,5,6], [7,8,9]])
    
    w, v = np.linalg.eig(M)
    # w 对应特征值,v 对应特征向量
    w, v
    """
    (array([ 1.61168440e+01, -1.11684397e+00, -9.75918483e-16]),
     matrix([[-0.23197069, -0.78583024,  0.40824829],
             [-0.52532209, -0.08675134, -0.81649658],
             [-0.8186735 ,  0.61232756,  0.40824829]]))
    """
    

    3. 计算两个数组间的欧式距离:
    x , y = ∑ 1 n ( x i − y i ) 2 x,y=\sqrt{ \sum_{1}^{n}(x_{i}-y_{i})^2 } x,y=1n(xiyi)2

    a = np.array([1, 2])
    b = np.array([7, 8])
    # 数学计算方法
    print(np.sqrt(np.power((8-2), 2) + np.power((7-1), 2)))
    
    # NumPy 计算
    np.linalg.norm(b-a)
    """
    8.48528137423857
    8.48528137423857
    """
    

    总结

    在《python进行数据分析》中开章的一句话:“numpy本身并没有提供多么高级的数据分析功能,理解numpy数组以及面向数组的计算将有助于你更加高效地使用诸如pandas之类的工具。”当我大概在numpy一百题中总结完以上的一些语法时,依然还是感觉到有些乱和零散,没有pandas那么的明确,而从功能分析上,相对于pandas表现一般,但它却是数据分析中奠定基础最重要的模块,希望在日后的学习过程中,我能对numpy有更深刻的认识,到时候应该会再开一贴来进行总结。另外在写这篇博文中,找到一些比较不错的资源先mark一下。



    1. numpy中文手册
    2. numpy文档
    3. 《利用python进行数据分析》
    4. 《Python数据分析基础教程:NumPy学习指南(第2版)》
    展开全文
  • Numpy总结

    2022-03-06 14:20:52
    1.Numpy是什么? numpy是Python的一个科学计算库,提供矩阵运算的功能。 1.1Numpy的导入 import numpy as np #一般都是用numpy的别名来进行操作 1.2numpy数组的创建 最简单的创建ndarray对象的方式是使用array...
  • Python数据分析--numpy总结

    千次阅读 2021-03-05 19:43:34
    Python数据分析–numpy总结 NumPy常用方法总结 文章目录Python数据分析--numpy总结生成ndarray的几种方式从已有数据中创建利用random模块生成ndarray创建特定形状的多维数组利用arange函数存取元素矩阵操作数据...
  • 目录Numpy1. ndarray2. 数据类型2.1 标量数据类型2.2 dtype2.3 唯一定义字符代码3. 数组属性3.1 ndarray.shape3.2 ndarray.reshape3.3 ndarray.ndim3.4 ndarray.itemsize3.5 ndarray.flags4. 数组创建4.1 numpy....
  • numpy知识总结

    2022-03-06 11:31:38
    numpy第二章知识总结
  • 机器学习-数据科学库:numpy总结numpy总结什么是numpynumpy创建数组(矩阵)numpy中常见的更多数据类型数据类型的操作数组的形状数组和数的计算广播原则NumPy 矩阵乘法元素级乘法矩阵乘积NumPy 的 dot 函数轴(axis)二...
  • numpy可以说是Python运用于人工智能和科学计算的一个重要基础,近段时间恰好学习了numpy,pandas,sklearn等一些Python机器学习和科学计算库,因此在此总结一下常用的用法。引入numpy库的方式:import numpy as np1...
  • NumPy总结(二):基本的NumPy数组操作 注:转载请注明出处 文章目录NumPy总结(二):基本的NumPy数组操作1 NumPy数组的属性2 数组索引:获取单个元素3 数组切片(slice):获取子数组4 数组的变形5 数组的拼接和分裂...
  • Python之Numpy总结

    2021-12-19 23:03:59
    Python之Numpy总结,比较精简,学完后的内容做了一个思维导图
  • import numpy as np import torch a= np.array([1 ,2 ,3 ,4]) #array转tensor b=torch.from_numpy(a) print(b) #tensor转array c=b.numpy() print(c)
  • NumPy总结(一):创建一个NumPy数组

    千次阅读 2020-08-21 12:49:36
    本节为NumPy的第一部分,主要讲解NumPy的主要功能及基本特性,最重要的是如何创建一个简单的NumPy数组。
  • numpy可以说是Python运用于人工智能和科学计算的一个重要基础,近段时间恰好学习了numpy,pandas,sklearn等一些Python机器学习和科学计算库,因此在此总结一下常用的用法。引入numpy库的方式:import numpy as np1...
  • 转载
  • numpy常用方法 一、numpy简介:numpy是Python数值计算中最为重要的基础包,能对矩阵中的所有数据进行快速的矩阵运算,且无需编写循环,因此可以在很大程度上减少计算时间成本。另外,因为numpy的算法库是用C语言写...
  • Numpy 学习总结

    2022-01-21 14:54:21
    import numpy as np 1、特殊数组 array_zeros = np.zeros((3, 3)) array_ones = np.ones((4, 4)) array_full = np.full((2, 3), 9) array_eye = np.eye(4) zero全零矩阵, ones全1矩阵, full(元组,数字)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 78,955
精华内容 31,582
关键字:

numpy总结