创建numpy.array，是使用numpy这个核武器的基础，本文尽量汇总常用创建numpy.array的方法。

array函数

>>> import numpy as np

>>> a = np.array([1,2,3,4,5])

>>> a

array([1, 2, 3, 4, 5])

>>> a.shape

(5,)

>>> a.ndim

1

>>> a.dtype

dtype('int32')

>>>

>>> b = np.array((1,2,3,4,5.0))

>>> b

array([1., 2., 3., 4., 5.])

>>> b.shape

(5,)

>>> b.ndim

1

>>> b.dtype

dtype('float64')

a用list创建，b用tuple创建，都一样。注意创建b时，tuple中有一个float，这时numpy将所有数据都转换成了它自己的float64类型。numpy.array中不允许有不同类型的数据同时存在。

我们还可以通过array函数创建多维数组：

>>> c = np.array(([1,2,3],[4,5,6],[7,8,9]))

>>> c

array([[1, 2, 3],

[4, 5, 6],

[7, 8, 9]])

>>> c.shape

(3, 3)

>>> c.ndim

2

>>>

>>> d = np.array([[1,2,3],[4,5,6],[7,8,9.0]])

>>> d.dtype

dtype('float64')

>>> d

array([[1., 2., 3.],

[4., 5., 6.],

[7., 8., 9.]])

创建array时，可以指定dtype：

>>> e = np.array((1,2,3), dtype=np.int64)

>>> e

array([1, 2, 3], dtype=int64)

>>>

>>> f = np.array((1,2,3), dtype=np.float16)

>>> f

array([1., 2., 3.], dtype=float16)

zeros函数

用zeros函数创建全0的array：

>>> a = np.zeros((2,3))

>>> a

array([[0., 0., 0.],

[0., 0., 0.]])

>>>

>>> b = np.zeros((3,5), dtype=np.int8)

>>> b

array([[0, 0, 0, 0, 0],

[0, 0, 0, 0, 0],

[0, 0, 0, 0, 0]], dtype=int8)

zeros_like函数

创建一个全0的，跟输入的array的shape一样的：

>>> a = np.array([[1,2,3],[4,5,6]])

>>> a

array([[1, 2, 3],

[4, 5, 6]])

>>> b = np.zeros_like(a)

>>> b

array([[0, 0, 0],

[0, 0, 0]])

>>> a.shape

(2, 3)

>>> b.shape

(2, 3)

>>> c = np.zeros_like(a, dtype=np.uint8)

>>> c

array([[0, 0, 0],

[0, 0, 0]], dtype=uint8)

>>> c.shape

(2, 3)

ones函数

跟zeros函数一样，创建全1的numpy.array，代码略。

ones_like函数

跟zeros_like函数一样，全1而已，注意这些函数都可以指定dtype。

empty函数

跟zeros和ones一样，不一样的地方在于，empty函数不对数据做初始化，即所有的内部数据都是随机的，看内存什么样子。有的时候使用empty函数，不做初始化，还可以进一步提高计算速度。

>>> a = np.empty((5,5))

>>> a

array([[0.00000000e+000, 2.30226697e-307, 2.30240278e-307,

2.30259291e-307, 2.30275588e-307],

[2.13425923e-307, 2.13439504e-307, 2.13453085e-307,

2.13473456e-307, 2.13493827e-307],

[2.13504692e-307, 2.13527779e-307, 2.13554940e-307,

2.13572595e-307, 2.13591609e-307],

[2.51437149e-307, 2.51456162e-307, 2.51476533e-307,

2.51500978e-307, 2.51517275e-307],

[2.51537647e-307, 2.51562092e-307, 2.51582463e-307,

2.51598760e-307, 2.28647257e-317]])

empty_like函数

跟其它*_like函数一样，也跟自己的empty一样，不做初始化。代码略。

arange函数

a range，一个范围，就像python内置的range一样：

>>> a = np.arange(10)

>>> a

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> b = np.arange(0,100,5)

>>> b

array([ 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80,

85, 90, 95])

>>> c = np.arange(20).reshape(5,4)

>>> c

array([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11],

[12, 13, 14, 15],

[16, 17, 18, 19]])

>>> c.shape

(5, 4)

>>>

>>> d = np.arange(0,1,0.01).reshape(10,10)

>>> d

array([[0. , 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09],

[0.1 , 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19],

[0.2 , 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29],

[0.3 , 0.31, 0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39],

[0.4 , 0.41, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49],

[0.5 , 0.51, 0.52, 0.53, 0.54, 0.55, 0.56, 0.57, 0.58, 0.59],

[0.6 , 0.61, 0.62, 0.63, 0.64, 0.65, 0.66, 0.67, 0.68, 0.69],

[0.7 , 0.71, 0.72, 0.73, 0.74, 0.75, 0.76, 0.77, 0.78, 0.79],

[0.8 , 0.81, 0.82, 0.83, 0.84, 0.85, 0.86, 0.87, 0.88, 0.89],

[0.9 , 0.91, 0.92, 0.93, 0.94, 0.95, 0.96, 0.97, 0.98, 0.99]])

跟python内置的range不一样的地方是，step可以是小数，不过一般不建议这样用，要产生均匀间隔的数据，建议使用下面这个函数：linspace

linspace函数

设置起点和终点，设置一共取多少个数：

>>> a = np.linspace(0,1,100).reshape(10,10)

>>> a

array([[0. , 0.01010101, 0.02020202, 0.03030303, 0.04040404,

0.05050505, 0.06060606, 0.07070707, 0.08080808, 0.09090909],

[0.1010101 , 0.11111111, 0.12121212, 0.13131313, 0.14141414,

0.15151515, 0.16161616, 0.17171717, 0.18181818, 0.19191919],

[0.2020202 , 0.21212121, 0.22222222, 0.23232323, 0.24242424,

0.25252525, 0.26262626, 0.27272727, 0.28282828, 0.29292929],

[0.3030303 , 0.31313131, 0.32323232, 0.33333333, 0.34343434,

0.35353535, 0.36363636, 0.37373737, 0.38383838, 0.39393939],

[0.4040404 , 0.41414141, 0.42424242, 0.43434343, 0.44444444,

0.45454545, 0.46464646, 0.47474747, 0.48484848, 0.49494949],

[0.50505051, 0.51515152, 0.52525253, 0.53535354, 0.54545455,

0.55555556, 0.56565657, 0.57575758, 0.58585859, 0.5959596 ],

[0.60606061, 0.61616162, 0.62626263, 0.63636364, 0.64646465,

0.65656566, 0.66666667, 0.67676768, 0.68686869, 0.6969697 ],

[0.70707071, 0.71717172, 0.72727273, 0.73737374, 0.74747475,

0.75757576, 0.76767677, 0.77777778, 0.78787879, 0.7979798 ],

[0.80808081, 0.81818182, 0.82828283, 0.83838384, 0.84848485,

0.85858586, 0.86868687, 0.87878788, 0.88888889, 0.8989899 ],

[0.90909091, 0.91919192, 0.92929293, 0.93939394, 0.94949495,

0.95959596, 0.96969697, 0.97979798, 0.98989899, 1. ]])

从0到1，100个数。

reshape函数

顾名思义吧，就是一个数组重新变换一下形状，变成多维的。上面的代码已经有很多地方在直接使用reshape函数了，请参考。

再给一个用reshape将一维转四维的示例：

>>> a = np.linspace(0,1,100).reshape(2,5,2,5)

>>> a

array([[[[0. , 0.01010101, 0.02020202, 0.03030303, 0.04040404],

[0.05050505, 0.06060606, 0.07070707, 0.08080808, 0.09090909]],

[[0.1010101 , 0.11111111, 0.12121212, 0.13131313, 0.14141414],

[0.15151515, 0.16161616, 0.17171717, 0.18181818, 0.19191919]],

[[0.2020202 , 0.21212121, 0.22222222, 0.23232323, 0.24242424],

[0.25252525, 0.26262626, 0.27272727, 0.28282828, 0.29292929]],

[[0.3030303 , 0.31313131, 0.32323232, 0.33333333, 0.34343434],

[0.35353535, 0.36363636, 0.37373737, 0.38383838, 0.39393939]],

[[0.4040404 , 0.41414141, 0.42424242, 0.43434343, 0.44444444],

[0.45454545, 0.46464646, 0.47474747, 0.48484848, 0.49494949]]],

[[[0.50505051, 0.51515152, 0.52525253, 0.53535354, 0.54545455],

[0.55555556, 0.56565657, 0.57575758, 0.58585859, 0.5959596 ]],

[[0.60606061, 0.61616162, 0.62626263, 0.63636364, 0.64646465],

[0.65656566, 0.66666667, 0.67676768, 0.68686869, 0.6969697 ]],

[[0.70707071, 0.71717172, 0.72727273, 0.73737374, 0.74747475],

[0.75757576, 0.76767677, 0.77777778, 0.78787879, 0.7979798 ]],

[[0.80808081, 0.81818182, 0.82828283, 0.83838384, 0.84848485],

[0.85858586, 0.86868687, 0.87878788, 0.88888889, 0.8989899 ]],

[[0.90909091, 0.91919192, 0.92929293, 0.93939394, 0.94949495],

[0.95959596, 0.96969697, 0.97979798, 0.98989899, 1. ]]]])

eye函数

eye函数应该是取I的谐音，用于创建单位矩阵(Identity matrix)：

>>> a = np.eye(5)

>>> a

array([[1., 0., 0., 0., 0.],

[0., 1., 0., 0., 0.],

[0., 0., 1., 0., 0.],

[0., 0., 0., 1., 0.],

[0., 0., 0., 0., 1.]])

>>>

>>> a = np.eye(7)

>>> a

array([[1., 0., 0., 0., 0., 0., 0.],

[0., 1., 0., 0., 0., 0., 0.],

[0., 0., 1., 0., 0., 0., 0.],

[0., 0., 0., 1., 0., 0., 0.],

[0., 0., 0., 0., 1., 0., 0.],

[0., 0., 0., 0., 0., 1., 0.],

[0., 0., 0., 0., 0., 0., 1.]])

>>>

>>> a = np.eye(7, dtype=np.uint8)

>>> a

array([[1, 0, 0, 0, 0, 0, 0],

[0, 1, 0, 0, 0, 0, 0],

[0, 0, 1, 0, 0, 0, 0],

[0, 0, 0, 1, 0, 0, 0],

[0, 0, 0, 0, 1, 0, 0],

[0, 0, 0, 0, 0, 1, 0],

[0, 0, 0, 0, 0, 0, 1]], dtype=uint8)

full函数

用同一个固定的数字来填满array中所有的空隙，zeros是用0填，ones是用1填，empty是不填，随机。

>>> a = np.full((3,4), 8)

>>> a

array([[8, 8, 8, 8],

[8, 8, 8, 8],

[8, 8, 8, 8]])

>>> a

array([[8, 8, 8, 8],

[8, 8, 8, 8],

[8, 8, 8, 8]])

>>>

>>> a = np.full((3,4), 8, dtype=np.float64)

>>> a

array([[8., 8., 8., 8.],

[8., 8., 8., 8.],

[8., 8., 8., 8.]])

>>> a = np.full((3,4,5), 8, dtype=np.float64)

>>> a

array([[[8., 8., 8., 8., 8.],

[8., 8., 8., 8., 8.],

[8., 8., 8., 8., 8.],

[8., 8., 8., 8., 8.]],

[[8., 8., 8., 8., 8.],

[8., 8., 8., 8., 8.],

[8., 8., 8., 8., 8.],

[8., 8., 8., 8., 8.]],

[[8., 8., 8., 8., 8.],

[8., 8., 8., 8., 8.],

[8., 8., 8., 8., 8.],

[8., 8., 8., 8., 8.]]])

-- EOF --