NumPy创建数组

目录

• 1. NumPy创建数组
  • 1.1 numpy.empty
  • 1.2 numpy.zeros
  • 1.3 numpy.ones
  • 1.4 numpy.eye
• 2. NumPy从已有数组创建数组
  • 2.1 numpy.asarray
  • 2.2 numpy.frombuffer
  • 2.3 numpy.fromiter
• 3. NumPy从数值范围创建数组
  • 3.1 numpy.arange
  • 3.2 numpy.linspace
  • 3.3 numpy.logspace

1. NumPy创建数组

1.1 numpy.empty

创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组

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

'''
参数：
shape：数组形状
dtype：数据类型
order：有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。
'''

import numpy as np
np.empty([3, 2], dtype=int)
'''
array([[         0,          0],
       [         0, 1072693248],
       [         0, 1073741824]])
'''

注意 − 数组元素为随机值，因为它们未初始化。

1.2 numpy.zeros

创建指定形状的数组，数组元素以0来填充。

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

import numpy as np

# 默认为浮点型
np.zeros(5)

# 设置为整型
np.zeros((5,), dtype=np.int)

# 自定义类型
np.zeros((2, 2), dtype=[('x', 'i4'), ('y', 'i4')])

1.3 numpy.ones

创建指定形状的数组，数组元素以1来填充。

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

import numpy as np

# 默认为浮点型
np.ones(5)

# 自定义类型
np.ones((2, 2), dtype=int)

1.4 numpy.eye

根据指定形状创建单位矩阵。

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

'''
参数：
N：指定的行数。
M：指定的列数，如果为None，则等于N。
k：对角线的下标，默认为0表示的是主对角线，负数表示的是低对角，正数表示的是高对角。
'''

import numpy as np

np.eye(3)
'''
结果为：
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
'''

np.eye(3, 3, k=1)
'''
结果为：
array([[0., 1., 0.],
       [0., 0., 1.],
       [0., 0., 0.]])
'''

2. NumPy从已有数组创建数组

2.1 numpy.asarray

类似于numpy.array，但是只有三个参数

np.asarray(a, dtype=None, order=None)

# a：任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组

2.2 numpy.frombuffer

用于实现动态数组，接受buffer输入参数，以流的形式读入转化成ndarray对象。

np.frombuffer(buffer, dtype=float, count=-1, offset=0)

'''
参数：
buffer:可以是任意对象，会以流的形式读入。
count:读取的数据数量，默认为-1，读取所有数据。
offset:读取的起始位置，默认为0。
'''

import numpy as np

st = b'hello world'
np.frombuffer(s, dtype='S1')

# 结果为：array([b'H', b'e', b'l', b'l', b'o', b' ', b'W', b'o', b'r', b'l', b'd'])

2.3 numpy.fromiter

从可迭代对象中建立ndarray对象，并返回一维数组。

np.fromiter(iterable, dtype, count=-1)

'''
参数：
iterable：可迭代对象
count：读取的数据数量，默认为-1，读取所有数据
'''

import numpy as np

lst = range(5)
it = iter(lst)

# 使用迭代器创建ndarray对象
np.fromiter(it, dtype=float)

# 结果为：array([0., 1., 2., 3., 4.])

3. NumPy从数值范围创建数组

3.1 numpy.arange

使用arange函数创建数值范围并返回ndarray对象。

np.arange(start, stop, step, dtype)

'''
参数：
start：起始值，默认为0
stop：终止值，不包含
step：步长，默认为1
'''

import numpy as np

# 生成0-5的数组
np.arange(5)

# 返回类型为float
np.arange(5, dtype=float)

# 设置起始值，终止值，步长
np.arange(1, 10, 2)

3.2 numpy.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 时，生成的数组中会显示间距，反之不显示。
'''

import numpy as np

# 元素全是1的等差数列
np.linspace(1, 1, 10)	# array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

# 不包含终止值
np.linspace(10, 20, 5, endpoint=False)
# array([10., 12., 14., 16., 18., 20.])

# 设置间距
np.linspace(1, 10, 10, retstep=True)
# array([1., 2., 3., 4., 5., 6., 7., 8., 9., 10.], 1.0)

# 拓展
np.linspace(1,10,10).reshape([10,1])
'''
结果为：
array([[1.]
	   [2.]
	   [3.]
	   [4.]
	   [5.]
	   [6.]
	   [7.]
	   [8.]
	   [9.]
	   [10.]])
'''

3.3 numpy.logspace

创建一个等比数列

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

'''
参数：
base：对数log的底数
其他参数np.linspace()
'''

import numpy as np

# 默认以10为底数
np.logspace(1.0, 2.0, num=10)

'''
结果为：
array([10., 12.91549665, 16.68100537, 21.5443469, 27.82559402, 
       35.93813664, 46.41588834, 59.94842503, 77.42636827, 100.])
'''

# 设置以2为底数
np.logspace(0, 9, 10, base=2)
'''
结果为：
array([1., 2., 4., 8., 16., 32., 64., 128., 256., 512.])
'''