精华内容
下载资源
问答
  • 2022-03-25 21:52:09

    1.数组创建

    numpy 提供的最重要的数据结构是ndarray,它是 python 中list的扩展。

    (1)通过array()函数进行创建。

    创建一维数组

    >>> a = np.array([0, 1, 2, 3, 4])
    >>> b = np.array((0, 1, 2, 3, 4))
    >>> print(a, type(a))
    [0 1 2 3 4] <class 'numpy.ndarray'>
    

    创建二维数组

    c = np.array([[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]])
    print(c, type(c))
    # [[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]] <class 'numpy.ndarray'>

    创建三维数组

    >>> d = np.array([[(1.5, 2, 3), (4, 5, 6)],
    ...               [(3, 2, 1), (4, 5, 6)]])
    >>> print(d, type(d))
    [[[1.5 2.  3. ]
      [4.  5.  6. ]]
    
     [[3.  2.  1. ]
      [4.  5.  6. ]]] <class 'numpy.ndarray'>
    

    (2)通过asarray()函数进行创建

    array()和asarray()均可以将结构数据转化为ndarray,当当数据源是ndarray 时,array()仍然会 copy 出一个副本,占用新的内存,在不改变dtype时,asarray()不会进行复制。

    • empty()函数:返回一个空数组,数组元素为随机数。
    • eye()函数:返回一个对角线上为1,其它地方为零的单位数组。
    • diag()函数:提取对角线或构造对角数组。

    2.利用数值范围来创建ndarray

    • arange()函数:返回给定间隔内的均匀间隔的值。
    • linspace()函数:返回指定间隔内的等间隔数字。
    • logspace()函数:返回数以对数刻度均匀分布。
    • numpy.random.rand() 返回一个由[0,1)内的随机数组成的数组。

    3.数组的属性

    • numpy.ndarray.ndim用于返回数组的维数(轴的个数)也称为秩,一维数组的秩为 1,二维数组的秩为 2,以此类推。
    • numpy.ndarray.shape表示数组的维度,返回一个元组,这个元组的长度就是维度的数目,即 ndim 属性(秩)。
    • numpy.ndarray.size数组中所有元素的总量,相当于数组的shape中所有元素的乘积,例如矩阵的元素总量为行与列的乘积。
    • numpy.ndarray.dtype ndarray 对象的元素类型。
    • numpy.ndarray.itemsize以字节的形式返回数组中每一个元素的大小。
    #一维
    >>> a = np.array([1, 2, 3, 4, 5])
    >>> print(a.shape)  # (5,)
    (5,)
    >>> print(a.dtype)  # int32
    int32
    >>> print(a.size)  # 5
    5
    >>> print(a.ndim)  # 1
    1
    >>> print(a.itemsize)  # 4
    
    
    #二维
    >>> b = np.array([[1, 2, 3], [4, 5, 6.0]])
    >>> print(b.shape)  # (2, 3)
    (2, 3)
    >>> print(b.dtype)  # float64
    float64
    >>> print(b.size)  # 6
    6
    >>> print(b.ndim)  # 2
    2
    >>> print(b.itemsize)  # 8
    8
    

    参考:阿里云登录 - 欢迎登录阿里云,安全稳定的云计算服务平台

    更多相关内容
  • Numpy创建数组

    2022-04-08 12:14:26
    Numpy创建数组 在前一节,介绍了创建 ndarray 数组的基本方法,除了使用 array() 方法外,NumPy 还提供了其他创建 ndarray 数组的方法。本节对这些常用方法做简单介绍。 numpy.empty() numpy.empty() 创建未初始化的...

    Numpy创建数组

    在前一节,介绍了创建 ndarray 数组的基本方法,除了使用 array() 方法外,NumPy 还提供了其他创建 ndarray 数组的方法。本节对这些常用方法做简单介绍。

    numpy.empty()

    numpy.empty() 创建未初始化的数组,可以指定创建数组的形状(shape)和数据类型(dtype),语法格式如下:

    numpy.empty(shape, dtype = float, order = 'C')
    

    它接受以下参数:

    shape:指定数组的形状;

    dtype:数组元素的数据类型,默认值是值 float;

    order:指数组元素在计算机内存中的储存顺序,默认顺序是“C”(行优先顺序)。

    使用示例如下:

    import numpy as np 
    arr = np.empty((3,2), dtype = int) 
    print(arr) 
    

    输出结果:

    [[2003134838  175335712]
    [ 538976288  538976288]
    [1970562418 1684369010]]
    

    可以看到,numpy.empty() 返回的数组带有随机值,但这些数值并没有实际意义。切记 empty 并非创建空数组。

    numpy.zeros()

    该函数用来创建元素均为 0 的数组,同时还可以指定被数组的形状,语法格式如下:

    numpy. zeros(shape,dtype=float,order="C")
    

    参数说明

    参数名称说明描述
    shape指定数组的形状大小。
    dtype可选项,数组的数据类型
    order“C”代表以行顺序存储,“F”则表示以列顺序存储

    示例如下:

    import numpy as np
    #默认数据类型为浮点数
    a=np.zeros(6)
    print(a)
    b=np.zeros(6,dtype="complex64" )
    print(b)
    

    输出结果:

    #a数组
    [0. 0. 0. 0. 0. 0.]
    #b数组
    [0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]
    

    也可以使用自定义的数据类型创建数组,如下所示:

    c = np.zeros((3,3), dtype = [('x', 'i4'), ('y', 'i4')]) 
    print(c)
    #输出x,y,并指定的数据类型
    [[(0, 0) (0, 0) (0, 0)]
    [(0, 0) (0, 0) (0, 0)]
    [(0, 0) (0, 0) (0, 0)]]
    numpy.ones()
    

    返回指定形状大小与数据类型的新数组,并且新数组中每项元素均用 1 填充,语法格式如下:

    numpy.ones(shape, dtype = None, order = 'C')
    

    示例如下:

    import numpy as np 
    arr1 = np.ones((3,2), dtype = int) 
    print(arr1)  
    

    输出结果如下:

     [[1 1] [1 1] [1 1]]
    

    下面介绍如何使用 Python 列表、流对象、可迭代对象来创建一个 NumPy 数组。

    numpy.asarray()

    asarray() 与 array() 类似,但是它比 array() 更为简单。asarray() 能够将一个 Python 序列转化为 ndarray 对象,语法格式如下:

    numpy.asarray(sequence,dtype = None ,order = None )
    

    它接受下列参数:

    sequence:接受一个 Python 序列,可以是列表或者元组;

    dtype:可选参数,数组的数据类型;

    order:数组内存布局样式,可以设置为 C 或者 F,默认是 C。

    示例 1,将列表转化为 numpy 数组:

    import numpy as np 
    l=[1,2,3,4,5,6,7] 
    a = np.asarray(l); 
    print(type(a)) 
    print(a) 
    

    输出结果如下所示:

    #a数组类型
    <class 'numpy.ndarray'>
    #a数组
    [1 2 3 4 5 6 7]
    

    示例 2,使用元组创建 numpy 数组:

    import numpy as np 
    l=(1,2,3,4,5,6,7)    
    a = np.asarray(l); 
    print(type(a)) 
    print(a)  
    

    输出结果如下:

    <class 'numpy.ndarray'>
    [1 2 3 4 5 6 7]
    

    示例 3,使用嵌套列表创建多维数组:

    import numpy as np 
    l=[[1,2,3,4,5,6,7],[8,9]] 
    a = np.asarray(l); 
    print(type(a)) 
    print(a)  
    

    输出结果:

    <class 'numpy.ndarray'>
    [list([1, 2, 3, 4, 5, 6, 7]) list([8, 9])]
    numpy.frombuffer()
    

    表示使用指定的缓冲区创建数组。下面给出了该函数的语法格式:

    numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
    

    它的参数说明如下所示:

    buffer:将任意对象转换为流的形式读入缓冲区;

    dtype:返回数组的数据类型,默认是 float32;

    count:要读取的数据数量,默认为 -1 表示读取所有数据;

    offset:读取数据的起始位置,默认为 0。

    示例 4 如下:

    import numpy as np 
    #字节串类型
    l = b'hello world' 
    print(type(l)) 
    a = np.frombuffer(l, dtype = "S1") 
    print(a) 
    print(type(a)) 
    

    输出结果如下:

    <class 'bytes'>
    [b'h' b'e' b'l' b'l' b'o' b' ' b'w' b'o' b'r' b'l' b'd']
    <class 'numpy.ndarray'>
    

    numpy.fromiter()

    该方法可以把迭代对象转换为 ndarray 数组,其返回值是一个一维数组。

    numpy.fromiter(iterable, dtype, count = -1)
    

    参数说明如下:

    参数描述

    参数名称描述说明
    iterable可迭代对象。
    dtype返回数组的数据类型。
    count读取的数据数量,默认为 -1,读取所有数据。

    示例5:使用内置 range() 函数创建列表对象,然后使用迭代器创建 ndarray 对象,代码如下:

    import numpy as np
    # 使用 range 函数创建列表对象 
    list=range(6)
    #生成可迭代对象i
    i=iter(list)
    #使用i迭代器,通过fromiter方法创建ndarray
    array=np.fromiter(i, dtype=float)
    print(array)
    

    输出结果:

    [0. 1. 2. 3. 4. 5.]
    
    展开全文
  • 文章目录numpy数组一、基于数组对象1. array和asarray2. frombuffer3. fromiter二、基于构造函数1. empty2. zeros3. ones三、基于数值范围1. arange2. linspace3. logspace numpy数组 NumPy 最重要的一个特点是其 N...


    numpy数组

    NumPy 最重要的一个特点是其 N 维数组对象 ndarray,用于存放同类型数据的集合,内部结构如下:

    • 一个指向数据(内存或内存映射文件中的一块数据)的指针
    • 数据类型或 dtype,描述在数组中的固定大小值的格子
    • 一个表示数组形状(shape)的元组,表示各维度大小的元组
    • 一个跨度元组(stride),其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数

    在这里插入图片描述
    其生成函数如下:

    numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
    
    • object是数组对象,必选
    • dtype是数据类型
    • copy对象是否复制
    • order创建数组的样式,C为航方向,F为列方向,默认A为任意方向
    • subok默认返回一个与基类类型一直的数组
    • ndmin指定生产数组的最小维度

    一、基于数组对象

    1. array和asarray

    array和asarray都可以将结构数据转化为ndarray,主要区别就是当数据源是ndarray时,array会copy出一个副本,占用新的内存,属于深拷贝,但asarray不会。

    x = [1,2,3,4,5]
    a = np.array(x)
    b = np.asarray(x)
    a == b
    
       array([ True,  True,  True,  True,  True])
    

    2. frombuffer

    该方法用于实现动态数组,接收buffer输入,以流的形式读入转化ndarray对象

    s = b'I like python'
    sbf = np.frombuffer(s,dtype='S1')
    print(sbf)
    
       [b'I' b' ' b'l' b'i' b'k' b'e' b' ' b'p' b'y' b't' b'h' b'o' b'n']
    

    buffer 是字符串的时候,Python3 默认 str 是 Unicode 类型,所以要转成 bytestring 在原 str 前加上 b

    3. fromiter

    从可迭代对象中建立 ndarray 对象,返回一维数组。

    list=range(5)
    it=iter(list) ## 构造迭代器
    x=np.fromiter(it, dtype=float)
    print(x)
    

    output:
    [0. 1. 2. 3. 4.]

    二、基于构造函数

    1. empty

    创建一个指定形状(shape)、数据类型(dtype)且未初始化的数组(数组元素为随机值)

    x = np.empty([3,3], dtype = float) 
    print(x)
    
       array([[0.00000000e+000, 0.00000000e+000, 0.00000000e+000],
              [0.00000000e+000, 0.00000000e+000, 6.71929278e-321],
              [7.56593016e-307, 2.22522596e-306, 2.56765117e-312]])
    

    2. zeros

    创建指定大小的数组,数组元素为 0

    x = np.zeros(5) # 默认为浮点数
    y = np.zeros((5,), dtype = np.int) # 设置类型为整数
    z = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')]) # 自定义类型 
    print('x: {0}\n y: {1} \n z: {2}'.format(x,y,z))
    
    x: [0. 0. 0. 0. 0.]
    y: [0 0 0 0 0] 
    z: [[(0, 0.) (0, 0.)]
       [(0, 0.) (0, 0.)]]
    

    3. ones

    创建指定形状的数组,数组元素为 1

    x = np.ones(5) # 默认为浮点数
    y = np.ones([3,3], dtype = int)# 自定义类型
    print('x: {0}\n y: {1}'.format(x,y))
    
    x: [1. 1. 1. 1. 1.]
    y: [[1 1 1]
        [1 1 1]
        [1 1 1]]
    

    三、基于数值范围

    1. arange

    根据 start 与 stop 指定的范围以及 step 设定的步长,生成一个 ndarray
    numpy.arange(start, stop, step, dtype)

    • start:起始值,默认为0
    • stop:终止值(不包含)
    • step:步长,默认为1
    x = np.arange(1,100,3).reshape(3,11) ##从1
    print(x)
    
    array([[ 1,  4,  7, 10, 13, 16, 19, 22, 25, 28, 31],
           [34, 37, 40, 43, 46, 49, 52, 55, 58, 61, 64],
           [67, 70, 73, 76, 79, 82, 85, 88, 91, 94, 97]])
    

    2. linspace

    创建等差数列的一维数组
    np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

    • start:起始值
    • stop:终止值,如果endpoint为true,该值包含于数列中
    • num:样本数量,默认为50
    • endpoint:该值为 true 时,数列中包含stop值,反之不包含,默认是True
    • retstep:如果为 True 时,生成的数组中会显示间距,反之不显示
    x = np.linspace(1,10,10, retstep= True)
    print(x)
    
    (array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]), 1.0)
    

    3. logspace

    创建对数等比数列
    np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

    • start:起始值为basestart
    • stop:终止值basestop
    • num:样本数量,默认为50
    • endpoint:该值为 true 时,数列中包含stop值,反之不包含,默认是True
    • base:对数 log 的底数
    x = np.logspace(0,10,10,endpoint=False,base=2)
    print(x)
    
    [  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]
    
    展开全文
  • NumPy创建数组的几种方式介绍

    千次阅读 2022-03-28 04:09:01
    创建数组的几种常见机制: 1. `numpy` 中定义的原生数组创建函数 2. 使用Python中类数组对象创建 `numpy` 数组

    创建数组

    创建数组的几种常见机制:

    1. numpy 中定义的原生数组创建函数
    2. 使用Python中类数组对象创建 numpy 数组

    一、 numpy 中定义的原生数组创建函数

    1. numpy.zeros(shape, dtype=float, order='C')

    参数

    • shape:int or tuple of lnts,新数组的形状大小;
    • dtype:data-type, optional,指定数组元素的数据类型(dtype);
    • order:{‘C’, ‘F’}, optional,行优先或者列优先;

    Returns

    • out:ndarray,函数返回一个全零数组。
    >>>np.zeros([2,3], dtype=int)
    array([[0, 0, 0],
           [0, 0, 0]])
    

    2. numpy.empty(shape, dtype=float, order='C')

    参数

    • shape:int or tuple of lnts,新数组的形状大小;
    • dtype:data-type, optional,指定数组元素的数据类型(dtype);
    • order:{‘C’, ‘F’}, optional,行优先或者列优先;

    Returns

    • out:ndarray,函数返回一个未初始化的数组。
    
    >>>np.zeros([2,3], dtype=int)
    array([[          0,           0,   242358960],
           [        720,           0, -2147483648]])
    

    zeros 函数不同,empty 不会将元素初始化为零,因此创建速度更快。但是它就需要用户手动设置数组的所有元素值,谨慎使用。

    3. numpy.ones(shape, dtype=float, order='C')

    参数

    • shape:int or tuple of lnts,新数组的形状大小;
    • dtype:data-type, optional,指定数组元素的数据类型(dtype);
    • order:{‘C’, ‘F’}, optional,行优先或者列优先;

    Returns

    • out:ndarray,函数返回一个全一数组。
    
    >>>np.ones([2,3], dtype=int)
    array([[1, 1, 1],
           [1, 1, 1]])
    

    4. numpy.full(shape, fill_value, dtype=None, order='C')

    参数

    • shape:int or sequence of lnts,新数组的形状大小;
    • fill_value:将被赋值给新数组的元素值;
    • dtype:data-type, optional,指定数组元素的数据类型(dtype);
    • order:{‘C’, ‘F’}, optional,行优先或者列优先;

    Returns

    • out:ndarray,函数返回一个全为fill_value值的数组。
    >>>np.full([2,3], 4, dtype=int)
    array([[4, 4, 4],
           [4, 4, 4]])
    

    5. numpy.zeros_like(a, dtype=float, order='C', subok=True, shape=None)

    参数

    • a:array_like,创建的新数组定义了和这个对象相同的形状和数据类型;
    • dtype:data-type, optional,重新指定数组元素的数据类型(dtype);
    • order:{‘C’, ‘F’, ‘K’}, optional,存储顺序,'C’表示C-order,'F’表示F-order,'K’表示遵循a的顺序;
    • subok:bool, optional,如果为True,则新创建的数组将使用a的子类类型,否则它将是基类数组;
    • shape:int or sequence of ints, optional,重新指定结果的形状。

    Returns

    • out:ndarray,函数返回一个全零数组。
    >>>a = np.zeros([2,3], dtype=int)
    >>>np.zeros_like(a, dtype=float)
    array([[0., 0., 0.],
           [0., 0., 0.]])
    

    6. numpy.empty_like(a, dtype=float, order='C', subok=True, shape=None)

    参数

    • a:array_like,创建的新数组定义了和这个对象相同的形状和数据类型;
    • dtype:data-type, optional,重新指定数组元素的数据类型(dtype);
    • order:{‘C’, ‘F’, ‘K’}, optional,存储顺序,'C’表示C-order,'F’表示F-order,'K’表示遵循a的顺序;
    • subok:bool, optional,如果为True,则新创建的数组将使用a的子类类型,否则它将是基类数组;
    • shape:int or sequence of ints, optional,重新指定结果的形状。

    Returns

    • out:ndarray,函数返回一个未初始化的数组。
    >>>a = np.zeros([2,3], dtype=int)
    >>>np.empty_like(a)
    array([[0, 0, 0],
           [0, 0, 0]])
    

    7. numpy.ones_like(a, dtype=float, order='C', subok=True, shape=None)

    参数

    • a:array_like,创建的新数组定义了和这个对象相同的形状和数据类型;
    • dtype:data-type, optional,重新指定数组元素的数据类型(dtype);
    • order:{‘C’, ‘F’, ‘K’}, optional,存储顺序,'C’表示C-order,'F’表示F-order,'K’表示遵循a的顺序;
    • subok:bool, optional,如果为True,则新创建的数组将使用a的子类类型,否则它将是基类数组;
    • shape:int or sequence of ints, optional,重新指定结果的形状。

    Returns

    • out:ndarray,函数返回一个全一数组。
    >>>a = np.zeros([2,3], dtype=int)
    >>>np.ones_like(a)
    array([[1, 1, 1],
           [1, 1, 1]])
    

    8. numpy.full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None)

    参数

    • a:array_like,创建的新数组定义了和这个对象相同的形状和数据类型;
    • fill_value:将被赋值给新数组的元素值;
    • dtype:data-type, optional,重新指定数组元素的数据类型(dtype);
    • order:{‘C’, ‘F’, ‘K’}, optional,存储顺序,'C’表示C-order,'F’表示F-order,'K’表示遵循a的顺序;
    • subok:bool, optional,如果为True,则新创建的数组将使用a的子类类型,否则它将是基类数组;
    • shape:int or sequence of ints, optional,重新指定结果的形状。

    Returns

    • out:ndarray,函数返回一个全一数组。
    >>>a = np.zeros([2,3], dtype=int)
    >>>np.full_like(a, 4)
    array([[4, 4, 4],
           [4, 4, 4]])
    

    9. numpy.eye(N, M=None, k=0, dtype=<class 'float'>, order='C')

    参数

    • N:int,输出数组的行数;
    • M:int, optional,输出数组的列数,如果为None,默认等与N;
    • k:int, optional,0表示主对角线,正数表示上对角线,负数表示下对角线;
    • dtype:data-type, optional,重新指定数组元素的数据类型(dtype);
    • order:{‘C’, ‘F’}, optional,行优先或者列优先;

    Returns

    • out:ndarray,函数返回一个对角线元素为1,其余元素为零的数组。
    >>>np.eye(4, M=5, dtype=float)
    array([[1., 0., 0., 0., 0.],
           [0., 1., 0., 0., 0.],
           [0., 0., 1., 0., 0.],
           [0., 0., 0., 1., 0.]])
    
    >>>np.eye(4, M=5, k=1, dtype=float)
    array([[0., 1., 0., 0., 0.],
           [0., 0., 1., 0., 0.],
           [0., 0., 0., 1., 0.],
           [0., 0., 0., 0., 1.]])
    

    10. numpy.identity(n, dtype=<class 'float'>)

    参数

    • n:int,输出数组的行数;
    • dtype:data-type, optional,指定数组元素的数据类型(dtype);

    Returns

    • out:ndarray,函数返回一个对角线元素为1的n×n数组。
    >>>np.identity(4, dtype=int)
    array([[1, 0, 0, 0],
           [0, 1, 0, 0],
           [0, 0, 1, 0],
           [0, 0, 0, 1]])
    

    11. numpy.arange([start, ]stop, [step, ]dtype=None)

    参数

    • start:int or real, optional,间隔开始,包括开始该值,默认为0;
    • stop:int or real,间隔结束,不包括该值;
    • step:int or real, optional,间隔长度,默认为1;
    • dtype:dtype, optional,输出数组的数据类型。

    Returns

    • out:ndarray,返回固定间隔值的数组。
    # arange(stop)
    >>>np.arange(6, dtype=int)
    array([0, 1, 2, 3, 4, 5])
    
    # arange(start, stop)
    >>>np.arange(3, 9, dtype=int)
    array([3, 4, 5, 6, 7, 8])
    
    # arange(start, stop, step) 
    
    >>>np.arange(3, 6, 0.5, dtype=int)
    array([3, 3, 3, 3, 3, 3])
    >>>np.arange(3, 6, 0.5, dtype=float)
    array([3. , 3.5, 4. , 4.5, 5. , 5.5])
    

    注意

    1. 如果是浮点参数,那么输出数组的长度是 ceil(stop-start)/step , 因为浮点溢出问题,可能会导致输出数组的最后一个元素大于 stop 值。因此,这种情况下,应该使用numpy.linspace
    >>>np.arange(-3, 3, 0.5, dtype=int)
    array([-3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8])
    
    1. 内置的 range 函数生成任意大小的Python内置整型, numpy.arange生成的是numpy.int32 or numpy.int64 。这可能会导致对于大的正数的错误结果。

    12. numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

    参数

    • start:array_like,序列的起始值;
    • stop:array_like,序列的终止值,如果endpoint为true,该值包含于数列中;
    • num:int, optional,要生成的等步长的样本数量,默认为50;
    • endpoint:bool, optional,该值为 true 时,数列中包含stop值,反之不包含,默认是True;
    • retstep:bool, optional,如果为 True 时,生成的数组中会显示间距,反之不显示;
    • dtype: dtype, optional,ndarray 的数据类型;

    Returns

    • samples:ndarray,等距间隔的序列;
    • step:float, optional,间隔长度;
    >>>np.linspace(2.0, 3.0, num=5)
    array([2.  , 2.25, 2.5 , 2.75, 3.  ])
    >>>np.linspace(2.0, 3.0, num=5, endpoint=False)
    array([2. ,  2.2,  2.4,  2.6,  2.8])
    >>>np.linspace(2.0, 3.0, num=5, retstep=True)
    (array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)
    

    13. numpy.logspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

    参数

    • start:array_like,序列的起始值;
    • stop:array_like,序列的终止值,如果endpoint为true,该值包含于数列中;
    • num:int, optional,要生成的等步长的样本数量,默认为50;
    • endpoint:bool, optional,该值为 true 时,数列中包含stop值,反之不包含,默认是True;
    • retstep:bool, optional,如果为 True 时,生成的数组中会显示间距,反之不显示;
    • dtype: dtype, optional,ndarray 的数据类型;

    Returns

    • samples:ndarray,对数刻度上等距的采样序列;
    >>>np.logspace(2.0, 3.0, num=4)
    array([ 100.        ,  215.443469  ,  464.15888336, 1000.        ])
    >>>np.logspace(2.0, 3.0, num=4, endpoint=False)
    array([100.        ,  177.827941  ,  316.22776602,  562.34132519])
    >>>np.logspace(2.0, 3.0, num=4, base=2.0)
    array([4.        ,  5.0396842 ,  6.34960421,  8.        ])
    

    二、从Python的 array_like 对象转化为 NumPy数组

    1. numpy.array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0, like=None)

    参数

    • object:array-like结构的数值数据对象,如果是标量,返回包含该对象的0维数组;
    • dtype:data-type, optional,输出数组的数据类型;
    • copy :bool, optional,值为True,则复制对象;
    • order:{‘C’, ‘F’, ‘K’}, optional,存储顺序,'C’表示C-order,'F’表示F-order,'K’表示遵循a的顺序;
    • subok:bool, optional,如果为True,直接返回子类,否则返回数组;
    • ndminint, optional,指定生成的数组应具有的最小维度数。为了满足这一要求,将根据需要对其形状进行预处理;

    Returns

    • out:ndarray,满足要求的数组对象;
    >>>np.array([1, 2, 3])
    array([1, 2, 3])
    
    # 多维数组
    >>>np.array([[1, 2], [3, 4]])
    array([[1, 2],
           [3, 4]])
    
    # 最小二维
    >>>np.array([1, 2, 3], ndmin=2)
    array([[1, 2, 3]])
    
    # 结构化数据类型对象
    >>>x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])
    x['a']
    array([1, 3])
    
    # 从子类创造一个数组
    >>>np.array(np.mat('1 2; 3 4'))
    array([[1, 2],
           [3, 4]])
    >>>np.array(np.mat('1 2; 3 4'), subok=True)
    matrix([[1, 2],
            [3, 4]])
    

    2. numpy.asarray(a, dtype=None, order=None, *, like=None)

    参数

    • a:array_like,输入数据,任何形式都会被转化为数组;
    • dtype:data_type, optional,设置输出数据的数据类型;
    • order:{‘C’, ‘F’, ‘K’}, optional,存储顺序,'C’表示C-order,'F’表示F-order,'K’表示遵循a的顺序;

    Returns

    • out:ndarray,如果输入的 a 已经是满足要求的数组了,则不会复制,直接返回。如果 a 是数组的子类,则返回基类ndarray。
    # 列表生成数组
    >>>a = [1, 2]
    >>>np.asarray(a)
    array([1, 2])
    
    # a 是数组,不发生复制
    >>>a = np.array([1, 2])
    >>>np.asarray(a) is a
    True
    
    # a 是数组,重新设置了新的数据类型,发生复制
    
    >>>a = np.array([1, 2], dtype=np.float32)
    >>>np.asarray(a, dtype=np.float32) is a
    True
    >>>np.asarray(a, dtype=np.float64) is a
    False
    

    numpy.arraynumpy.asarray 的区别:
    当参数本身就是数组时,numpy.array 会重新产生一个副本,而 numpy.asarray 不会。

    3. numpy.asanyarray(a, dtype=None, order=None, *, like=None)

    参数

    • a:array_like,输入数据,任何形式都会被转化为数组;
    • dtype:data_type, optional,设置输出数据的数据类型;
    • order:{‘C’, ‘F’, ‘K’}, optional,存储顺序,'C’表示C-order,'F’表示F-order,'K’表示遵循a的顺序;

    Returns

    • out:ndarray or an ndarray subclass,如果输入的 a 已经是满足要求的数组或数组的子类,则不会复制,直接返回。
    >>>a = [1, 2]
    >>>np.asanyarray(a)
    array([1, 2])
    
    >>>a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)
    >>>np.asanyarray(a) is a
    True
    

    4. numpy.asmatrix(data, dtype=None)

    参数

    • data:array_like,输入数据;
    • dtype:data_type, optional,设置输出数据的数据类型;
      Returns
    • mat:matrix,输出转化后的矩阵,如果输入已经是一个矩阵,则不发生复制。
    >>>x = np.array([[1, 2], [3, 4]])
    >>>m = np.asmatrix(x)
    >>>x[0,0] = 5
    >>>m
    matrix([[5, 2],
            [3, 4]])
    

    5. numpy.copy(a, order='K', subok=False)

    参数

    • a:array_like,输入数据;
    • order:{‘C’, ‘F’, ‘K’}, optional,存储顺序,'C’表示C-order,'F’表示F-order,'K’表示遵循a的顺序;
    • subok:bool, optional,如果为True,则子类将被返回,否则返回的数组将被强制为基类数组(默认为False)。

    Returns

    • out:数组a;效果等同于np.array(a, copy=True)
    展开全文
  • numpy数组创建
  • 第1关:Numpy创建数组

    2022-04-25 21:29:56
    在 Python 中创建数组有许多的方法,这里我们使用 Numpy 中的arange方法快速的新建一个数组: import numpy as np a = np.arange(5) 其中import numpy as np是指引入Numpy这个库,并取别名为np。之所以取别名,是...
  • numpy创建数组

    千次阅读 2019-02-23 17:50:39
    数组的操作 list ====== 特殊的数组 数组和列表的区别: 数组: 存储的时同一种数据类型; list:容器, 可以存储任意数据类型; 一维数组和数组的计算: # 一维数组和数组的计算 a = [1, 2, 3, 4] b =...
  • 4.Numpy创建数组

    2021-07-13 21:12:16
    可以使用以下方法创建数组 numpy.empty 生成一组随机的数组 import numpy as np x = np.empty([3,2], dtype = int) print (x) 生成一组随机的数组 [[ 6917529027641081856 5764616291768666155] [ 69175290
  • numpy创建数组的几种方法array(),arange(),array(range())创建数组array()创建全1、全0、全相同数字的数组创建随机数组 array(),arange(),array(range())创建数组 array() ①创建一维数组a,其中包含1,2,3,4,5五...
  • Numpy 创建数组.pdf

    2021-08-26 15:15:22
    Numpy 创建数组.pdf
  • 使用numpy创建数组: 2.1从python列表创建数组: #创建一维数组: l = np.array([1,2,3,4],dtype = 'float') #输出l: array([1., 2., 3., 4.]) #创建二维数组: l = np.array([range(i, i+3) for i in [2,4,6]]) #...
  • python——numpy数据库
  • python中numpy创建数组

    千次阅读 2022-04-11 14:29:08
    import numpy as np #自定义数据类型 dt = np.dtype([('name','S20'),('age','i1'),('score','f4')]) #自定义数组 u=np.array([('abc',12,88),('...#创建数组 e=np.empty([3,4],dtype=int,order='C') print(e) .
  • 使用Numpy创建数组_总结

    千次阅读 2020-04-14 15:27:09
    有时候在做tensorflow搭建模块时经常会出现特别低级的数组构建错误,而且错误形式千奇百怪,今天终于决定系统地重写认识一下如何使用NumPy创建数组。 查询了很多文章和书籍,把查阅到的所有创建方式做一个总结,以便...
  • NumPy的Ndarray对象: N维数组对象ndarray,它是一系列同类型数据...创建一维数组 1、 直接传入列表的方式 t1=np.array([1,2,3]) print(t1) print(type(t1)) 2、传入range生成序列 t2=np.array(range(10)) print(t...
  • 1、numpy创建一维数组 [ 1] 通过列表生成数组 import numpy as np data1=[5,7,9,20]#列表类型 list arr1=np.array(data1) #ndarray数组类型 numpy.ndarray print(data1) print(type(data1)) #type输出数据类型 #...
  • NumPy创建数组

    千次阅读 2022-05-18 21:33:48
    NumPy创建数组 一、常见创建 numpy.empty numpy.empty 方法用来创建一个指定形状(shape)、数据类型(dtype)且未初始化的数组: numpy.empty(shape, dtype = float, order = 'C') 数组元素为随机值。 numpy.zeros...
  • Python NumPy 创建数组(ndarray)

    千次阅读 2020-12-05 05:04:05
    1、创建一个NumPy ndarray对象NumPy用于处理数组NumPy中的数组对象称为ndarray。我们可以使用array()函数创建一个NumPyndarray对象。例如:import numpy as nparr = np.array([1, 2, 3, 4, 5])print(arr)print...
  • Numpy 创建数组的几种方式

    千次阅读 2019-01-01 14:48:39
    Numpy 数组转换成 Python 列表的函数 copy 复制 Numpy 数组元素的函数 ones,zeros 创建用 0 或者 1填充的数组的函数 zeros_like,ones_like 该函数用来创建与作为参数的列表形状相同的二维数组 fill...
  • (从python的基础数据对象转化)通过先创建一个...(通过Numpy内生的函数生成)numpy也提供专门创建数组的函数 (2)numpy.arange(开始值,终值,步长),不包含终值 (3)numpy.linspace(开始值,终值,元素个数),包含...
  • Numpy最重要的一个特点是N维数组对象 - ndarray。维数在Numpy中成为秩(rank),...创建ndarray创建ndarray有两种方式:使用普通的array列表使用Numpy的内置函数方法一:使用array创建数组注:ndarray中所有的元素必须...
  • NumPy 创建数组

    2018-11-14 15:56:10
    NumPy 创建数组 ndarray 数组除了可以使用底层 ndarray 构造器来创建外,也可以通过以下几种方式来创建。 numpy.empty numpy.empty 方法用来创建一个指定形状(shape)、数据类型(dtype)且未初始化的数组: ...
  • ndarray 数组除了可以使用底层 numpy.array 构造器来创建外,也可以通过以下几种方式来创建numpy.emptynumpy.empty 方法用来创建一个指定形状(shape)、数据类型(dtype)且未初始化的数组:语法参数shape:数组...
  • Numpy 创建数组

    千次阅读 2017-03-02 07:49:18
     ①ndarray,一个具有矢量算术运算和复杂广播能力的快速且节省空间的多维数组。  ②用于对整组数据进行快速运算的标准数学函数(无需编写循环)。  ③用于读写磁盘数据的工具以及用于操作内存映射文件的工具。 ...
  • python3库numpy创建数组的方式

    千次阅读 2018-03-09 08:55:51
    版权声明:转载请注明原作者及出处import numpy as np ...#0-创建数组 zero = np.zeros((4,4)) one1 = np.ones((3,3)) one2 = np.ones((2,2)) one2.fill(2333) print(zero) print(one1) print(one2...
  • NumPy创建数组 ndarray数组除了可以使用底层ndarray构造器来创建外,也可以通过以下几种方式来创建。 numpy.empty numpy.empty 方法用来创建一个指定形状(shape)、数据类型(dtype)且未初始化的数组: numpy....
  • 一、numpy创建数组的几种主要方法 1、array()函数-自由创建+reshape()方法 #可通过列表如[1,2,3,4],元组如(1,2,3,4)创建 import numpy as np # 一维 x=np.array([1,2,3,4]) # 二维 y=np.array([1,2,3,4])....
  • 主要介绍了Python使用numpy模块创建数组操作,结合实例形式分析了Python使用numpy模块实现数组的创建、赋值、修改、打印等相关操作技巧与注意事项,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 70,213
精华内容 28,085
关键字:

numpy创建数组

友情链接: grbl_v0_9j.zip