Python组件---NumPy学习（三）

12 搜索NumPy 数组

搜索某个值，然后返回获得匹配的索引。

使用where() 进行NumPy数组索引；

12.1 where()查询

import numpy as np

# where() 搜索值的索引
arrS = np.arange(16).reshape(4,4)
print(arrS)
# 查找单个值，使用==索引
indexArr = np.where(arrS == 5)
print(indexArr)

# 查找偶数数值
ouindx = np.where(arrS%2 == 0)
print(ouindx)

# 查找奇数数值
jiindx = np.where(arrS%2 == 1)
print(jiindx)
# arr3 = np.arr

结果：

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
(array([1], dtype=int64), array([1], dtype=int64))
(array([0, 0, 1, 1, 2, 2, 3, 3], dtype=int64), array([0, 2, 0, 2, 0, 2, 0, 2], dtype=int64))

结果中两个数组，颜色一致的数字为一个元素的所以编号；

12.2 搜索排序

使用searchsorted() 的方法，该方法在数组中执行二进制搜索，并返回将在其中插入指定值以维持搜索顺序的索引。---这个searchsorted()方法，并不是找出某个元素的位置，而是找出某个元素放在哪个位置上才能保持原有的排列顺序

​
# searchsorted() 根据当前排序，查找插入当前值的位置
arrss = np.array([2,5,7,9,11,34])
print(arrss)
# 查找[8,16,22]插入数组arrss的位置，并且符合排序
index7Arr = np.searchsorted(arrss,9,side='right')
print(index7Arr)
# 查找[8,16,22]插入数组arrss的位置，并且符合排序
indexArr = np.searchsorted(arrss,[8,16,22])
print(indexArr)

​

结果：

[ 2  5  7  9 11 34]
4
[3 5 5]

13 NumPy 数组排序

排序是指将元素按有序顺序排列。

有序序列是拥有与元素相对应的顺序的任何序列，例如数字或字母、升序或降序。

NumPy数组使用sort() 的函数进行排序；

此函数返回数组的副本，而原始数组保持不变

import numpy as np

# 1D数组sort() 函数排序
arr1d = np.array([3,5,7,9,2,1])
print(np.sort(arr1d))
# 2D数组 sort()排序
arr2d = np.array([[4,3,1],[5,3,1]])
print(np.sort(arr2d))

结果：[1 2 3 5 7 9]
[[1 3 4]
 [1 3 5]]

14 NumPy 数组过滤

从现有数组中取出一些元素并从中创建新数组称为过滤（filtering）。
在 NumPy 中，我们使用布尔索引列表来过滤数组。
布尔索引列表是与数组中的索引相对应的布尔值列表。
如果索引处的值为 True，则该元素包含在过滤后的数组中；如果索引处的值为 False，则该元素将从过滤后的数组中排除。

import numpy as np

# numpy数组过滤
arr = np.array([61, 62, 63, 64, 65])
x = [True, False, True, False, True]
newarr = arr[x]
print(newarr)

运行结果：[61 63 65]

14.1 创建过滤器数组

为了不像上面用例使用True，False硬编码，可以根据条件创建过滤器数组

下图：根据大于62条件进行过滤数组

import numpy as np

# 创建过滤数组
arr = np.array([61, 62, 63, 64, 65])
# 创建一个空列表
filter_arr = []
# 遍历 arr 中的每个元素
for element in arr:
  # 如果元素大于 62，则将值设置为 True，否则为 False：
  if element > 62:
    filter_arr.append(True)
  else:
    filter_arr.append(False)
newarr = arr[filter_arr]
print(filter_arr)
print(newarr)

14.2 直接从数组创建过滤器

import numpy as np

# 创建一个过滤器数组，该数组仅返回原始数组中的偶数元素：
arr = np.array([1, 2, 3, 4, 5, 6, 7])
filter_arr = arr % 2 == 0
newarr = arr[filter_arr]
print(filter_arr)
print(newarr)

15. NumPy 随机数

随机数并不意味着每次都有不同的数字。随机意味着无法在逻辑上预测的事物。

15.1 伪随机和真随机

计算机在程序上工作，程序是权威的指令集。因此，这意味着必须有某种算法来生成随机数。
如果存在生成随机数的程序，则可以预测它，因此它就不是真正的随机数。
通过生成算法生成的随机数称为伪随机数。
我们可以生成真正的随机数吗？
是的。为了在我们的计算机上生成一个真正的随机数，我们需要从某个外部来源获取随机数据。外部来源通常是我们的击键、鼠标移动、网络数据等。
我们不需要真正的随机数，除非它与安全性（例如加密密钥）有关或应用的基础是随机性（例如数字轮盘赌轮）。

15.2 NumPy的Random 提供伪随机数

import numpy as np

# randint生成一个 0 到 100 之间的随机整数：
x = np.random.randint(100)
print("生成100内随机数:", x)

# rand生成随机浮点数：
x1 = np.random.rand()
print("生成0-1内随机浮点数:", x1)

15.3 生成随机数组

在 NumPy 中，我们可以使用上例中的两种方法来创建随机数组。

整数：randint() 方法接受 size 参数，您可以在其中指定数组的形状。

浮点数：rand() 方法还允许您指定数组的形状。

用例：

import numpy as np

# 生成一个 1-D 数组，其中包含 5 个从 0 到 100 之间的随机整数组：
x=np.random.randint(100, size=(5))
print("生成100内随机数:", x)

# 生成有 3 行的 2-D 数组，每行包含 5 个从 0 到 100 之间的随机整数组
x1 = np.random.randint(100, size=(3, 5))
print("生成100内随机数组:", x1)

# rand生成1D随机浮点数组：
y1 = np.random.rand(5)
print("生成0-1内随机浮点数组:", y1)

# 生成有 3 行的 2-D 数组，每行包含 5 个从 0 到 1 之间的随机数组
y2 = np.random.rand(3, 5)
print("生成有 3 行的 2-D 数组:", y2)

打印结果：

生成100内随机数: [17 61 40 50 65]
生成100内随机数组: [[65  8 51 91 19]
 [84 63 21 41 30]
 [10  3 94 65 47]]
生成0-1内随机浮点数组: [0.91938577 0.27859716 0.28764233 0.21471749 0.59214906]
生成有 3 行的 2-D 数组: [[0.83885196 0.29991637 0.7761525  0.23716597 0.90626849]
 [0.74033709 0.45950665 0.71663226 0.52281348 0.92200688]
 [0.1759903  0.73999979 0.26187017 0.65964554 0.84479247]]

15.4 从数组生成随机数

choice() 方法使您可以基于值数组生成随机值。
choice() 方法将数组作为参数，并随机返回其中一个值。

用例：

import numpy as np

# 从数组生成随机数
x = np.random.choice([3, 5, 7, 9])
print("从数组生成随机数:", x)

# 生成由数组参数（3、5、7 和 9）中的值组成的二维数组：
x1 = np.random.choice([3, 5, 7, 9], size=(3, 5))
print("生成由数组参数中的值组成的二维数组:", x1)

结果打印：

从数组生成随机数: 9
生成由数组参数中的值组成的二维数组: [[9 3 5 7 9]
 [3 9 5 7 7]
 [3 7 5 5 3]]

16. NumPy ufuncs

ufuncs 指的是“通用函数”（Universal Functions），它们是对 ndarray 对象进行操作的 NumPy 函数。

16.1 使用 ufuncs原因

ufunc 用于在 NumPy 中实现矢量化，这比迭代元素要快得多。
它们还提供广播和其他方法，例如减少、累加等，它们对计算非常有帮助。
ufuncs 还接受其他参数，比如：
where 布尔值数组或条件，用于定义应在何处进行操作。
dtype 定义元素的返回类型。
out 返回值应被复制到的输出数组。

16.2 向量化

将迭代语句转换为基于向量的操作称为向量化。
由于现代 CPU 已针对此类操作进行了优化，因此速度更快。

对两个列表的元素进行相加：
list 1: [1, 2, 3, 4]
list 2: [4, 5, 6, 7]

如果没有 ufunc，我们可以使用 Python 的内置 zip() 方法

通过 ufunc，我们可以使用 add() 函数

import numpy as np

# 对两个列表的元素进行相加
x = [1, 2, 3, 4]
y = [4, 5, 6, 7]
z = []

# 没有 ufunc，我们可以使用 Python 的内置 zip() 方法
for i, j in zip(x, y):
  z.append(i + j)
print("no ufunc:", z)

# 通过 ufunc，我们可以使用 add() 函数
z1 = np.add(x, y)
print("ufunc:",z1)

结果输出：

no ufunc: [5, 7, 9, 11]
ufunc: [ 5  7  9 11]

至此，NumPy的基础学习完成。