Numpy深度学习【001】：数组创建

---

1. 创建简单数组

1.1 方法定义

numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
numpy.empty(shape, dtype=float, order='C')
numpy.zeros(shape, dtype=float, order='C')
numpy.ones(shape, dtype=float, order='C')
numpy.eye(N, M=None, k=0, dtype=float, order='C')

1.2 应用示例

>>> import numpy as np   
>>> np.array([[1,2,3],[4,5,6]])                # 创建常规数组，默认元素类型为int32

array([[1, 2, 3],
       [4, 5, 6]])
>>> np.array([[1,2,3],[4,5,6]], dtype=np.int8) # 创建常规数组，指定元素类型为int8

array([[1, 2, 3],
       [4, 5, 6]], dtype=int8)
       
>>> np.zeros((2,3))                            # 全0数组
array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.]])
       
>>> np.ones((2,3))                             # 全1数组
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])
       
>>> np.eye(3)                                  # 主对角线元素为1其他元素为0
array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]])
       

---

2. 创建随机数组

2.1 方法定义

numpy.random.rand(d0, d1, …, dn)   # 创建n维均匀分布的随机数组，取值范围[0,1)  
numpy.random.randn(d0, d1, …, dn)  # 创建n维均匀分布的随机数组，取值范围为标准正态分布
numpy.random.random(size=None)     # 在[0,1）内产生随机数，size：随机数的shape，可以为元祖或者列表，[2,3]表示2维随机数，维度为（2,3）。
numpy.random.randint(low, high=None, size=None, dtype='l') # 产生随机整数，low：最小值；high：最大值；size：数据个数。low不能缺省且大于0，high缺省时，范围为：（0， low）。
numpy.random.ranf([size]) # 在[0,1）内产生随机数，size：随机数的shape，可以为元组或者列表，[2,3]表示2维随机数，维度为（2,3）。
numpy.random.sample([size])
numpy.random.choice(a, size=None, replace=True, p=None) # 从a中随机选择指定数据，a：1维数组 size：返回数据形状。
numpy.random.bytes(length) # 返回随机位，length：位的长度。
numpy.random.random_integers(low, high=None, size=None)  # 生成一个整数或一个N维整数数组，取值范围：若high不为None，则取[low,high]之间随机整数，否则取[1,low]之间随机整数。

numpy.random.shuffle()  # 将数组中的元素打乱。
numpy.random.seed()     # 生成随机数种子

---

2.2 应用示例

>>> np.random.rand(2)     # 生成两个[0, 1]之间均匀分布的随机浮点数，构成一个shape=(1,2)的数组
array([0.12769855, 0.49978711])

>>> np.random.rand(3, 2)  # 生成两个[0, 1]之间的随机浮点数，构成一个shape=(3,2)的数组
array([[0.23253159, 0.18998376],
       [0.14354299, 0.34838597],
       [0.05232929, 0.73316462]])
       
>>> np.random.random(3)   # 生成两个[0, 1]之间的随机浮点数，构成一个shape=(1,3)的数组
array([0.29334156, 0.45858765, 0.99297047])

>>> np.random.random((2,3))   # 生成[0, 1)之间的随机浮点数，构成一个shape=(2,3)的数组【rand()的shape参数分开，random()的shape参数为一个整体】
array([[ 0.84731148,  0.8222318 ,  0.85799278],
       [ 0.59371558,  0.92330741,  0.04518351]])

>>> np.random.randn(2)   # 生成服从标准正态分布的随机数，构成一个shape=(1,2)的数组
array([ 0.96343691, -0.56618819])

>>> np.random.randn(2, 3)  # 生成服从标准正态分布的随机数，构成一个shape=(2,3)的数组
array([[ 0.83643246, -1.10141861,  0.95539116],
       [ 0.35640549, -0.47138391,  3.14138933]])

>>> np.random.randint(2, size=10)  # 生成[0, low)之间的随机整数，构成一个shape=(1,10)的数组
array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0])
       
>>> np.random.randint(0,10,(3,2)) # 生成[0,10)之间的随机整数，构成一个shape=(3,2)的数组【size可直接传参】
array([[2, 4],
       [8, 3],
       [8, 5]])
       
>>> np.random.ranf(2)   # 在[0,1）内产生随机数，构成一个shape=(1,2)的数组
array([0.70509621, 0.81761987])

>>> np.random.ranf((2, 3))    # 在[0,1）内产生随机数，构成一个shape=(2,3)的数组
array([[0.39512439, 0.94612533, 0.32707229],
       [0.16822838, 0.97932185, 0.58393311]])
       
>>> np.random.sample(2)   # 在[0,1）内产生随机数，构成一个shape=(1,2)的数组
array([0.05385311, 0.48871813])

>>> np.random.sample((2, 3))   # 在[0,1）内产生随机数，构成一个shape=(2,3)的数组
array([[0.24614041, 0.80696712, 0.10892324],
       [0.38084801, 0.43251784, 0.81110075]])

>>> a = [1, 2, 3, 4, 5]
>>> np.random.choice(a)  # 从列表a中选取1个元素
5

>>> np.random.choice(10, (2,3))  # 从[0,10)中选取元素，构成一个shape=(2,3)的数组
array([[2, 7, 6],
       [1, 7, 0]])

>>> np.random.bytes(5)  # 返回随机字节长度
b'\x0f\x85\x8d$\x98'

>>> rand_data = np.random.randint(1, 10, (3, 4))
print(rand_data)
>>> np.random.shuffle(rand_data)
print(rand_data)  
[[7 6 7 9]
 [7 4 3 2]
 [6 2 2 2]]
 
[[6 2 2 2]
 [7 4 3 2]
 [7 6 7 9]]
 # 按照行打乱了，也就是交换了行      

---

3. 在数值范围内创建数组

3.1 方法定义

numpy.arange(start, stop, step, dtype=None)
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)  # 在指定的间隔范围内返回均匀间隔的数字创建数组【num：返回个数，endpoint：若为True，则stop为最后一个样本，retstep：若为True，按照步长返回】
numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)  # 用于创建等比数列数组【base:幂底数】

3.2 应用示例

>>> np.arange(5)          # 在[0,4]之间取整数，步长为1，构成数组
array([0, 1, 2, 3, 4])

>>> np.arange(0,5,2)      # 在[0,4]之间取整数，步长为2，构成数组
array([0, 2, 4])

>>> np.linspace(0, 5, num=5)  # 在[0,4]之间从0开始取5个均匀间隔的样本元素，且5为最后一个元素，构成数组
array([0.  , 1.25, 2.5 , 3.75, 5.  ])

>>> np.linspace(0, 5, num=5, endpoint=False)  # 在[0,4]之间从0开始取5个均匀间隔的样本元素，构成数组
array([0., 1., 2., 3., 4.])

>>> np.linspace(0, 5, num=5, retstep=True)
(array([0.  , 1.25, 2.5 , 3.75, 5.  ]), 1.25)

>>> np.logspace(1,3, num=3)    # 在[10^1, 10^3]之间从10^1开始取3个等比的样本元素，且10^3为最后一个元素，构成数组
array([  10.,  100., 1000.])

>>> np.logspace(1, 3, num=3, endpoint=False) # 在[10^1, 10^3]之间从10^1开始取3个等比的样本元素，构成数组
array([ 10.        ,  46.41588834, 215.443469  ])

>>> np.logspace(0,9,num=10,base=2)   # 在[2^0, 10^3]之间从2^9开始取10个等比的样本元素，且2^9为最后一个元素，构成数组
array([   1.,    2.,    4.,    8.,   16.,   32.,   64.,  128.,  256.,  512.])

---

4. 从已有数组创建数组

4.1 方法定义

numpy.asarray(a, dtype=None, order=None) # a:可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组;dtype：数据类型;order：有"C"和"F"两个选项,分别代表行优先和列优先，在计算机内存中的存储元素的顺序。

numpy.empty_like(a, dtype=None, order='K', subok=True)
numpy.zeros_like(a, dtype=None, order='K', subok=True)
numpy.ones_like(a, dtype=None, order='K', subok=True)[source]

4.2 应用示例

>>> a = [1,2]  # 将列表转换为数组
>>> numpy.asarray(a)
array([1,2])

>>> a= [1,2]

>>> numpy.asarray(a,'f')  # 将数据类型转换为float,'f'表示为dtype类型为float
array([1.,2.], dtype=float32)

>>> numpy.asarray(a,'i')  # 将数据类型转换为int,'i'表示为dtype类型为int
array([1,2])

np.asarray()与 np.array ()的不同

np.asarray的定义：

def asarray(a, dtype=None, order=None):
    return array(a, dtype, copy=False, order=order)

而 np.array的定义：

def array(a, dtype=None, order=None):
    return array(a, dtype, copy=True, order=order)

简而言之：
主要区别在于 np.array（默认情况下）将会copy该对象，而 np.asarray除非必要，否则不会copy该对象。

>>> np.empty_like(np.asarray([1,2,3]))
array([0, 0, 0])

>>> np.zeros_like(np.asarray([1,2,3]))
array([0, 0, 0])

>>> np.ones_like(np.asarray([1,2,3]))
array([1, 1, 1])

---

5. 构造复杂数组

5.1 重复数组 tile

>>> a = np.arange(3)
>>> a
array([0, 1, 2])

>>> np.tile(a, 2)
array([0, 1, 2, 0, 1, 2])

>>> np.tile(a, (2,3))
array([[0, 1, 2, 0, 1, 2, 0, 1, 2],
       [0, 1, 2, 0, 1, 2, 0, 1, 2]])

5.2 重复元素 repeat

>>> a = np.arange(3)
>>> a
array([0, 1, 2])

>>> a.repeat(2)
array([0, 0, 1, 1, 2, 2])

5.3 一维数组网格化: meshgrid

>>> lon = np.arange(30, 120, 10)
>>> lon
array([ 30,  40,  50,  60,  70,  80,  90, 100, 110])

>>> lat = np.arange(10, 50, 10)
>>> lat
array([10, 20, 30, 40])

>>> lons, lats = np.meshgrid(lon, lat)

>>> lons
array([[ 30,  40,  50,  60,  70,  80,  90, 100, 110],
       [ 30,  40,  50,  60,  70,  80,  90, 100, 110],
       [ 30,  40,  50,  60,  70,  80,  90, 100, 110],
       [ 30,  40,  50,  60,  70,  80,  90, 100, 110]])

>>> lats
array([[10, 10, 10, 10, 10, 10, 10, 10, 10],
       [20, 20, 20, 20, 20, 20, 20, 20, 20],
       [30, 30, 30, 30, 30, 30, 30, 30, 30],
       [40, 40, 40, 40, 40, 40, 40, 40, 40]])

5.4 指定范围和分割方式的网格化: mgrid

>>> lats, lons= np.mgrid[10:50:10, 30:120:10]
>>> lats 
array([[10, 10, 10, 10, 10, 10, 10, 10, 10],
       [20, 20, 20, 20, 20, 20, 20, 20, 20],
       [30, 30, 30, 30, 30, 30, 30, 30, 30],
       [40, 40, 40, 40, 40, 40, 40, 40, 40]])

>>> lons
array([[ 30,  40,  50,  60,  70,  80,  90, 100, 110],
       [ 30,  40,  50,  60,  70,  80,  90, 100, 110],
       [ 30,  40,  50,  60,  70,  80,  90, 100, 110],
       [ 30,  40,  50,  60,  70,  80,  90, 100, 110]])

>>> lats, lons = np.mgrid[10:50:5j, 30:120:10j]

>>> lats
array([[10., 10., 10., 10., 10., 10., 10., 10., 10., 10.],
       [20., 20., 20., 20., 20., 20., 20., 20., 20., 20.],
       [30., 30., 30., 30., 30., 30., 30., 30., 30., 30.],
       [40., 40., 40., 40., 40., 40., 40., 40., 40., 40.],
       [50., 50., 50., 50., 50., 50., 50., 50., 50., 50.]])

>>> lons
array([[ 30.,  40.,  50.,  60.,  70.,  80.,  90., 100., 110., 120.],
       [ 30.,  40.,  50.,  60.,  70.,  80.,  90., 100., 110., 120.],
       [ 30.,  40.,  50.,  60.,  70.,  80.,  90., 100., 110., 120.],
       [ 30.,  40.,  50.,  60.,  70.,  80.,  90., 100., 110., 120.],
       [ 30.,  40.,  50.,  60.,  70.,  80.,  90., 100., 110., 120.]])

上面的例子中用到了虚数。构造复数的方法如下：

>>> complex(2,5)
(2+5j)