numpy(1)：创建数组的方法总结

1. Numpy简介

Numpy是Numerical Python的简称，它是目前Python数值计算中最为重要的基础包。大多数计算包都提供了基于Numpy的科学函数功能，将Numpy的数组对象作为数据交换的通用语。

Numpy之所以能够流行，其中一个原因就是它的设计对于含有大量数组的数据非常有效。Numpy在内部将数据存储在连续的内存块上，这与其他的Python内键数据结构是不同的，也使得Numpy运行效率更高，占用的内存更少。而且Numpy可以针对全量数组进行复杂计算而不需要写Python循环。

 

2. 使用Numpy创建数组

在实际开发过程中，经常需要使用numpy创建数组而且目标数组的实际需求还不尽相同，对于这一块不熟悉的我总是在此时就需要百度或者回看之前写好的代码，感觉效率十分低下，故在此根据以往的经验总结一下各种数组的创建方式。

 

本文中的例子基于numpy1.19版本

 

1. 创建空数组

empty()函数

创建空数组最常用的方法是empty()，该方法返回一个未初始化的数组，虽然名称是empty，但实际上如果分配的内存空间不是空的，那么得到的array其实也不是空的，它只是不会对分配的空间做任何初始化动作，即保留了内存中原有的内容。

 

定义

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

• shape：用于指定数组维度，数据类型是int或tuple，如2或者(2, 3)
• dtype: 用于表示数组中元素的数据类型，默认是float
• order: 表示数组中元素的存储方式，有'C'和'F'两个取值，
• C表示以C-type方式存储，即行优先；F表示以Fortran-type方式存储，即列优先。

 

返回值

返回一个指定参数未初始化的数组对象。

 

示例

arr = np.empty((2, 3))

[[6.23042070e-307 1.42417221e-306 9.34603000e-307] [3.22651328e-307 1.24610994e-306 1.44083514e-311]]

 

empty_like()函数

这个方法返回一个与给定数组类型和维度等参数相同的新数组，新数组的元素同样是未初始化的。

 

定义

numpy.empty_like(prototype, dtype=None, order='K', subok=True, shape=None)

• prototype: 数组对象，返回的新数组的形状和类型与它相同
• dtype: 数组中元素的数据类型，默认是None
• order: 数组元素的内存布局，可选的值为：'C', 'F', 'A', 'K'；
  • C表示C-type方式，
  • K表示尽可能匹配prototype的布局
  • A表示如果prototype是F则为F，否则为C
  • F表示Fortran-type，
• subok: bool型参数，如果为True，则新创建的数组将使用子类类型“ a”，否则它将是基类数组。默认为True。
• shape: 覆盖prototype的shape。如果order ='K'并且尺寸数量不变，则将尝试保持顺序，否则order ='C'。默认为None

 

示例

arr = np.empty((2, 3))
arr2 = np.empty_like(arr)

 

2. 创建填充固定值的数组

numpy支持在创建数组时将数组元素初始化固定的内容，相当于C语言memset。

 

zeros()函数

numpy.zeros()返回一个所有元素都为0的数组。

 

定义

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

• shape, dtype, order同empty()

 

zeros_like()函数

类似于empty_like()，返回一个与指定数组形状、类型相同的，但是元素初始化为0的数组

 

ones()函数

numpy.ones()返回一个所有元素都初始化为1的数组。

 

定义

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

 

full()函数

numpy.full()返回一个所有元素都初始化为指定值的数组。

 

定义

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

• fill_value: 初始化值

 

同理，ones_like(), full_like()类似。

 

3. 生成随机数数组

生成随机数数组是我在实际开发过程中使用频率最高的数组，与上面创建空数组直接使用numpy的方法不同，随机数主要使用numpy.random类下的方法。

 

numpy.random部分函数列表如下：

函数	描述
seed	向随机数生成器传递随机状态种子
RandomState	创建一个随机数生成器
random	随机从[0,1)分布中抽取样本
permutation	返回一个序列的随机排列，或者返回一个乱序的整数范围序列
shuffle	随机排列一个序列
rand	从[0,1)中随机抽取样本
randint	根据给定的由低到高的范围抽取随机整数
randn	从均值0方差1的正态分布中抽取样本
binomial	从二项分布中抽取样本
normal	从正态（高斯）分布中抽取样本
beta	从beta分布中抽取样本
chisquare	从卡方分布中抽取样本
gamma	从伽玛分布中抽取样本
uniform	从均匀[0,1)分布中抽取样本

 

seed()函数

numpy.random使用具有确定性行为的算法根据随机数生成器中的随机数种子生成随机数，故其生成的是伪随机数。为了在不同运行时生成不同随机数，可以通过np.random.seed()更改numpy的随机数种子。

 

定义

numpy.random.seed(self, seed=None)

• seed: 随机数种子的值

注：numpy.random使用一个全局随机数种子，即此使用此函数修改种子后，程序的所有random函数都由该种子生成。

 

RandomState()函数

此函数会创建一个随机数生成器，且独立于其他的随机数状态。

 

定义

class numpy.random.RandomState(seed=None)

• seed: 随机数种子，不同于seed()函数，此处seed只对RandomState()函数有效。

 

示例

iter = np.random.RandomState(3456)
iter.random(10)

array([0.64317051, 0.46296798, 0.0626953 , 0.87496673, 0.97749171,
       0.82488721, 0.11339586, 0.3087274 , 0.27506891, 0.21442521])

 

random()函数

随机从[0,1)分布中抽取样本

 

定义

numpy.random.random(size=None)

• size: 表示数组元素的个数或形状，可以是整形数据也可以是元组。

 

示例

arr1 = np.random.random(5)
arr2 = np.random.random((2,3))
arr3 = np.random.random((4,5,6))

 

permutation()函数

随机排列序列，或返回排列范围。

定义

numpy.random.permutation(x)

• x: 可以是整型也可以是数组。如果是int型数据，表示随机序列的范围；如果是数组，则是对该数组的元素进行乱序排列。

 

示例

>>> np.random.permutation(10)
array([3, 1, 6, 0, 7, 4, 5, 9, 2, 8])

>>> np.random.permutation([1.5, 2.6, 2.1, 4.6, 9.8, 7.5, 0, 9, 11])
array([11. ,  7.5,  2.6,  9. ,  0. ,  2.1,  1.5,  9.8,  4.6])

 

shuffle()函数

根据给定的数组或列表，重新排列元素。类似于permutation()函数中x是数组的情况。

注意这个函数不会返回新对象，而是对参数数组本身进行重排。

 

定义

numpy.random.shuffle(x)

• x: 重排的数组或列表

 

示例

>>> a = [1,2,3,4,5,6,7,8,9]
>>> arr = np.random.shuffle(a)
>>> arr
>>> a
[3, 9, 6, 8, 2, 7, 4, 1, 5]

 

rand()函数

从[0，1)中随机抽取指定个数的样本，与random()类似，不同之处在于，数组的每个维度大小都作为单个参数，而random()是以元组形式给出。

 

定义

numpy.random.rand(d0, d1, ..., dn)

• d0, d1, ... dn：表示数组的维度，如果为空，则返回一个样本。

 

示例

>>> np.random.rand()
0.026236009125877313

>>> np.random.rand(2,5)
array([[0.93694736, 0.4317506 , 0.51333133, 0.53853345, 0.08853337],
       [0.60811337, 0.15272295, 0.0965382 , 0.42666303, 0.73880541]])

 

randint()函数

此函数从给定的范围[low, high)或者[0, low)中随机生成指定元素个数的数组，数组中元素的类型为整型。

 

定义

numpy.random.randint(low, high=None, size=None, dtype=int)

• low:可以是int型或者可以转换为int型的类型，也可以是数组。当low为int型数据时， 如果high被指定，则low表示元素值的下限；   如果high为None,则low表示上限，即从[0,low)中取值。当low为数组时，则会生成一个与给定数组元素个数相同的数组，新数组中每个元素的范围均遵循对应元素的规则；
• high: 可以为int型，也可以是数组。如果指定，则该值必须大于low；如果是数组，则该数组大小与low相同，且每个元素均大于low中对应元素，默认为None；
• size: 数组大小或形状，可以是int型也可以是元组。当low和high是数组时，size要么与该数组保持一致，要么为None,默认为None；
• dtype:元素数据类型，可用值只有int相关类型，如int8/16/32/64和uint8/16/32/64

 

示例

>>> np.random.randint(2, 6, 8)
array([3, 4, 2, 4, 3, 5, 2, 4])

>>> np.random.randint([2,5, 1], [3,6,6])
array([2, 5, 1])

 

randn()函数

此函数从标准正态分布中返回一个或多个样本。

 

定义

numpy.random.randn(d0, d1, ..., dn)

d0, d1, ... dn：表示数组的维度，如果为空，则返回一个样本。

 

示例

>>> np.random.randn()
0.6358534629626217

>>> np.random.randn(2, 5)
array([[-1.0059359 ,  0.02242329,  1.37900107,  1.05563345,  0.44669075],
       [ 1.69313515, -1.11041318,  1.13208661,  0.31018443,  2.16582224]])

 

binomial()函数

从具有指定参数，n个试验和p个成功概率的二项式分布中抽取样本。

定义

numpy.random.binomial(n, p, size=None)

• n: 实验次数，int型或者可转换为int的类型，也可以是数组类型。
• p: 概率值（0<= p <= 1），浮点型数据数组
• size: 元素个数或形状，int型或者元组。如果n和p是数组，则size可以为None，或者与原数组形状相同。

 

示例

>>> np.random.binomial(6, 0.5, size=(3,5))
array([[2, 3, 4, 2, 4],
       [3, 3, 2, 3, 3],
       [3, 2, 2, 2, 4]])

>>> np.random.binomial([5,3,4], [0.2,0.9,0.5])
array([0, 3, 4])

 

normal()函数

从正态（高斯）分布中抽取样本

定义

numpy.random.normal(loc=0.0, scale=1.0, size=None)

• loc: 分布的中心值，float或float数组
• scale: 分布的标准偏差，必须大于0
• size: 数组大小或形状，int或元组

 

示例

>>> np.random.normal(0, 1.0, 5)
array([ 0.51698752, -0.14418676,  0.76859391, -1.58793346, -0.8634437 ])

>>> np.random.normal([2,3,4], [1.0,4,2])
array([0.33934416, 1.1648542 , 4.22208145])

 

beta()函数

从Beta分布中抽取样本。具体Beta分布是什么在此不表。

 

定义

numpy.random.beta(a, b, size=None)

• a: float型数据或数组
• b: float型数据或数组
• size: 数组大小或形状，int或元组

 

示例

>>> np.random.beta(0.2, 0.5, 5)
array([1.68633760e-01, 2.50448910e-01, 9.99691548e-01, 8.15323858e-05,
       1.02785557e-01])

 

chisquare()函数

从卡方分布中抽取样本.

 

定义

numpy.random.chisquare(df, size=None)

• df: float型数据或数组
• size: 数组大小或形状，int或元组

 

gamma()函数

从伽玛分布中抽取样本。

 

定义

numpy.random.gamma(shape, scale=1.0, size=None)

• shape: float型数据或数组，必须大于0
• scale: float型数据或数组，必须大于0，默认为1.0
• size: 数组大小或形状，int或元组

 

uniform()函数

从均匀[0,1)分布中抽取样本

 

定义

numpy.random.uniform(low=0.0, high=1.0, size=None)

• low: 分布下限，float型数据或数组
• high: 分布上限，必须大于low，float型数据或数组
• size: 数组大小或形状，int或元组

 

4. 生成排序好的数组

arange()函数

返回给定间隔内的均匀间隔的值。

在半开间隔[开始，停止)的间隔内生成值。对于整数参数，该函数等效于Python内置的range函数，但返回ndarray而不是列表。

 

定义

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

• start: 起始位置，可选，默认是0
• stop: 停止位
• step: 步长，即每个元素取值的间隔
• dtype: 数据类型

 

注：[start, stop)应该是int型数据，如果是float，可能得不到预期的结果。

示例

>>> np.arange(2, 6)
array([2, 3, 4, 5])

>>> np.arange(2.1, 6.6)
array([2.1, 3.1, 4.1, 5.1, 6.1])

 

linspace()函数

arange()函数只适用于整数的情况，对于浮点型numpy提供了linspace()函数。此函数返回指定间隔内的等间隔数字。返回以间隔[开始，停止]计算的num个均匀间隔的样本。间隔的端点可以选择排除。

 

定义

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

• start: 数组类型，序列的起始值
• stop: 数组类型，序列的结束值
• num: int型，样本个数，默认是50
• endpoint: bool型，如果为True，则序列中包含stop值，否则不包含该值。
• restep: bool型，如果为True，则返回(样本，步长)
• dtype:数据类型，如果有给出数据类型，则从其他输入参数推断。
• axis: 结果中的轴用于存储样本。仅当start或stop类似于数组时才相关。默认情况下（0），样本将沿着在开始处插入的新轴。使用-1来获得轴的末端。

 

示例

>>> np.linspace(0,5,5)
array([0.  , 1.25, 2.5 , 3.75, 5.  ])

>>> np.linspace(0,4,5,retstep=True)
(array([0., 1., 2., 3., 4.]), 1.0)

5. 从已有对象中生成数组

array()函数

将输入数据（可以是列表、元组、数组以及其他序列）转换为ndarray，如不显式指明数据类型，将自动推断；默认复制所有的输入数据。

 

定义

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

• object: 数组或元组等原始对象
• dtype:数据类型，如果为None，则自动推断为则将类型确定为在序列中保存对象所需的最小类型
• copy: 是否复制对象，默认为True，如果为False，则返回一个原对象的副本。
• order: 指定阵列的内存布局。其取值与copy相匹配：

order	no copy	copy=True
‘K’	unchanged	F & C order preserved, otherwise most similar order
‘A’	unchanged	F order if input is F and not C, otherwise C order
‘C’	C order	C order
‘F’	F order	F order

• subok: 如果为True，则将传递子类，否则，返回的数组将被强制为基类数组。默认为False
• ndmin: 指定结果数组应具有的最小维数。
•  

示例

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

 

asarray()函数

将输入转换为ndarray，但如果输入已经是ndarray则不再复制。

 

定义

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

• a: 输入数据，必须是可以转换为数组的类型，如列表、元组等；
• dtype:数组数据类型
• order: 可选为{'C', 'F'}，默认是'C'

 

示例

>>> a = [1, 2]
>>> np.asarray(a)
array([1, 2])

>>> a = np.array([1, 2])
>>> np.asarray(a) is a
True

 

asanyarray()函数

与asarray()函数类似，但不同点在于此函数会传递子类。

 

定义

numpy.asanyarray(a, dtype=None, order=None)

参数同asarray()

 

ascontiguousarray()函数

以C-type风格返回内存中连续的数组空间

 

定义

numpy.ascontiguousarray(a, dtype=None)

• a: 数组或可转换为数组类型的对象

 

示例

>>> x = np.arange(6).reshape(2,3)
>>> np.ascontiguousarray(x, dtype=np.float32)
array([[0., 1., 2.],
       [3., 4., 5.]], dtype=float32)
>>> x.flags['C_CONTIGUOUS']
True

 

6. 根据文件生成数组

在实际开发过程中，有时为了方便，有时因为实际数据来自于其他业务的采集信息，往往会将数据保存在文件中，这时在代码中就会需要从文件中读取内容生成数组。

常用操作比如：fomfile(), load(), loadtxt()等。

后续统一说明。

 

3. 相关内容

1. NumPy数据类型

numpy的数据类型即是上述方法参数中的'dtype'，它是一个特殊的对象，包含了数组需要为某一种类型数据所申明的内存块信息。有了它，是的numpy能和其他语言的数据类型进行兼容，如C语言和Fortran语言等。

 

Numpy的数据类型如下：

类型	类型代码	描述
int8, uint8	i1, u1	有符号和无符号的8位整数
int16, uint16	i2, u2	有符号和无符号的16位整数
int32, uint32	i4, u4	有符号和无符号的32位整数
int64, uint64	i8, u8	有符号和无符号的64位整数
float16	f2	半精度浮点数
float, float32	f4或f	单精度浮点数；兼容C语言float
float64	f8或d	双精度浮点数；兼容C语言double和Python float
float128	f16或g	拓展精度浮点数
complex64/128/264	c8, c6, c32	基于32/64/128位浮点数的复数
bool	?	布尔型
object	o	Python object类型
string_	S	修正的ASCII字符串类型
unicode_	U	修正的Unicode类型

 

使用时可以作为字符串使用也可以作为numpy的关键字使用，如：

dtype='float64' 
dtype=np.float64