本文详细介绍了如何使用NumPy库创建各种类型的数组，包括简单数组、随机数组、数值范围内数组以及从已有数组创建新数组。还探讨了如tile、repeat、meshgrid和mgrid等高级构造复杂数组的方法，对于理解和操作NumPy数组非常有帮助。
文章目录
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)
扫一扫
2827
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
