创建数组

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

numpy 中定义的原生数组创建函数
使用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])

注意

如果是浮点参数，那么输出数组的长度是 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])
内置的 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)

NumPy创建数组的几种方式介绍相关推荐

JS基础之数组--概述、创建数组的几种方式、数组的特点、数组的常用方法、数组的解构赋值、数组高级API
一.概述描述:数组(array)是按照一定顺序排列的一组值,每个值都拥有自己的编号,编号从0开始.整个数组用方括号来表示. 语法:var arr=[item1,item2,item3-] 1.1 注 ...
【JS】JavaScript中创建数组的6种方式（代码示例合集）
创建数组的6种方式 <!DOCTYPE html> <html lang="en"><head><meta charset="U ...
Java创建数组的几种方式
Java创建数组的几种方式 1.一维数组的声明方式: type[] arrayName; 或 type arrayName[]; 附:推荐使用第一种格式,因为第一种格式具有更好的可读性,表示type[ ...
java创建数组的方式_Java创建数组的几种方式总结
1.一维数组的声明方式: type[] arrayName; 或 type arrayName[]; 附:推荐使用第一种格式,因为第一种格式具有更好的可读性,表示type[]是一种引用类型(数组)而不 ...
java 创建数组的三种方式及区别
创建数组的三种方式:其实分为2类,一种是静态的创建,如方式一.一种是动态的创建,只不过根据写法的不同分为方式二和方式三: // 数组初始化的三种方式//1.声明,分配空间并赋值int[] arr0 = ...
javaScript中创建数组的3种方式
JS数组定义及详解 javascript如何定义数组? 直接上代码和截图 //javaScript中创建数组的3种方式 //方式1 var names = ["令狐冲", &quo ...
Java创建数组的三种方式（以及length方法是否能获取数组中元素的个数）
Java创建数组的三种方法 import java.util.Arrays; public class Sum { public static void main(String[] args){ in ...
java new数组_Java创建数组的几种方式
1.一维数组的声明方式: type[] arrayName; 或 type arrayName[]; 附:推荐使用第一种格式,因为第一种格式具有更好的可读性,表示type[]是一种引用类型(数组)而不 ...
【php复习之】php创建数组的几种方式
1.array()函数 1.1无key值 $arr=array(1,2,3,4); 1.2键值对 $arr=array( 'name'=>'myj', 'age'=>'18', 'phon ...

NumPy创建数组的几种方式介绍

创建数组

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

NumPy创建数组的几种方式介绍相关推荐

最新文章

热门文章

NumPy创建数组的几种方式介绍

创建数组

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

NumPy创建数组的几种方式介绍相关推荐

最新文章

热门文章

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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