Numpy 基本使用

阿里云2000元红包!本站用户参与享受九折优惠!

  1. 随机数
    # 随机产生一个长度为 7 数值在 1 到 10 (不包含10)之间的数组
    random_array = np.random.randint(0, 10, size = 7)
    print(random_array)
    # 随机产生一个3行5列数值在 1 到 10 (不包含10)之间的二维数组
    # size 指的是 3 行 5 列
    randint_array = np.random.randint(1, 10, size = (3, 5))
    print(random_array)
    # 半开区间内的随机浮点数[0.0,1.0) 均匀分布
    random = np.random.rand(3, 4)
    print(random)
    # 产生[-1,5)中均匀分布的样本值
    random_uniform = np.random.uniform(-1, 5, size=(3, 4))
    print(random_uniform)
    # standard normal 标准正态分布
    standard_normal = np.random.randn(4, 4)
    print(standard_normal)
    # 卡方分布
    chisquare = np.random.chisquare(2, size=(4, 4))
    print(chisquare)
    # 二项分布
    # 10 试验次数,0.4 每次试验的概率
    binomial = np.random.binomial(10, 0.4, size=(4, 4))
    print(binomial)
    # 高斯分布
    #参数顺序:1.均值 2.标准差 3.生成多少样本
    gaussian_normal = np.random.normal(0, 0.1, 10)
    print(gaussian_normal)
    
  1. 数组的创建
    list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    array = np.array(list, dtype=np.int64)
    # 创建一个一维 ndarray 数组
    array = np.arange(15)
    # 打乱数组序列
    np.random.shuffle(array)
    # 3 x 5 个元素的 二维数组
    array = array.reshape(3, 5)
    # 1 x 3 x 5 个元素的 三维数组
    array = array.reshape(1, 3, 5)
    # 数值大小的全为 0 的数组
    array = np.zeros((3,5),dtype=np.int32)
    # 数值大小的全为 1 的数组
    array = np.ones((2,3))
    # 数值大小的全为 7 的数组
    array = np.full((2,2), 7)
    # 单位矩阵
    array = np.eye(3, 3)
    # 初始化数组,不是总是返回全 0,有时返回的是未初始的随机值(内存里的随机值)
    array = np.empty((3, 3),dtype=np.int32)
    # 半开放区间 [0,1) 内的随机浮点数
    array = np.random.random((3,4))
    
  1. 数组行列操作
    a= np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
    # 2
    print(a[0, 1])
    # 行操作
    row_r1 = a[1, :]
    # [5 6 7 8] (4,)
    print(row_r1, row_r1.shape)
    row_r2 = a[1:2, :]
    # [[5 6 7 8]] (1, 4)
    print(row_r2, row_r2.shape)
    # 列操作
    col_r1 = a[:, 1]
    col_r2 = a[:, 1:2]
    # Prints "[ 2  6 10] (3,)"
    print(col_r1, col_r1.shape)
    # [[ 2]
    #  [ 6]
    #  [10]] (3, 1)
    print(col_r2, col_r2.shape)
    # 反转数组的行
    # [[ 9 10 11 12]
    #  [ 5  6  7  8]
    #  [ 1  2  3  4]]
    print(a[::-1,])
    # 反转数组的行和列
    # [[12 11 10  9]
    #  [ 8  7  6  5]
    #  [ 4  3  2  1]]
    print(a[::-1, ::-1])
    # ========================================================
    # [[2 3]
    #  [6 7]]
    b = a[:2, 1:3]
    print(b)
    b[0, 0] = 77
    # [[77  3]
    #  [ 6  7]]
    print(b)
    # 77
    print(a[0,1])
    # ========================================================
    b = np.array([2, 2, 2])
    # [ 3  7 11]
    print(a[np.arange(3), b])
    a[np.arange(3), b] += 10
    # [[ 1 77 13  4]
    #  [ 5  6 17  8]
    #  [ 9 10 21 12]]
    print(a)
    # ========================================================
    bool_idx = (a > 5)
    # [[False False False False]
    #  [False  True  True  True]
    #  [ True  True  True  True]]
    print(bool_idx)
    # [ 6  7  8  9 10 11 12]
    print(a[bool_idx])
    # [ 6  7  8  9 10 11 12]
    print(a[a > 5])
    
  1. 数组属性
    a= np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
    # <class 'numpy.ndarray'>
    print(type(a))
    # 数据类型 int32
    print('数据类型: ', a.dtype)
    # 维度个数 2
    print('维度个数: ', a.ndim)
    # 维度大小 (3, 4)
    print('维度大小: ', a.shape)
    # 取数组第3行3列元素 11
    print('第3行3列元n: ', a[2,2])
    # 转置矩阵
    # [[1  5  9]
    #  [2  6 10]
    # [3  7 11]
    # [4  8 12]]
    print('转置矩阵: \n', a.T)
    v = np.array([1,2,3])
    # [1 2 3]
    print(v)
    # 注意,对秩为1的数组求转置没有任何作用 
    # [1 2 3]
    print(v.T)
    a[2,2] = 5
    # [[ 1  2  3  4]
    #  [ 5  6  7  8]
    #  [ 9 10  5 12]]
    print(a)
    a = a.astype('str')
    # 转换类型
    # [['1' '2' '3' '4']
    #  ['5' '6' '7' '8']
    #  ['9' '10' '5' '12']]
    print(a)
    
  1. 数组数学
    x = np.array([[1,2],[3,4]], dtype=np.float64)
    y = np.array([[5,6],[7,8]], dtype=np.float64)
    # Elementwise sum; both produce the array
    # [[ 6.0  8.0]
    #  [10.0 12.0]]
    print(x + y)
    print(np.add(x, y))
    # Elementwise difference; both produce the array
    # [[-4.0 -4.0]
    #  [-4.0 -4.0]]
    print(x - y)
    print(np.subtract(x, y))
    # Elementwise product; both produce the array
    # [[ 5.0 12.0]
    #  [21.0 32.0]]
    print(x * y)
    print(np.multiply(x, y))
    # Elementwise division; both produce the array
    # [[ 0.2         0.33333333]
    #  [ 0.42857143  0.5       ]]
    print(x / y)
    print(np.divide(x, y))
    # Elementwise square root; produces the array
    # [[ 1.          1.41421356]
    #  [ 1.73205081  2.        ]]
    print(np.sqrt(x))
    x = np.array([[1,2],[3,4]])
    y = np.array([[5,6],[7,8]])
    v = np.array([9,10])
    w = np.array([11, 12])
    # 向量內积
    # 219
    print(v.dot(w))
    print(np.dot(v, w))
    # 矩阵 / 向量 乘积
    # [29 67]
    print(x.dot(v))
    print(np.dot(x, v))
    # 矩阵 / 矩阵 乘积
    # [[19 22]
    #  [43 50]]
    print(x.dot(y))
    print(np.dot(x, y))
    # 10
    print(np.sum(x))
    # [4 6]
    print(np.sum(x, axis=0))
    # [3 7]
    print(np.sum(x, axis=1))
    X = np.array([[1,2],[3,4]])
    #求解方阵的逆
    print(np.linalg.inv(X))
    mat = X.T.dot(X)
    print(np.linalg.inv(mat))
    mat.dot(np.linalg.inv(mat))
    #计算矩阵的 qr 分解-特征值和特征向量分解
    # qr 分解是求解一般的矩阵全部特征值最有效的方法,
    # 首先经过矩阵的正交相似变换为Hessen矩阵,
    # 再通过QR方法求特征值和特征向量,得到的是一个正规正交矩阵Q(m*m)和一个上三角矩阵R(m*m)
    # 特征值 q: [[-0.58123819 -0.81373347] [-0.81373347  0.58123819]]
    # 特征向量 r: [[-17.20465053 -24.41200414] [  0.  0.23249528]]
    q,r = np.linalg.qr(mat)
    print(q, r)
    #根据矩阵的特征值和特征向量得到原矩阵
    print(q.dot(r))
    # eig 方阵的特征值和特征向量
    value,vector = np.linalg.eig(mat)
    # 计算矩阵的qr分解-特征值和特征向量分解
    # [ 0.13393125 29.86606875] [[-0.81741556 -0.57604844]  [ 0.57604844 -0.81741556]]
    print(value,vector)
    # 利用特征值和特征向量求解原矩阵
    matrix = np.mat([[1,2,3], [4,5,6], [7,8,9]])
    e,v = np.linalg.eig(matrix)
    # 根据特征值和特征向量得到原矩阵
    y = v * np.diag(e) * np.linalg.inv(v)
    print(y)
    # 根据特征值和特征向量得到原矩阵
    y = v.dot(np.dot(np.diag(e), np.linalg.inv(v)))
    print(y)
    print(matrix)
    # svd奇异值分解
    X = np.mat([[1,2,3],[4,5,6],[7,8,9]])
    print(X)
    U,sigma,VT = np.linalg.svd(X)
    # [[-0.40455358 -0.9145143 ]
    #  [-0.9145143   0.40455358]]
    print("U: ", U)
    # [5.4649857  0.36596619]
    print("sigma: ", sigma)
    # [[-0.57604844 -0.81741556]
    #  [ 0.81741556 -0.57604844]]
    print("VT: ", VT)
    # 转换为原来的矩阵,一定记住sigma转化为单位矩阵
    # [[1. 2. 3.]
    #  [4. 5. 6.]
    #  [7. 8. 9.]]
    print(U.dot(np.diag(sigma).dot(VT)))
    print(np.dot(U, np.dot(np.diag(sigma), VT)))
    
  1. 广播
    x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
    v = np.array([1, 0, 1])
    vv = np.tile(v, (4, 1))
    # [[1 0 1]
    #  [1 0 1]
    #  [1 0 1]
    #  [1 0 1]]
    print(vv)
    y = x + vv
    # [[ 2  2  4]
    #  [ 5  5  7]
    #  [ 8  8 10]
    #  [11 11 13]]
    print(y)
    x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
    v = np.array([1, 0, 1])
    y = x + v  # Add v to each row of x using broadcasting
    # [[ 2  2  4]
    #  [ 5  5  7]
    #  [ 8  8 10]
    #  [11 11 13]]
    print(y)
    v = np.array([1,2,3])
    w = np.array([4,5])
    # [[1]
    #  [2]
    #  [3]]
    print(np.reshape(v, (3, 1)))
    # [[ 4  5]
    #  [ 8 10]
    #  [12 15]]
    print(np.reshape(v, (3, 1)) * w)
    x = np.array([[1,2,3], [4,5,6]])
    # x + v ==> x + [[1,2,3],[1,2,3]]
    # [[2 4 6]
    #  [5 7 9]]
    print(x + v)
    # [[ 5  6  7]
    #  [ 9 10 11]]
    print((x.T + w).T)
    print(x + np.reshape(w, (2, 1)))
    # [[ 2  4  6]
    #  [ 8 10 12]]
    print(x * 2)
    
  2. 等差等比数列
    # 等比数列
    # logspace 用于创建一个等比数列构成的一维数组中
    # 第一个参数表示起始点为 10 的幂
    # 第二个参数表示终止点
    # 开始点和结束点是10的幂,0 代表 10 的 0 次方
    # 第三个参数表示数列的个数, 默认 50 个
    # 参数 endpoint 来决定是否包含终止值,默认为 True。
    # 参数 base 来决定底数,默认为 10。
    # [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
    print(np.logspace(0,0,10))
    # [1.e+00 1.e+01 1.e+02 1.e+03 1.e+04 1.e+05 1.e+06 1.e+07 1.e+08 1.e+09]
    print(np.logspace(0,9,10))
    # [ 1.  2.  4.  8. 16.]
    print(np.logspace(0, 4, 5, base=2))
    # 等差数列
    # linspace 用于创建一个等差数列构成的一维数组
    # 第一个参数表示起始点
    # 第二个参数表示终止点
    # 第三个参数表示数列的个数
    # 参数 endpoint来决定是否包含终止值,默认为 True。
    # [ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
    print(np.linspace(1, 10, 10))
    # [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
    print(np.linspace(1, 1, 10))
    # [1.  1.9 2.8 3.7 4.6 5.5 6.4 7.3 8.2 9.1]
    print(np.linspace(1, 10, 10, endpoint=False))
    
  3. matrix 二维矩阵
    x=np.mat("1 2;3 4")
    # [[1 2]
    #  [3 4]]
    print(x)
    x = np.mat([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
    # [[ 1  2  3  4]
    #  [ 5  6  7  8]
    #  [ 9 10 11 12]]
    print(x)
    x = np.random.randint(0, 5, [3, 2, 2])
    # [[[2 4]
    #   [3 1]]
    #
    #  [[4 3]
    #   [0 3]]
    #
    #  [[4 4]
    #   [4 1]]]
    print(x)
    # (3, 2, 2)
    print (x.shape)
    #验证三维矩阵X是不能被mat或matrix矩阵转换的,这点需要注意
    #这个会报错 ValueError: shape too large to be a matrix.
    # y = np.mat(x)
    
  4. Numpy 内置函数
    1. 元素计算函数

      arr = np.random.randn(2,3)
      # [[ 1.07169256  1.0762356  -1.14597845]
      #  [ 0.51060493 -1.1502163  -1.01753376]]
      print(arr)
      # np.ceil(): 向上取最接近的整数,参数是 number 或 array
      # [[ 2.  2. -1.]
      #  [ 1. -1. -1.]]
      print(np.ceil(arr))
      # np.floor(): 向下取最接近的整数,参数是 number 或 array
      # [[ 1.  1. -2.]
      #  [ 0. -2. -2.]]
      print(np.floor(arr))
      # np.rint(): 四舍五入,参数是 number 或 array
      # [[ 1.  1. -1.]
      #  [ 1. -1. -1.]]
      print(np.rint(arr))
      # np.isnan(): 判断元素是否为 NaN(Not a Number),参数是 number 或 array
      # [[False False False]
      #  [False False False]]
      print(np.isnan(arr))
      # np.multiply(): 元素相乘,参数是 number 或 array
      # [[1.14852495 1.15828307 1.31326661]
      #  [0.26071739 1.32299754 1.03537495]]]
      print(np.multiply(arr, arr))
      # np.divide(): 元素相除,参数是 number 或 array
      # [[1. 1. 1.]
      #  [1. 1. 1.]]
      print(np.divide(arr, arr))
      # np.abs():元素的绝对值,参数是 number 或 array
      # [[1.07169256 1.0762356  1.14597845]
      #  [0.51060493 1.1502163  1.01753376]]
      print(np.abs(arr))
      # np.where(condition, x, y): 三元运算符,x if condition else y
      # [[ 1  1 -1]
      #  [-1  1  1]]
      print(np.where(arr > 0, 1, -1)
      
  1. 元素统计函数

    # 多维数组默认统计全部维度,axis参数可以按指定轴心统计,值为 0 则按列统计,值为 1 则按行统计。
    arr = np.arange(1,13).reshape(3,4)
    # [[ 1  2  3  4]
    #  [ 5  6  7  8]
    #  [ 9 10 11 12]]
    print(arr)
    # 返回一个一维数组,每个元素都是之前所有元素的 累加和
    # [ 1  3  6 10 15 21 28 36 45 55 66 78]
    print(np.cumsum(arr))
    # 返回一个一维数组,每个元素都是之前所有元素的累乘积
    # [1  2  6  24  120  720  5040  40320  362880 3628800  39916800  479001600]
    print(np.cumprod(arr))
    # 所有元素的和
    # 78
    print(np.sum(arr))
    # 数组的按列统计和
    # [15 18 21 24]
    print(np.sum(arr, axis=0))
    # 数组的按行统计和
    # [10 26 42]
    print(np.sum(arr, axis=1))
    # 所有元素的平均值
    # 6.5
    print(np.mean(arr))
    # 所有元素的最大值
    # 12
    print(np.max(arr))
    # 所有元素的最小值
    # 1
    print(np.min(arr))
    # 所有元素的标准差
    # 3.452052529534663
    print(np.std(arr))
    # 所有元素的方差
    # 11.916666666666666
    print(np.var(arr))
    # 最大值的下标索引值
    # 11
    print(np.argmax(arr))
    # 最小值的下标索引值
    # 0
    print(np.argmin(arr))
    
  2. 元素判断函数

    arr = np.random.randn(2,3)
    # [[ 0.04623215  0.05486533  0.62061233]
    #  [-0.34335838 -0.5959028  -0.29623683]]
    print(arr)
    # np.any(): 至少有一个元素满足指定条件,返回True
    # True
    print(np.any(arr > 0))
    # np.all(): 所有的元素满足指定条件,返回True
    # False
    print(np.all(arr > 0))
    
  1. 元素去重排序函数

    arr = np.array([[1, 2, 1], [2, 3, 4]])
    # [[1 2 1]
    #  [2 3 4]]
    print(arr)
    # np.unique():找到唯一值并返回排序结果,类似于Python的set集合
    # [1 2 3 4]
    print(np.unique(arr))
    

参考:

Python Numpy教程

Python Numpy文档

Python Numpy中文文档

https://www.jianshu.com/p/fc15ebe56df8

「点点赞赏,手留余香」

    还没有人赞赏,快来当第一个赞赏的人吧!
pandas
0 条回复 A 作者 M 管理员
    所有的伟大,都源于一个勇敢的开始!
欢迎您,新朋友,感谢参与互动!欢迎您 {{author}},您在本站有{{commentsCount}}条评论