Numpy基础20问

讨论 VectorJin
Lv2 初级炼丹师
发布在 NumPy   944   0
讨论 VectorJin   944   0

    1、什么是numpy?

    一言以蔽之,numpy是python中基于数组对象的科学计算库。

    提炼关键字,可以得出numpy以下三大特点:

    • 拥有n维数组对象;
    • 拥有广播功能(后面讲到);
    • 拥有各种科学计算API,任你调用;

    2、如何安装numpy?

    因为numpy是一个python库,所以使用python包管理工具pip或者conda都可以安装。

    安装python后,打开cmd命令行,输入:

    pip install numpy

    即可完成安装。

    3、什么是n维数组对象?

    n维数组(ndarray)对象,是一系列同类数据的集合,可以进行索引、切片、迭代操作。

    numpy中可以使用array函数创建数组:

    import numpy as np
    np.array([1,2,3])
    # 输出:array([1, 2, 3])
    

    4、如何区分一维、二维、多维?

    判断一个数组是几维,主要是看它有几个轴(axis)。

    一个轴表示一维数组,两个轴表示二维数组,以此类推。

    每个轴都代表一个一维数组。

    比如说,二维数组第一个轴里的每个元素都是一个一维数组,也就是第二个轴。

    一维数组一个轴:

    [1,2,3]

    二维数组两个轴:

    [[0, 1, 2],
     [3, 4, 5]]

    三维数组三个轴:

    [[[ 0,  1,  2],
      [ 3,  4,  5]],
    
     [[ 6,  7,  8],
      [ 9, 10, 11]]]

    以此类推n维数组。

    5、如何创建n维数组?

    numpy中常用array函数创建数组,传入列表或元组即可。

    创建一维数组,并指定数组类型为int:

    import numpy as np
    np.array([1,2,3],dtype=int)
    # 输出:array([1, 2, 3])
    

    创建二维数组:

    import numpy as np
    np.array(((1,2),(3,4)))
    
     '''
    输出:
    array([[1, 2],
           [3, 4]])
    '''
    

    还可以使用arange函数创建一维数字数组,用法类似python的range函数.

    import numpy as np
    np.arange(1,6)
    '''
    输出:array([1, 2, 3, 4, 5])
    '''
    

    6、如何创建随机数组?

    numpy的random模块用来创建随机数组。

    • random.rand函数,生成[0,1)均匀分布的随机数组
    import numpy as np
    # 创建2行2列取值范围为[0,1)的数组
    np.random.rand(2,2)
    '''
    输出:
    array([[0.99449146, 0.92339551],
           [0.1837405 , 0.41719798]])
    '''
    
    • random.randn函数,生成数值成标准正态分布(平均值为0,标准差为1)的数组
    import numpy as np
    # 创建2行3列,取值范围为标准正态分布的数组
    np.random.randn(3,2)
    '''
    输出:
    array([[-1.27481003, -1.5888111 ],
           [ 0.16985203, -2.91526479],
           [ 1.75992671, -2.81304831]])
    '''
    
    • random.randint函数,生成可以指定范围的随机整数数组
    import numpy as np
    # 创建2行2列,取值范围为[2,10)的随机整数数组
    np.random.randint(2,10,size=(2,2))
    '''
    输出:
    array([[5, 4],
           [3, 7]])
    '''
    
    • random.normal函数,生成数值成正态分布(可指定平均值、标准差)的数组
    import numpy as np
    # 创建一维,数值成正态分布(均值为1,标准差为2)的数组
    # 参数loc代表均值,scale代表标准差
    np.random.normal(loc=1,scale=2,size=5)
    '''
    输出:
    array([ 0.82962241,  0.41738042,  0.0470862 ,  1.79446076, -1.47514478])
    '''
    

    random模块还有其他函数,这里不多说。

    7、如何查看数组的维度?

    前面说到,数组维度即代表轴的数量。

    我们可以通过数组(adarray)对象的ndim或shape属性,来查看轴的数量。

    • ndim属性直接返回维度值;
    • shape属性返回一个元组,元组的长度即代表维度值,里面的数字从左往右分别代表每一轴的元素数量。
    import numpy as np
    # 创建一维数组
    x1 = np.array([1,2,3])
    # 返回维度值
    x1.ndim
    '''
    输出:1
    '''
    # 创建二维数组
    x2 = np.array([[1,2,3],[4,5,6]])
    # 返回形状
    x2.shape
    '''
    输出:(2, 3)
    元素长度为2代表二维,
    元素2代表0轴有两个元素,
    元素3代表1轴有3个元素。
    '''
    

    8、如何查看数组有多少个元素?

    数组(ndarray)对象的size属性可以查看数组包含元素总数。

    import numpy as np
    # 创建二维数组
    x2 = np.array([[1,2,3],[4,5,6]])
    # 查看元素总数
    x2.size
    '''
    输出:6
    '''
    

    还可以通过shape属性返回元素的乘积,来计算数组元素数量。

    import numpy as np
    from functools import reduce
    # 创建二维数组
    x2 = np.array([[1,2,3],[4,5,6]])
    # 查看元素总数
    reduce(lambda x,y:x*y , x2.shape)
    '''
    输出:6
    shape形状:
    (2,3)
    '''
    

    9、Numpy数组支持哪些数据类型?

    Numpy支持的数据类型非常多,所以很适合做数值计算。 下面给出常见的数据类型:


    10、如何查看数组的类型?

    数组(adarrry)对象提供dtype属性,用来查看数组类型。

    import numpy as np
    # 创建二维数组
    x2 = np.array([[1,2,3],[4,5,6]],dtype=int)
    # 返回类型
    x2.dtype
    '''
    输出:dtype('int32')
    '''
    

    11、如何改变数组的形状?

    前面说过,数组的shape属性返回一个元组,能够反映数组的形状,包括维度以及每个轴的元素数量。

    那么如果给定一个数组,怎么改变其形状呢?

    常用的方式有两种:

    • reshape方法,它返回一个新的数组,而不能改变原始数组。
    • resize方法,无返回值,它更改了原始数组。

    比如说我要将一个二维数组转换为三维数组。

    import numpy as np
    # 创建二维数组
    x2 = np.array([[1,2,3],[4,5,6]])
    # 将x2转换为三维数组,并且自定义每个轴的元素数量
    x2.reshape(1,2,3)
    '''
    输出:
    array([[[1, 2, 3],
            [4, 5, 6]]])
    '''
    

    reshape方法可以传入整数或者元组形式的参数。

    传入的参数和shape属性返回的元组的含义是一样的。

    例如, x2.reshape(1,2,3)是将二维数组转换成三维数组,参数个数代表要转换的维度,参数数字从左到右分别表示0轴、1轴、2轴的元素数量。

    resize方法和reshape方法使用形式一样,区别是resize方法改变了原始数组形状。

    import numpy as np
    # 创建二维数组
    x2 = np.array([[1,2,3],[4,5,6]])
    # 将x2转换为三维数组,并且自定义每个轴的元素数量
    x2.resize((1,2,3))
    x2
    '''
    输出:
    array([[[1, 2, 3],
            [4, 5, 6]]])
    '''
    

    12、如何对数组进行索引和切片操作?

    numpy一维数组的索引和切片操作类似python列表,这里不多讲。

    比如说取一维数组前三个元素。

    import numpy as np
    # 创建一维数组
    x1 = np.array([1,2,3,4])
    # 切片,取前三个元素
    x1[:3]
    '''
    输出:
    array([1, 2, 3])
    '''
    

    重点是对多维数组的索引和切片。

    多维数组有多个轴,那么就需要对每个轴进行索引。

    例如,三维数组形状为(x,y,z),分别代表:0轴有x个元素、1轴有y个元素,2轴有z个元素。

    对0、1、2轴进行索引,如果取o轴第2个元素、1轴第0个元素、2轴第3个元素,那么索引形式就为[2,0,3]。

    import numpy as np
    # 创建三维数组
    x3 = np.arange(24).reshape(3,2,4)
    # 对该三维数组进行索引
    x3[2,0,3]
    
    '''
    输出:19
    
    三维数组形式:
    array([[[ 0,  1,  2,  3],
            [ 4,  5,  6,  7]],
    
           [[ 8,  9, 10, 11],
            [12, 13, 14, 15]],
    
           [[16, 17, 18, 19],
            [20, 21, 22, 23]]])
    '''
    

    切片也是同样道理。

    如果取o轴前2个元素、1轴前1个元素、2轴后2个元素,那么切片形式就为[:2,:1,-2:]。

    import numpy as np
    # 创建三维数组
    x3 = np.arange(24).reshape(3,2,4)
    # 对该三维数组进行切片
    x3[:2,:1,-2:]
    
    '''
    输出:
    array([[[ 2,  3]],
    
           [[10, 11]]])
    
    三维数组形式:
    array([[[ 0,  1,  2,  3],
            [ 4,  5,  6,  7]],
    
           [[ 8,  9, 10, 11],
            [12, 13, 14, 15]],
    
           [[16, 17, 18, 19],
            [20, 21, 22, 23]]])
    '''
    

    13、如何对数组里每个元素进行迭代?

    说到迭代,大家很容易想到直接对数组直接使用for循环操作,对于一维数组来说,当然是可以的。

    import numpy as np
    # 创建一维数组
    x1 = np.array([1,2,3,4])
    # 迭代
    for i in x1:
        print(i)
    '''
    输出:
    1
    2
    3
    4
    '''
    

    但对于多维数组,迭代是相对于0轴完成的,就是多维数组最外层的那一维。

    你没有办法直接遍历数组里每一个元素,嵌套循环又太低效。

    这个时候就需要用到flat方法,它可以将多维数组平铺为一维的迭代器。

    import numpy as np
    # 创建二维数组
    x2 = np.array([[1,2,3],[4,5,6]])
    # 先平铺,再迭代
    for i in x2.flat:
        print(i)
    '''
    输出:
    1
    2
    3
    4
    5
    6
    '''
    

    14、如何将多维数组展开为一维数组?

    数组(ndarray)对象提供了ravel方法,用来将多维数组展开为一维数组。

    import numpy as np
    # 创建er维数组
    x3 = np.arange(12).reshape(3,4)
    # 对该三维数组进行索引
    x3.ravel()
    '''
    输出:
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
    '''
    

    15、什么广播机制?

    广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式, 对多个数组的算术运算通常在相应的元素上进行。

    较小的数组在较大的数组上“广播”,以便它们具有兼容的形状。

    比如说一个一维数组乘以一个数字,相当于一维数组里每个元素都乘以这个数。


    import numpy as np
    # 创建一维数组
    x1 = np.array([1,2,3])
    # 广播
    x1 * 2
    '''
    输出:
    array([2, 4, 6])
    '''
    

    如果相同维度的数组进行运算,其shape相同,那么广播就是两个数组相同位数的元素进行运算。

    import numpy as np
    # 创建一维数组
    x1 = np.array([1,2,3])
    x2 = np.array([4,5,6])
    # 广播
    x1 + x2
    '''
    输出:
    array([5, 7, 9])
    '''
    

    如果两个数组维度不同,进行运算,这里就触发了广播的两个规则。

    • 让所有输入数组都向其中形状最长的数组看齐,形状中不足的部分都通过在前面加 1 补齐;
    • 当输入数组的某个维度的长度为 1 时,沿着此维度运算时都用此维度上的第一组值。

    这两个规则保证了不同维度数组进行运算时,其维度自动调整成一致。

    import numpy as np
    # 创建一维数组
    x1 = np.array([[1,2,3],[4,5,6]])
    x2 = np.array([2,3,4])
    # 广播
    x1 - x2
    '''
    输出:
    array([[-1, -1, -1],
           [ 2,  2,  2]])
    '''
    

    16、numpy中如何进行数值舍入操作?

    • around函数,用于四舍五入,返回一个新数组
    import numpy as np
    # 创建一维数组
    x1 = np.array([1.45,2.78,3.12])
    # 四舍五入,到小数点后1位
    np.around(x1,1)
    '''
    输出:
    array([1.4, 2.8, 3.1])
    '''
    
    • floor函数,用于向下取整,返回一个新数组
    import numpy as np
    # 创建一维数组
    x1 = np.array([1.45,2.78,3.12])
    # 向下取整
    np.floor(x1)
    '''
    输出:
    array([1., 2., 3.])
    '''
    
    • ceil函数,用于向上取整,返回一个新数组
    import numpy as np
    # 创建一维数组
    x1 = np.array([1.45,2.78,3.12])
    # 向下取整
    np.ceil(x1)
    '''
    输出:
    array([2., 3., 4.])
    '''
    

    17、如何对数组进行转置操作?

    numpy提供了transpose函数用以对数组进行维度的调换,也就是转置操作。

    转置后返回一个新数组。

    import numpy as np
    # 创建二维数组
    x1 = np.arange(12).reshape(3,4)
    # 转置
    np.transpose(x1)
    '''
    输出:
    array([[ 0,  4,  8],
           [ 1,  5,  9],
           [ 2,  6, 10],
           [ 3,  7, 11]])
    原数组:
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    '''
    

    当然,可以用更简单的方法。

    数组对象提供了T方法,用于转置,同样会返回一个新数组。

    import numpy as np
    # 创建二维数组
    x1 = np.arange(12).reshape(3,4)
    # 转置
    x1.T
    '''
    输出:
    array([[ 0,  4,  8],
           [ 1,  5,  9],
           [ 2,  6, 10],
           [ 3,  7, 11]])
    原数组:
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    '''
    

    18、如何连接两个相同维度的数组?

    numpy的concatenate 函数用于沿指定轴连接相同形状的两个或多个数组。

    import numpy as np
    # 创建两个二维数组
    x1 = np.array([[1,2,3],[4,5,6]])
    x2 = np.array([[7,8,9],[10,11,12]])
    # 连接,默认沿0轴连接
    np.concatenate((x1,x2))
    
    '''
    输出:
    array([[ 1,  2,  3],
           [ 4,  5,  6],
           [ 7,  8,  9],
           [10, 11, 12]])
    '''
    
    # 指定沿1轴连接
    np.concatenate((x1,x2),axis=1)
    
    '''
    输出:
    array([[ 1,  2,  3,  7,  8,  9],
           [ 4,  5,  6, 10, 11, 12]])
    '''
    

    19、如何向数组添加值?

    • numpy的append 函数向数组末尾追加值,可以指定不同的轴。
    import numpy as np
    # 创建一个二维数组
    x1 = np.array([[1,2,3],[4,5,6]])
    # 直接向数组末尾添加元素,返回平铺的一维数组
    np.append(x1,[7,8,9])
    '''
    输出:
    array([1, 2, 3, 4, 5, 6, 7, 8, 9])
    '''
    
    # 沿轴 0 添加元素
    np.append(x1, [[7,8,9]],axis = 0)
    '''
    输出:
    array([[1, 2, 3],
           [4, 5, 6],
           [7, 8, 9]])
    '''
    
    # 沿轴 1 添加元素
    np.append(x1, [[5,5,5],[7,8,9]],axis = 1)
    '''
    输出:
    array([[1, 2, 3, 5, 5, 5],
           [4, 5, 6, 7, 8, 9]])
    '''
    
    • numpy的insert 函数可以沿给定轴,在数组中任意位置插入数据。
    import numpy as np
    # 创建一个二维数组
    x1 = np.array([[1,2,3],[4,5,6],[7,8,9]])
    # 直接在指定位置插入元素,返回平铺的一维数组
    np.insert(x1,2,[0,0,0])
    '''
    输出:
    array([1, 2, 0, 0, 0, 3, 4, 5, 6, 7, 8, 9])
    
    原数组:
    array([[1, 2, 3],
           [4, 5, 6],
           [7, 8, 9]])
    '''
    
    # 指定位置,沿轴 0 插入元素
    np.insert(x1,1,[0,0,0],axis=0)
    '''
    输出:
    array([[1, 2, 3],
           [0, 0, 0],
           [4, 5, 6],
           [7, 8, 9]])
    '''
    
    # 指定位置,沿轴 1插入元素
    np.insert(x1,2,[0,0,0],axis=1)
    '''
    输出:
    array([[1, 2, 0, 3],
           [4, 5, 0, 6],
           [7, 8, 0, 9]])
    '''
    

    20、如何对数组进行去重操作?

    numpy的unique 函数用于去除数组中的重复元素,返回一个新数组。

    import numpy as np
    # 创建一个一维数组
    x1 = np.array([2,3,5,1,3,8,1,0])
    np.unique(x1)
    '''
    输出:
    array([0, 1, 2, 3, 5, 8])
    '''
    

    unique函数还能返回重复元素的索引、计数等信息,可去查文档自定义参数。


    参考资料

    [1]

    numpy文档: https://www.numpy.org.cn/

    [2]

    菜鸟教程: https://www.runoob.com/numpy/numpy-tutorial.html

    版权声明:作者保留权利,不代表意本站立场。如需转载请联系本站以及作者。

    参与讨论

    回复《 Numpy基础20问

    EditorJs 编辑器

    沙发,很寂寞~
    反馈
    to-top--btn