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数组

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：起始值为base^start
• stop：终止值base^stop
• 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.]

创建数组

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

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])

2. 内置的 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.array 和 numpy.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)