- 最开始，我们先导入 numpy 库。
import numpy as np
一、随机函数
- NumPy 中也有自己的随机函数，包含在 random 模块中。它能产生特定分布的随机数，如正态分布等。
- 接下来介绍一些常用的随机数。
| 函数名 | 功能 | 参数使用(int a,b,c,d) |
|---|---|---|
| rand(int1,[int2,[int3,]]) | 生成(0,1)均匀分布随机数 | (a)，(a,b)，(a,b,c) |
| randn(int1,[int2,[int3,]]) | 生成标准正态分布随机数 | (a)，(a,b)，(a,b,c) |
| randint(low[,hight,size,dtype]) | 生成随机整数 | (a,b)，(a,b,c)，(a,b,(c,d)) |
| sample(size) | 生成[0,1)随机数 | (a)，((a,b))，((a,b,c)) |
1. numpy.random.rand(d0,d1,…,dn)
- rand 函数根据给定维度生成 [0,1) 之间的数据，包含 0，不包含 1。
- dn 表示每个维度。
- 返回值为指定维度的 array。
- 我们可以创建 4 行 2 列的随机数据。
np.random.rand(4,2)
#array([[0.02533197, 0.80477348],
# [0.85778508, 0.01261245],
# [0.04261013, 0.26928786],
# [0.81136377, 0.34618951]])
- 我们也可以创建 2 块 2 行 3 列的随机数据。
np.random.rand(2,2,3)
#array([[[0.01820147, 0.5591452 , 0.05975028],
# [0.09208771, 0.96067587, 0.87031724]],
#
# [[0.32644706, 0.9580549 , 0.94756885],
# [0.57613453, 0.59642938, 0.62449385]]])
2. numpy.random.randn(d0,d1,…,dn)
- randn 函数返回一个或一组样本，具有标准正态分布。
- dn 表示每个维度。
- 返回值为指定维度的 array。
- 标准正态分布又称为 u 分布，是以 0 为均值、以 1 为标准差的正态分布，记为 N(0,1)。
- 我们随机生成满足标准正态分布的 10 个数据，并使用 matplotlib 绘图工具将其绘制出来。
from matplotlib import pyplot as plt
a = np.random.randn(10)
print(a)
plt.hist(a)
#[ 0.42646668 -1.40306793 -0.05431918 0.03763756 1.7889215 0.25540288
# -1.60619811 -2.21199667 -0.92209721 0.47669523]
#(array([1., 1., 1., 1., 0., 2., 3., 0., 0., 1.]),
# array([-2.21199667, -1.81190485, -1.41181303, -1.01172122, -0.6116294 ,
# -0.21153758, 0.18855423, 0.58864605, 0.98873787, 1.38882969,
# 1.7889215 ]),
3. numpy.random.normal()
numpy.random.normal(loc=0.0, scale=1.0, size=None)
- numpy.random.normal 返回一个由 size 指定形状的数组，数组中的值服从 μ=loc,σ=scale 的正态分布。
4. numpy.random.randint()
numpy.random.randint(low, high=None, size=None, dtype=’l’)
- 返回随机整数，范围区间为 [low,high），包含 low，不包含 high。
- 其参数含义为，low 表示最小值，high 表示最大值，size 表示数组维度大小，dtype 表示数据类型，默认的数据类型是 np.int。
- 当 high 没有填写时，默认生成随机数的范围是 [0，low)。
- 例如，我们可以返回 [0,1) 之间的整数，所以只有 0，由于默认数据类型是 int，因此，我们不需要填写数据类型参数。
np.random.randint(1,size=5)
#array([0, 0, 0, 0, 0])
- 同理，我们也可以返回 [2,10) 之间的整数。
np.random.randint(2,10,size=5)
#array([7, 6, 7, 8, 3])
- 我们可以在返回 [2,10) 之间整数的基础上，将返回的维度设置为二维。
np.random.randint(2,10,size=(2,5))
#array([[7, 7, 2, 7, 4],
# [5, 8, 6, 9, 7]])
- 当我们不设置维度参数时，就是默认返回一行一列。例如，我们返回 1 个 [1,5) 之间的随机整数。
np.random.randint(1,5)
#2
- np.random.randint 随机函数对负数也同样生效。例如，我们返回 -5 到 5 之间不包含 5 的 2 行 2 列数据。
np.random.randint(-5,5,size=(2,2))
#array([[-4, -5],
# [ 1, 3]])
5. numpy.random.sample
numpy.random.sample(size=None)
- 返回半开区间内的随机浮点数 [0.0,1.0]。
np.random.sample((2,3))
np.random.sample((2,2,3))
#array([[[0.7686855 , 0.70071112, 0.24265062],
# [0.63907407, 0.76102216, 0.66424632]],
#
# [[0.40679315, 0.73614372, 0.64102261],
# [0.97843216, 0.52552309, 0.44970841]]])
Type Markdown and LaTeX: α2
6. 随机种子np.random.seed()
- 使用相同的 seed() 值，则每次生成的随机数都相同，使得随机数可以预测。
- 但是，只在调用的时候 seed() 一下子并不能使生成的随机数相同，需要每次都调用一下 seed()，表示种子相同，从而生成的随机数相同。
- 如下例子，当我们设置两个随机数种子，就会返回两个不一样的数组。
np.random.seed(2)
L1 = np.random.randn(3, 3)
L2 = np.random.randn(3, 3)
print(L1)
print("-"*10)
print(L2)
#[[-0.41675785 -0.05626683 -2.1361961 ]
# [ 1.64027081 -1.79343559 -0.84174737]
# [ 0.50288142 -1.24528809 -1.05795222]]
----------
#[[-0.90900761 0.55145404 2.29220801]
# [ 0.04153939 -1.11792545 0.53905832]
# [-0.5961597 -0.0191305 1.17500122]]
- 但是，当我们只生产一个随机数种子时，那么，返回的两个数组就会产生一模一样的数据。
np.random.seed(1)
L1 = np.random.randn(3, 3)
np.random.seed(1)
L2 = np.random.randn(3, 3)
print(L1)
print("-"*10)
print(L2)
#[[ 1.62434536 -0.61175641 -0.52817175]
# [-1.07296862 0.86540763 -2.3015387 ]
# [ 1.74481176 -0.7612069 0.3190391 ]]
#----------
#[[ 1.62434536 -0.61175641 -0.52817175]
# [-1.07296862 0.86540763 -2.3015387 ]
# [ 1.74481176 -0.7612069 0.3190391 ]]
7. 正态分布 numpy.random.normal
numpy.random.normal(loc=0.0, scale=1.0, size=None)
- 它的作用是返回一个由 size 指定形状的数组，数组中的值服从 μ=loc,σ=scale 的正态分布。
- 其参数含义如下所示：
- loc : float 型或者 float 型的类数组对象，指定均值 μ。
- scale : float 型或者 float 型的类数组对象，指定标准差 σ。
- size : int 型或者 int 型的元组，指定了数组的形状。如果不提供 size，且 loc 和 scale 为标量（不是类数组对象），则返回一个服从该分布的随机数。
- 例如，我们返回两个正态分布的数组，均为 3 行 2 列，但是他们的均值和标准差不同，第一个返回数组的均值是 0，标准差是 1；第二个返回数组的均值是 1，标准差是 3。
a = np.random.normal(0, 1, (3, 2))
print(a)
print('-'*20)
b = np.random.normal(1, 3, (3, 2))
print(b)
#[[-0.26905696 2.23136679]
# [-2.43476758 0.1127265 ]
# [ 0.37044454 1.35963386]]
#--------------------
#[[ 2.50557162 -1.53264111]
# [ 1.00002928 2.62705772]
# [ 0.05947541 3.31303521]]
二、数组的其他函数
- 主要有以下方法：
| 函数名称 | 描述说明 |
|---|---|
| resize | 返回指定形状的新数组。 |
| append | 将元素值添加到数组的末尾。 |
| insert | 沿规定的轴将元素值插入到指定的元素前。 |
| delete | 删掉某个轴上的子数组，并返回删除后的新数组。 |
| argwhere | 返回数组内符合条件的元素的索引值。 |
| unique | 用于删除数组中重复的元素，并按元素值由大到小返回一个新数组。 |
| sort() | 对输入数组执行排序，并返回一个数组副本 |
| argsort | 沿着指定的轴，对输入数组的元素值进行排序，并返回排序后的元素索引数组 |
1. numpy.resize()
numpy.resize(arr, shape)
- numpy.resize() 可以返回指定形状的新数组。
- 这里我们需要注意的是，numpy.resize(arr,shape) 和 ndarray.resize(shape, refcheck=False) 的区别：
- （1） numpy.resize(arr,shape)，有返回值，返回复制内容。如果维度不够，会使用原数组数据补齐。
- （2） ndarray.resize(shape, refcheck=False)，修改原数组，不会返回数据。如果维度不够，会使用 0 补齐。
- 具体可见如下示例：
- 首先，我们生成一个指定元素的数组，并输出该数组和数组的形状。
a = np.array([[1,2,3],[4,5,6]])
print('a数组:',a)
print('a数组形状:',a.shape)
#3a数组: [[1 2 3]
# [4 5 6]]
#a数组形状: (2, 3)
- 然后，我们使用 numpy.resize 将 a 数组改变成 3 行 3 列的数组（如果维度不够，会使用原数组数据补齐）。
b = np.resize(a,(3,3))
b
#array([[1, 2, 3],
# [4, 5, 6],
# [1, 2, 3]])
- 此时，我们再次输出 a 数组。
a
#array([[1, 2, 3],
# [4, 5, 6]])
- 然后，我们使用 ndarray.resize（a.resize）将 a 数组改变成 3 行 3 列的数组（如果维度不够，会使用 0 补齐）。
a.resize((3,3),refcheck=False)
a
#array([[1, 2, 3],
# [4, 5, 6],
# [0, 0, 0]])
- 此时，a 数组的原本数据已经进行了修改，在此便不进行演示。
2. numpy.append()
- 它的作用是在数组的末尾添加值，默认返回一个一维数组。
numpy.append(arr, values, axis=None)
- 其参数具有如下含义：
- arr：输入的数组。
- values：向 arr 数组中添加的值，需要和 arr 数组的形状保持一致。
- axis：默认为 None，返回的是一维数组；当 axis=0 时，追加的值会被添加到行，而列数保持不变，若 axis=1 则与其恰好相反。
- 具体可见如下示例：
- 首先，我们生成一个指定元素的数组，并向该数组添加元素。
a = np.array([[1,2,3],[4,5,6]])
print (np.append(a, [7,8,9]))
#[1 2 3 4 5 6 7 8 9]
- 我们可以沿轴 0 添加元素。
print (np.append(a, [[7,8,9]],axis = 0))
#[[1 2 3]
# [4 5 6]
# [7 8 9]]
- 我们也可以沿轴 1 添加元素。
print (np.append(a, [[5,5,5],[7,8,9]],axis = 1))
#[[1 2 3 5 5 5]
# [4 5 6 7 8 9]]
3. numpy.insert()
- 该函数表示沿指定的轴，在给定索引值的前一个位置插入相应的值，如果没有提供轴，则输入数组被展开为一维数组。
numpy.insert(arr, obj, values, axis)
- 其参数具有如下含义：
- arr：要输入的数组。
- obj：表示索引值，在该索引值之前插入 values 值。
- values：要插入的值。
- axis：指定的轴，如果未提供，则输入数组会被展开为一维数组。
- 具体可见如下示例：
- 我们生成一个指定元素的数组，并不提供axis的情况。
a = np.array([[1,2],[3,4],[5,6]])
print (np.insert(a,3,[11,12]))
#[ 1 2 3 11 12 4 5 6]
- 我们可以沿轴 0 将元素插入到行。
print (np.insert(a,1,[11],axis = 0))
#[[ 1 2]
# [11 11]
# [ 3 4]
# [ 5 6]]
- 我们也可以沿轴 1 将元素插入到列。
print (np.insert(a,1,11,axis = 1))
#[[ 1 11 2]
# [ 3 11 4]
# [ 5 11 6]]
4. numpy.delete()
- numpy.delete() 表示从输入数组中删除指定的子数组，并返回一个新数组。
- 它与 insert() 函数相似，若不提供 axis 参数，则输入数组被展开为一维数组。
numpy.delete(arr, obj, axis)
- 其参数具有如下含义：
- arr：要输入的数组；
- obj：整数或者整数数组，表示要被删除数组元素或者子数组；
- axis：沿着哪条轴删除子数组。
- 具体可见如下示例：
- 我们生成一个指定元素的数组，并不提供axis的情况，是删除指定数组元素。
a = np.arange(12).reshape(3,4)
print(a)
print(np.delete(a,5))
#[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
#[ 0 1 2 3 4 6 7 8 9 10 11]
- 我们可以删除第二列，但注意需要将 axis 参数设置为 1，表示沿列方向进行删除。
- 我们也可以将 axis 参数设置为 0，沿行方向进行多行元素删除操作。
- 这里需要注意的是，不可以使用切片的形式。
print(np.delete(a,1,axis = 1))
print(a)
print(np.delete(a,[1,2],axis = 0))
#[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
#[[0 1 2 3]]
5. numpy.argwhere()
- numpy.argwhere()返回数组中非 0 元素的索引，若是多维数组则返回行、列索引组成的索引坐标。
- 具体可见如下示例：
- 我们生成一个指定元素的数组，并将其输出。
x = np.arange(6).reshape(2,3)
x
#array([[0, 1, 2],
# [3, 4, 5]])
- 然后，返回所有大于 1 的元素索引。
print(x)
y=np.argwhere(x>1)
print("-"*10)
print(y,y.shape)
#[[0 1 2]
# [3 4 5]]
#----------
#[[0 2]
# [1 0]
# [1 1]
# [1 2]] (4, 2)
6. numpy.unique()
- numpy.unique() 用于删除数组中重复的元素。
numpy.unique(arr, return_index, return_inverse, return_counts)
- 其参数具有如下含义：
- arr：输入数组，若是多维数组则以一维数组形式展开。
- return_index：如果为 True，则返回新数组元素在原数组中的位置（索引）。
- return_inverse：如果为 True，则返回原数组元素在新数组中的位置（索引）。
- return_counts：如果为 True，则返回去重后的数组元素在原数组中出现的次数。
- 具体可见如下示例：
- 我们先生成一个指定元素的数组，并将其输出。
- 然后，使用 numpy.unique() 对其进行去重操作，并将其输出，便于比对观察。
a = np.array([5,2,6,2,7,5,6,8,2,9])
print (a)
uq = np.unique(a)
print(uq)
#[5 2 6 2 7 5 6 8 2 9]
#[2 5 6 7 8 9]
- 我们可以获取数组去重后的索引数组，并打印去重后数组的索引。
print("a:",a)
u,indices = np.unique(a, return_index = True)
print(u)
print('-'*20)
print(indices)
#a: [5 2 6 2 7 5 6 8 2 9]
#[2 5 6 7 8 9]
#--------------------
#[1 0 2 4 7 9]
- 我们也可以获取去重数组的下标，并打印其下标。
ui,indices = np.unique(a,return_inverse = True)
print (ui)
print('-'*20)
print (indices)
print("a:",a)
#[2 5 6 7 8 9]
#--------------------
#[1 0 2 0 3 1 2 4 0 5]
- 我们可以知道去重元素的重复数量，也就是该去重元素的出现次数。
uc,indices = np.unique(a,return_counts = True)
print (uc)
print (indices)
#a: [5 2 6 2 7 5 6 8 2 9]
#[2 5 6 7 8 9]
#[3 2 2 1 1 1]
7. numpy.sort()
- numpy.sort() 表示对输入数组执行排序，并返回一个数组副本。
numpy.sort(a, axis, kind, order)
- 其参数具有如下含义：
- a：要排序的数组。
- axis：沿着指定轴进行排序，如果没有指定 axis，默认在最后一个轴上排序，若 axis=0 表示按列排序，axis=1 表示按行排序。
- kind：默认为 quicksort（快速排序）。
- order：若数组设置了字段，则 order 表示要排序的字段。
- 具体可见如下示例：
- 我们先生成一个指定元素的数组，并将其输出，然后调用 sort() 函数对其进行排序并输出排序后的数组。
- 最后，输出原数组，发现并没有发生改变，说明 sort() 函数不会对原数组内的元素进行修改。
a = np.array([[3,7,5],[6,1,4]])
print('a数组是：', a)
print('排序后的内容:',np.sort(a))
a
#a数组是： [[3 7 5]
# [6 1 4]]
#排序后的内容: [[3 5 7]
# [1 4 6]]
#array([[3, 7, 5],
# [6, 1, 4]])
- 我们可以以行为参照，列上面的数据排序：
print(np.sort(a, axis = 0))
#[[3 1 4]
# [6 7 5]]
- 我们也可以以列为参照，行上面的数据排序：
print(np.sort(a, axis = 1))
#[[3 5 7]
# [1 4 6]]
- 我们还可以在 sort 函数中设置排序字段，按我们指定的方式进行排序。
- 首先，我们指定数据类型为名字（字符串）和年龄（整型），按指定好的的数据类型定义数组的元素，并将其元素输出。
- 然后，我们将指定排序方式定义为名字，并输出排序后的数组，与前面输出的原数组数据进行比较。
dt = np.dtype([('name', 'S10'),('age', int)])
a = np.array([("raju",21),("anil",25),("ravi", 17), ("amar",27)], dtype = dt)
print(a)
print('--'*10)
print(np.sort(a, order = 'name'))
#[(b'raju', 21) (b'anil', 25) (b'ravi', 17) (b'amar', 27)]
#--------------------
#[(b'amar', 27) (b'anil', 25) (b'raju', 21) (b'ravi', 17)]
8. numpy.argsort()
- argsort() 表示沿着指定的轴，对输入数组的元素值进行排序，并返回排序后的元素索引数组。
- 具体可见如下示例：
- 我们先生成一个指定元素的数组，并将其输出。
a = np.array([90, 29, 89, 12])
print("原数组:",a)
#原数组: [90 29 89 12]
- 然后，使用 numpy.argsort() 对 a 数组进行排序，并将排序后的元素索引数组输出。
sort_ind = np.argsort(a)
print("打印排序元素索引值:",sort_ind)
#打印排序元素索引值: [3 1 2 0]
- 随后，我们可以使用索引数组对原数组进行排序。
sort_a = a[sort_ind]
print("打印排序数组")
for i in sort_ind:
print(a[i],end = " ")
a[sort_ind]
#打印排序数组
#12 29 89 90
#array([12, 29, 89, 90])
文章出处登录后可见！
已经登录？立即刷新
