Numpy 模块常用方法汇总
随机数数组
原文出处https://www.kuxai.com/post/175
numpy数组是一个值网格，所有类型都相同，并由非负整数元组索引。 维数是数组的排名; 数组的形状是一个整数元组，给出了每个维度的数组大小。
我们可以从嵌套的Python列表初始化numpy数组，并使用方括号访问元素：
import torch
import tensorflow as tf
# 创建采样(2, 2)的标准正太分布的张量
a = torch.randn(2, 3)
# 创建采样自[0, 10)区间的(2, 2)均匀分布的张量
b = tf.random.uniform((2, 2), 0, 10)
print(a)
print(b)
tensor([[ 2.0729, -0.6350],
[-1.8206, -0.8142]])
tf.Tensor(
[[9.330468 6.0732355]
[6.65187 4.6297417]], shape=(2, 2), dtype=float32)
本文主要总结一些在Numpy中比较常用的产生随机数的函数，为了方便我将这些随机函数分成两个部分：
用于产生固定区间范围的随机数，称为基本随机数；
用于按照某些分布概率统计规则来产生的随机数，称为分布随机数；
基本随机数
random.rand(d0, d1, …, dn)
random.rand(d0, d1, …, dn)，产生[0, 1)范围的浮点随机数
rand函数用于产生[0, 1)范围内的浮点随机数，其中参数dn表示第n个维度的长度。
import numpy as np
# 产生shape为 (d0, d1,..., dn), 值为 [0, 1) 范围内的浮点随机数
# 默认d0 = 1, 产生[0, 1)范围内的一个浮点随机数
a = np.random.rand()
# d0 = 2, 产生[0, 1)范围内的一维数组（向量）的浮点随机数
b = np.random.rand(2)
# d0 = 2, d1 = 3, 产生[0, 1)范围内的二维数组（矩阵）的浮点随机数
c = np.random.rand(2,3)
print(a)
print(b)
print(c)
0.575695284381402
[0.50852146 0.17941441]
[[0.07689737 0.17578407 0.16941739]
[0.63075319 0.86015553 0.88239051]]
random.random_sample(size)
random.random_sample(size)，产生[0, 1)范围内的浮点随机数
random_sample函数用于产生[0, 1)范围的浮点随机数，其中参数size为产生数组的大小，如果不指定则会产生一个随机数。
这里需要注意：
rand和random_sample函数产生的都是[0, 1)范围内的浮点随机数，不过这两个函数的参数不同：
rand(d0, d1, …, dn)中的参数dn用于指定维度的长度；
random_sample(size)中的参数size为产生数组的大小；
ranf、random、sample、random_sample这些方法使用方式与实现的功能都是一样的，如果查看Numpy官方文档也可以发现这些函数的示例都是相同的；
import numpy as np
# 产生shape为size, 值为 [0, 1) 范围内的浮点随机数
# 不指定size参数, 产生[0, 1)范围内的浮点随机数
a = np.random.random_sample()
# 指定size参数,产生[0, 1)范围内的二维数组（矩阵）的浮点随机数
b = np.random.random_sample(size = (2, 3))
print(a)
print(b)
0.8369940955261025
[[0.12079451 0.65141355 0.91492699]
[0.07162246 0.24889967 0.56503944]]
random.randint(low, high = None, size = None)
random.randint(low, high = None, size = None)，产生[low, high)范围内的整型随机数
random.randint随机函数用于产生[low, high)范围的随机整数，需要注意范围是"包左不包右"，包含low但是不包含high。size为产生数组的大小。
import numpy as np
# 产生shape为size, 值为 [low, high) 范围内的整型随机数
# low = 0, high = 3, 产生[0, 3)范围内的一个整型随机数
a = np.random.randint(0, 3)
# low = 3, 产生[0, 3)范围内的一维数组（向量）的整型随机数
b = np.random.randint(3, size = 4)
# low = 0, high = 3, 产生[0, 3)范围内的二维数组（矩阵）的整型随机数
c = np.random.randint(0, 3, size = (2, 3))
print(a)
print(b)
print(c)
2
[0 2 1 1]
[[2 1 1]
[0 1 0]]
random.random_integers(low, high = None, size = None)
random.random_integers(low, high = None, size = None)，产生[low, high]范围内的整型随机数
random_integers函数和randint函数是对应的，主要区别就在于randint函数的范围为[low, high)即"包左不包右"，而random_integers函数的范围为[low, high]即"即包左又包右"。不过为了统一Numpy的接口，random_interger函数即将被摒弃，官方推荐使用randint函数来实现。如果想要将范围确定在[low, high]范围中，只需要将randint函数的size参数指定为(low, high + 1)。
小结
常用的分布随机数
random.randn(d0, d1, …, dn)
random.randn(d0, d1, …, dn)，产生标准正太分布（normal）分布的随机数
randn函数用于产生标准正太分布的随机数，其中参数dn表示第n个维度的长度。
import numpy as np
# 产生shape为 (d0, d1,..., dn)的标准正态分布
# 从标准正态部分中随机采样3个随机数
a = np.random.randn(3)
# 从标准正态分布中随机采样2 × 3个随机数，组成(2, 3)的二维数组（矩阵）
b = np.random.randn(2, 3)
print(a)
print(b)
[ 0.2203204 1.73158706 -0.78638403]
[[ 0.44799247 -0.37243396 -0.57481381]
[ 0.17644269 0.99336282 -0.55967673]]
random.normal(loc = 0.0, scale = 1.0, size = None)
random.normal(loc = 0.0, scale = 1.0, size = None)，产生正态分布随机数
normal函数产生正态分布的随机数，其中：
参数loc对应数学中的期望μ，μ是正态分布的位置参数，描述正态分布集中趋势位置，与μ邻近的概率值越大，而远离μ的概率值越小。正态分布以X = μ为对称轴，左右完全对称。正态分布的期望、均数、中位数、众数相同，均等于μ；
参数scale对应数学中的标准差σ，σ描述正态分布数据的离散程度，σ越大，数据的分布越分散，σ越小，数据分布越集中。σ也称为正态分布的形状参数，σ越大，曲线越扁平，反之，σ越小，曲线越高瘦；
参数size为产生数组的大小；
import numpy as np
# 产生shape为size的正态分布
mu, sigma = 0.1, 2.0
# 从μ = 0.1, σ = 2.0的正态部分中随机采样3个随机数
a = np.random.normal(mu, sigma, 3)
# 从μ = 0.1, σ = 2.0的正态部分中随机采样2 × 3个随机数，组成(2, 3)的二维数组（矩阵）
b = np.random.normal(mu, sigma, size = (2, 3))
print(a)
print(b)
[ 1.31578944 -1.16272895 2.50095739]
[[ 2.07134546 -0.62086584 -0.32091925]
[ 0.2286672 -1.13700916 0.09206429]]
这里需要注意，将normal函数的参数loc = 0, scale = 1.0，即μ = 0, σ = 1.0，期望为0方差为1的正态分布为标准正态分布，此时使用randn函数可以实现同样的效果。
random.uniform(low = 0.0, high = 1.0, size = None)
random.uniform(low = 0.0, high = 1.0, size = None)，产生均匀分布的随机数
uniform函数在指定[low, high)范围内产生均匀分布的随机数。
import numpy as np
# 产生shape为size范围在[low, high)内的均匀分布
# low = 3, 输出向量, shape = (4, )
a = np.random.uniform(3, size = 4)
# low = 0, high = 3, 输出为标量, shape = ()
b = np.random.uniform(0, 3)
# low = 0, high = 3, 输出为矩阵, shape = (2, 3)
c = np.random.uniform(0, 3, size = (2, 3))
print(a)
print(b)
print(c)
[2.65418547 1.65702115 2.42128949 2.74215319]
1.253105912177019
[[2.11947645 2.85662794 2.33596866]
[0.86552208 2.9166298 1.55980368]]
小结
分布的随机数有很多，不过在深度学习中最常用的就是正态分布和均匀分布了。
##
指定值范围数组
生成数组
| 参数 | 作用 |
|---|---|
| shape | 数组形状 |
| dtype | 数组类型,可选 |
| order | 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 |
空数组 np.empty
numpy.empty(shape, dtype = float, order = ‘C’)
x = np.empty([3,2], dtype = int)
print (x) # [[ 6917529027641081856 5764616291768666155]
# [ 6917529027641081859 -5764598754299804209]
# [ 4497473538 844429428932120]]
#数组元素为随机值，因为它们未初始化
值相同的数组np.zeros、np.ones、np.full
numpy.zeros(shape, dtype = float, order = ‘C’)
numpy.ones(shape, dtype = None, order = ‘C’)
a = np.zeros((2,2)) # Create an array of all zeros
print(a) # Prints "[[ 0. 0.]
# [ 0. 0.]]"
b = np.ones((1,2)) # Create an array of all ones
print(b) # Prints "[[ 1. 1.]]"
c = np.full((2,2), 7) # Create a constant array
print(c) # Prints "[[ 7. 7.]
# [ 7. 7.]]
单位矩阵np.eye
d = np.eye(2) # Create a 2x2 identity matrix
print(d) # Prints "[[ 1. 0.]
# [ 0. 1.]]"
#### 已有数值范围
##### 列表生成数组np.array()
```python
a = np.array([1, 2, 3])
b = np.array([[1,2,3],[4,5,6]])
等差数组np.arange
numpy.arange(start, stop, step, dtype)
import numpy as np
x = np.arange(10,20,2) # print [10 12 14 16 18]
np.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 时，生成的数组中会显示间距，反之不显示 |
| dtype | ndarray 的数据类型 |
# 以下实例用到三个参数，设置起始点为 1 ，终止点为 10，数列个数为 10。
import numpy as np
a = np.linspace(1,10,10)
# print [ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
# 设置元素全部是1的等差数列：
import numpy as np
a = np.linspace(1,1,10)
# print [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
#将 endpoint 设为 false，不包含终止值：
import numpy as np
a = np.linspace(10, 20, 5, endpoint = False)
# print [10. 12. 14. 16. 18.]
# 如果将 endpoint 设为 true，则会包含 20。
# 以下实例设置间距。
import numpy as np
a =np.linspace(1,10,10,retstep= True)
print
# 拓展例子
b =np.linspace(1,10,10).reshape([10,1])
# print
#(array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]), 1.0)
#[[ 1.]
# [ 2.]
# [ 3.]
# [ 4.]
# [ 5.]
# [ 6.]
# [ 7.]
# [ 8.]
# [ 9.]
# [10.]]
等比数组np.logspace
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
| 参数 | 描述 |
|---|---|
| start | 序列的起始值为：base ** start |
| stop | 序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中 |
| num | 要生成的等步长的样本数量，默认为50 |
| endpoint | 该值为 true 时，数列中中包含stop值，反之不包含，默认是True |
| base | 对数 log 的底数 |
| dtype | ndarray 的数据类型 |
import numpy as np
# 默认底数是 10
a = np.logspace(1.0, 2.0, num = 10)
# print
#[ 10. 12.91549665 16.68100537 21.5443469 27.82559402
# 35.93813664 46.41588834 59.94842503 77.42636827 100. ]
# 将对数的底数设置为 2 :
import numpy as np
a = np.logspace(0,9,10,base=2)
#print [ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]
从已有数组创建数组
从已有数组创建数组np.asarray
numpy.asarray(a, dtype = None, order = None)
# 将列表转换为 ndarray:
import numpy as np
x = [1,2,3]
a = np.asarray(x) # print [1 2 3]
#将元组转换为 ndarray:
import numpy as np
x = (1,2,3)
a = np.asarray(x) # print [1 2 3]
# 将元组列表转换为 ndarray:
import numpy as np
x = [(1,2,3),(4,5)]
a = np.asarray(x) # print [(1, 2, 3) (4, 5)]
将流转化为数组np.frombuffer
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
| 参数 | 描述 |
|---|---|
| buffer | 可以是任意对象，会以流的形式读入 |
| dtype | 返回数组的数据类型，可选 |
| count | 读取的数据数量，默认为-1，读取所有数据 |
| offset | 读取的起始位置，默认为0 |
import numpy as np
s = b'Hello World'
a = np.frombuffer(s, dtype = 'S1')
# print [b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']
从可迭代对象中建立 np.fromiter
numpy.fromiter(iterable, dtype, count=-1)
| 参数 | 描述 |
|---|---|
| iterable | 可迭代对象 |
| dtype | 返回数组的数据类型 |
| count | 读取的数据数量，默认为-1，读取所有数据 |
import numpy as np
# 使用 range 函数创建列表对象
list=range(5)
it=iter(list)
# 使用迭代器创建 ndarray
x=np.fromiter(it, dtype=float) # print [0. 1. 2. 3. 4.]
1542
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
