Numpy 基本使用

小鱼儿 2024-04-19 15:37 73阅读 0赞

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)
2.  ##### 数组的创建 #####
    
        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))
3.  ##### 数组行列操作 #####
    
        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])
4.  ##### 数组属性 #####
    
        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)
5.  ##### 数组数学 #####
    
        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)))
6.  ##### 广播 #####
    
        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)
7.  ##### 等差等比数列 #####
    
        # 等比数列
        # 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))
8.  ##### 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)
9.  ##### 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)
    2.  **元素统计函数**
        
            # 多维数组默认统计全部维度，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))
    3.  **元素判断函数**
        
            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))
    4.  **元素去重排序函数**
        
            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文档][Python Numpy 1]

[Python Numpy中文文档][Python Numpy 2]

[Python Numpy]: http://cs231n.github.io/python-numpy-tutorial/#python-basic
[Python Numpy 1]: https://docs.scipy.org/doc/numpy/reference/
[Python Numpy 2]: https://www.numpy.org.cn/article/basics/index.html