一个认为一切根源都是“自己不够强”的INTJ
个人主页：用哲学编程-CSDN博客专栏：每日一题——举一反三
Python编程学习
Python内置函数
Python-3.12.0文档解读
目录
详细说明
功能描述
参数
返回值
使用规则
示例代码
基本使用
模运算
变动记录
记忆策略
常用场景
场景 1: 基本幂运算
场景 2: 计算倒数
场景 3: 幂运算结合模运算
场景 4: 计算倒数的模运算
场景 5: 处理复数结果
场景 6: 使用 pow 函数计算斐波那契数列的某一项
巧妙用法
技巧 1: 模逆的计算
技巧 2: 实现组合数计算
技巧3: 利用 pow 实现 RSA 加密和解密
综合技巧
技巧 1: 使用 pow 结合 itertools 生成密码学中的大素数
技巧2: 结合 multiprocessing 进行并行计算
详细说明
功能描述
pow 函数用于计算 base 的 exp 次幂。在提供 mod 参数时，返回 base 的 exp 次幂对 mod 取余。这比单独使用表达式 pow(base, exp) % mod 更高效。两参数形式 pow(base, exp) 等价于乘方运算符 base**exp。
参数
- base (数值类型): 底数。
- exp (数值类型): 指数。
- mod (整数类型, 可选): 模数。如果提供，则返回结果为 base 的 exp 次幂对 mod 取余。如果不提供，则执行普通幂运算。
返回值
返回值的类型和输入参数类型有关：
- 如果 base 和 exp 都是整数且不涉及负指数，则结果为整数。
- 如果 exp 为负值，所有参数将被转换为浮点数，结果也为浮点数。
- 如果 base 为负且 exp 为非整数，结果为复数。
使用规则
- 基本运算:
- pow(10, 2) 返回 100。
- pow(10, -2) 返回 0.01。
- 模运算:
- pow(base, exp, mod) 将计算 (base ** exp) % mod。
- 负指数时的模运算:
- 如果 exp 为负值且给定 mod，则 base 必须相对于 mod 不可整除。函数将计算 pow(inv_base, -exp, mod)，其中 inv_base 是 base 的倒数对 mod 取余。
示例代码
基本使用
print(pow(10, 2)) # 输出 100
print(pow(10, -2)) # 输出 0.01模运算
# 计算 2 的 5 次幂对 3 取余
print(pow(2, 5, 3)) # 输出 2
# 计算 38 的倒数对 97 取余
inv_38_mod_97 = pow(38, -1, 97)
print(inv_38_mod_97) # 输出 23
# 验证倒数
print((23 * 38) % 97 == 1) # 输出 True变动记录
- 版本 3.8 之前:
- 三参数形式的 pow 不允许第二个参数为负值。
- 仅支持位置参数。
- 版本 3.8:
- 三参数形式的 pow 现在允许第二个参数为负值，能够计算倒数的余数。
支持关键字参数。
记忆策略
pow 是单词 "power" 的缩写。在数学中，"power" 表示幂运算。因此，当看到 pow 时，可以联想到幂（power）运算。
常用场景
pow 函数在很多实际应用中都非常有用，尤其是在涉及幂运算和模运算的场景中。以下是几个详细的使用场景，每行代码都带有注释。
场景 1: 基本幂运算
计算一个数字的幂次方，例如科学计算或复利公式等。
# 计算 3 的 4 次幂
result = pow(3, 4)
# 预期输出 3 ** 4 = 81
print(result) # 输出 81场景 2: 计算倒数
当需要计算一个数的倒数时，使用负指数。
# 计算 5 的 -2 次幂，即 1 / (5 ** 2)
result = pow(5, -2)
# 预期输出 1 / (5 ** 2) = 1 / 25 = 0.04
print(result) # 输出 0.04场景 3: 幂运算结合模运算
常用于密码学中的大数计算，例如RSA算法。
# 计算 7 的 256 次幂对 13 取余
result = pow(7, 256, 13)
# 预期输出 (7 ** 256) % 13
print(result) # 输出 9场景 4: 计算倒数的模运算
在模运算中计算一个数的倒数，常用于加密算法和同余方程。
# 计算 38 的倒数对 97 取余
inv_38_mod_97 = pow(38, -1, 97)
# 检查 38 的倒数 (23) 和 38 相乘后对 97 取余是否为 1
# 预期输出 True
print((inv_38_mod_97 * 38) % 97 == 1) # 输出 True场景 5: 处理复数结果
处理负数底数和非整数指数的幂运算，会返回复数结果。
# 计算 -9 的 0.5 次幂，即 sqrt(-9)
result = pow(-9, 0.5)
# 预期输出复数 3j (即虚数单位 j)
print(result) # 输出 3j场景 6: 使用 pow 函数计算斐波那契数列的某一项
利用快速幂算法来计算斐波那契数列的第 n 项。
import math
def fibonacci(n):
# 使用黄金比例公式计算 fib(n)
phi = (1 + math.sqrt(5)) / 2
psi = (1 - math.sqrt(5)) / 2
# 计算 phi^n 和 psi^n
phi_n = pow(phi, n)
psi_n = pow(psi, n)
# 按照公式计算斐波那契数列的第 n 项
fib_n = (phi_n - psi_n) / math.sqrt(5)
# 由于浮点数计算存在误差，这里使用四舍五入取整
return round(fib_n)
# 计算 Fibonacci(10)
result = fibonacci(10)
# 预期输出 55
print(result) # 输出 55
# 计算 Fibonacci(20)
result = fibonacci(20)
# 预期输出 6765
print(result) # 输出 6765巧妙用法
技巧 1: 模逆的计算
在数论和密码学中，经常需要计算模逆。一般方法可能需要扩展欧几里得算法，但 pow 函数可以巧妙地利用费马小定理快速计算模逆。
def mod_inverse(a, m):
# 如果 m 是素数，利用费马小定理计算模逆
return pow(a, m - 2, m) # 这里假设 m 是素数
# 示例: 计算 3 在模 11 下的模逆
result = mod_inverse(3, 11)
print(result) # 输出 4，因为 (3 * 4) % 11 = 1技巧 2: 实现组合数计算
在组合数学中，计算组合数（即二项式系数）时，可以利用 pow 函数实现快速计算，特别是在模运算下。
def mod_comb(n, k, mod):
if k > n:
return 0
if k == 0 or k == n:
return 1
# 计算 n! % mod
num = 1
for i in range(n, n - k, -1):
num = (num * i) % mod
# 计算 k! % mod
denom = 1
for i in range(1, k + 1):
denom = (denom * i) % mod
# 计算组合数: num * mod_inverse(denom, mod) % mod
return (num * pow(denom, mod - 2, mod)) % mod
# 示例: 计算 C(10, 3) % 13
result = mod_comb(10, 3, 13)
print(result) # 输出 10，因为 C(10, 3) = 120，120 % 13 = 10技巧3: 利用 pow 实现 RSA 加密和解密
在 RSA 加密算法中，核心步骤是计算大整数的模幂。pow 函数的三参数形式非常适合这个任务。
# RSA 加密
def rsa_encrypt(message, e, n):
return pow(message, e, n)
# RSA 解密
def rsa_decrypt(ciphertext, d, n):
return pow(ciphertext, d, n)
# 示例参数（实际使用中参数应更大）
e = 65537
d = 2753
n = 3233
# 加密
message = 123
ciphertext = rsa_encrypt(message, e, n)
print(ciphertext) # 输出密文
# 解密
decrypted_message = rsa_decrypt(ciphertext, d, n)
print(decrypted_message) # 输出 123，解密后的明文这些技巧展示了 pow 函数在计算效率和解决复杂数学问题上的强大功能，不仅能处理常见的幂运算，还能高效地计算模幂和模逆。
综合技巧
可以将 pow 函数与其他函数或方法结合使用来解决一些复杂问题，以下是几个巧妙的组合用法：
技巧 1: 使用 pow 结合 itertools 生成密码学中的大素数
在密码学中，大素数的生成和验证是一个重要的步骤。可以使用 itertools 生成候选素数，然后使用 pow 函数进行快速素数测试（如费马素性测试）。
import itertools
import random
def is_probable_prime(n, k=5):
"""使用费马素性测试检查一个数是否为素数"""
if n <= 1:
return False
for _ in range(k):
a = random.randint(2, n - 2)
if pow(a, n - 1, n) != 1:
return False
return True
def generate_large_prime(bits):
"""生成指定位数的大素数"""
while True:
candidate = random.getrandbits(bits) | (1 << (bits - 1)) | 1
if is_probable_prime(candidate):
return candidate
# 示例：生成一个512位的大素数
large_prime = generate_large_prime(512)
print(large_prime)技巧2: 结合 multiprocessing 进行并行计算
在大规模计算中，可以使用 multiprocessing 进行并行计算，并结合 pow 函数进行高效的数学运算。
from multiprocessing import Pool
def power_mod(base_exp_mod):
base, exp, mod = base_exp_mod
return pow(base, exp, mod)
# 示例：并行计算多个幂模运算
inputs = [(2, 100000000, 1000000007), (3, 200000000, 1000000007), (5, 300000000, 1000000007)]
with Pool() as pool:
results = pool.map(power_mod, inputs)
print(results) # 输出多个幂模运算结果的列表以上这些例子展示了如何巧妙地将 pow 函数与其他函数或方法结合使用，解决实际中的复杂问题。这些技巧不仅高效，还能显著简化代码逻辑。
感谢阅读。
