Python-VBA函数之旅-pow函数

目录

一、pow函数的常见应用场景

二、pow函数使用注意事项

三、如何用好pow函数？

1、pow函数：

1-1、Python：

1-2、VBA：

2、推荐阅读：

个人主页：神奇夜光杯-CSDN博客 

一、pow函数的常见应用场景

        Python中的pow()函数在多种实际应用场景中都非常有用，特别是在需要执行幂运算的情况下，其常见的应用场景有：

1、科学计算：在科学计算中，经常需要进行幂运算，pow()函数能够方便地计算一个数的任意次幂。

2、工程和数学领域：在工程和数学领域，pow()函数同样被广泛使用，例如在物理学、化学、生物学等学科的数学模型中，经常需要进行幂运算。

3、密码学：在密码学中，pow()函数的模幂运算(当提供modulus参数时)被广泛用于加密和解密算法中，如RSA加密算法。

4、图像处理和计算机图形学：在图像处理和计算机图形学中，幂运算可以用于调整图像的亮度和对比度。例如，通过将像素值进行幂运算，可以增强或减弱图像的明暗效果。

5、机器学习：在机器学习和数据科学中，pow()函数可以用于各种数学运算和模型计算中。例如，在回归模型中，可能需要计算特征的幂次来捕获数据中的非线性关系。

6、物理模拟和动画：在物理模拟和动画中，幂运算可以用于模拟各种物理现象，如弹性碰撞、阻尼运动等，通过调整幂次，可以精确地控制模拟结果。

7、金融和经济学：在金融和经济学中，幂运算被用于计算复利、计算投资回报率等，pow()函数可以方便地执行这些计算，帮助投资者和分析师更好地理解市场动态和投资决策。

8、数据分析：在数据分析中，幂运算可以用于对数据进行缩放或转换，以便更好地进行可视化或建模。例如，可以使用pow()函数将数据转换为对数尺度，以便在图表中更清晰地显示数据的分布和趋势。

9、编程优化：在编程时，使用pow()函数可以简化代码并提高计算精度，与手动编写幂运算的循环或递归相比，使用内置函数通常更快、更可靠且更易于维护。

        总之，pow()函数在Python编程中具有广泛的应用场景，无论是用于科学计算、工程和数学领域、密码学、图像处理和计算机图形学、机器学习还是其他领域，它都是一个非常有用的工具。

 

二、pow函数使用注意事项

        在Python中使用pow()函数时，需注意以下事项：

1、参数类型：pow()函数可以接受整数、浮点数或复数作为参数，但是，当使用浮点数或复数时，结果的精度可能会受到限制，尤其是在涉及非常大的数值或复杂的计算时。

2、整数溢出：当使用非常大的整数作为base或exponent时，可能会遇到整数溢出的问题；Python的整数类型通常是无限的(在大多数现代Python实现中)，但如果你在使用其他编程语言或工具(如C语言的某些版本)时调用Python的pow()函数，并且这些工具对整数大小有限制，那么可能会遇到溢出问题。

3、浮点数精度：当使用浮点数作为base或exponent时，结果的精度可能会受到影响；浮点数在计算机中的表示是近似的，因此计算结果可能不是完全精确的，在进行需要高精度的计算时，可能需要使用专门的数学库或工具。

4、性能考虑：虽然pow()函数在大多数情况下都很快，但在进行大量的幂运算或涉及非常大的数值时，性能可能会成为一个问题；如果你发现pow()函数的性能不足以满足你的需求，可能需要考虑使用其他方法或工具来优化你的代码。

5、模幂运算：当使用modulus参数进行模幂运算时，需要确保modulus不是零，因为除以零是未定义的；此外，如果modulus是负数，那么结果将取决于你的Python实现和版本，因为不同的实现可能对负数模数有不同的处理方式。

6、整数除法：在Python 3中，整数除法默认是精确的(即返回浮点数)，但在某些情况下，你可能希望进行整数除法并丢弃小数部分；如果你使用pow()函数进行整数除法并期望得到整数结果，需要确保base、exponent和modulus(如果有)都是整数，并且使用`//`运算符来获取整数结果。

7、避免不必要的计算：在使用pow()函数之前，确保你的计算是必要的；有时候，你可以通过其他方式避免进行昂贵的幂运算，例如通过查找表、近似算法或数学公式来优化你的代码。

8、错误处理：当使用pow()函数时，始终考虑可能出现的错误情况，并编写适当的错误处理代码来捕获和处理这些错误。例如，如果modulus参数是负数，或者如果函数返回了意外的结果，你的代码应该能够优雅地处理这些情况。

三、如何用好pow函数？

        在Python中，pow()函数是一个内置函数，用于计算一个数的幂。你可以直接使用它而无需导入额外的模块，因为它与math.pow()函数功能相同但更加方便。以下是使用Python中pow()函数的一些建议：

1、基本用法：result = pow(base, exponent)，其中base是底数，exponent是指数。

2、处理浮点数：pow()函数可以用于浮点数。

3、处理负数指数：当指数为负数时，pow()函数会计算底数的倒数的绝对值的幂，并返回结果的倒数。

4、处理模幂运算：pow()函数还可以接受一个可选的第三个参数，用于模幂运算(也称为模方)，这在密码学和一些数学运算中特别有用。

5、避免不必要的调用：如果你多次使用相同的底数和指数计算幂，那么最好将结果存储在一个变量中，以避免重复计算。

6、性能考虑：虽然pow()函数在大多数情况下都很快，但如果你在处理大量数据或需要极致性能的场景中，仍然应该考虑优化；对于整数幂运算，使用内置的`**`运算符可能更为高效，因为Python内部可能为此进行了优化。

7、类型检查：虽然Python是动态类型的，但如果你在处理不确定类型的输入时，最好进行类型检查以确保它们都是数值类型，因为非数值类型的输入会导致TypeError错误。

8、文档和测试：始终参考Python官方文档以获取关于pow()函数的最新信息和细节；同时，编写单元测试以确保你的代码在预期范围内正确工作是很重要的。

9、代码清晰性：确保你的代码易于阅读和理解，当使用pow()函数时，最好为变量选择有意义的名称，并在需要时添加注释。

10、错误处理：虽然pow()函数通常不会引发异常(除了当底数为负数且指数为非整数且没有提供模数时)，但在处理用户输入或不确定的数据时，最好添加适当的错误处理逻辑来捕获和处理任何潜在的异常。

1、pow函数：

1-1、Python：

# 1.函数：pow
# 2.功能：用于计算一个数的幂次
# 3.语法：pow(base, exponent, [modulus=None])
# 4.参数：
# 4-1、base：必须参数，表示基数，即要计算幂次的那个数
# 4-2、exponent：必须参数，表示指数，即基数要乘以自身的次数
# 4-3、modulus：可选参数，默认为None，表示模数，如果提供了这个参数，则函数会返回(base ** exponent) % modulus的结果
# 5.返回值：
# 5-1、无modulus参数：返回base的exponent次幂
# 5-2、有modulus参数：返回base的exponent次幂对modulus取余
# 6.说明：
# 6-1、如果参数base和exponent有一个是浮点数，则结果转换成浮点数
# 6-2、如果参数base和exponent都是正整数，则结果也是正整数
# 6-3、如果参数exponent为负整数，则结果返回浮点数(浮点数不能取模，此时可选参数modulus不能传入值)
# 6-4、如果pow()函数中设置了可选参数modulus的值，则参数base和exponent必须为整数，且exponent不能为负整数
# 6-5、pow()函数所有参数必须是数值类型
# 7.示例：
# 用dir()函数获取该函数内置的属性和方法
print(dir(pow))
# ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
# '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__',
# '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__',
# '__str__', '__subclasshook__', '__text_signature__']
 
# 用help()函数获取该函数的文档信息
help(pow)
 
# 应用一：科学计算
# 示例1：计算整数幂
# 计算2的10次方
result = pow(2, 10)
print(f"2的10次方是 {result}")
# 计算3的5次方
result = pow(3, 5)
print(f"3的5次方是 {result}")
# 2的10次方是 1024
# 3的5次方是 243
 
# 示例2：计算浮点数幂
# 计算2.71828的3次方(e的3次方)
result = pow(2.71828, 3)
print(f"e的3次方近似为 {result}")
# 计算1.5的平方根(即1.5的0.5次方)
result = pow(1.5, 0.5)
print(f"1.5的平方根是 {result}")
# e的3次方近似为 20.085496391455553
# 1.5的平方根是 1.224744871391589
 
# 示例3：模幂运算(加密中使用)
# 在模数 23 下，计算 5 的 10 次方
result = pow(5, 10, 23)
print(f"在模 23 下，5 的 10 次方是 {result}")
# RSA 加密算法中的一个简化示例
p = 61  # 质数 p
q = 53  # 质数 q
n = p * q  # 模数 n
phi = (p - 1) * (q - 1)  # 欧拉函数 φ(n)
e = 17  # 公钥指数 e，与 φ(n) 互质
# 计算私钥指数 d，满足 e*d mod φ(n) = 1
d = pow(e, -1, phi)  # 使用扩展欧几里得算法或模逆元算法计算
# 打印公钥和私钥
print(f"公钥 (e, n): ({e}, {n})")
print(f"私钥 (d, n): ({d}, {n})")
# 在模 23 下，5 的 10 次方是 9
# 公钥 (e, n): (17, 3233)
# 私钥 (d, n): (2753, 3233)
 
# 示例4：比较pow()和**运算符
# 使用pow()函数和**运算符计算3的4次方
result_pow = pow(3, 4)
result_exp = 3 ** 4
print(f"使用pow(): {result_pow}")
print(f"使用**运算符: {result_exp}")
# 性能上，两者通常没有显著差异，但在某些极端情况下，** 运算符可能更优化
# 使用pow(): 81
# 使用**运算符: 81
 
# 应用二：工程和数学领域
# 示例1：物理学中的能量计算
# 假设一个物体的质量为 2 kg，速度为 3 m/s
mass = 2  # kg
velocity = 3  # m/s
# 动能公式：E_k = 1/2 * m * v^2
kinetic_energy = 0.5 * mass * pow(velocity, 2)
print(f"物体的动能为：{kinetic_energy} 焦耳")
# 物体的动能为：9.0 焦耳
 
# 示例2：数学中的幂律关系
# 假设有两个变量 x 和 y，它们之间存在关系 y = x^2
x = 4
n = 2
# 使用 pow() 函数计算 y
y = pow(x, n)
print(f"当 x = {x} 且 n = {n} 时，y = {y}")
# 当 x = 4 且 n = 2 时，y = 16
 
# 示例3：数值方法中的迭代算法
def sqrt_newton_method(x, epsilon=1e-10, max_iter=100):
    guess = x / 2.0
    for _ in range(max_iter):
        if abs(guess * guess - x) < epsilon:
            return guess
        guess = (guess + x / guess) / 2.0
    print("迭代次数超过最大限制，可能无法收敛到精确值")
    return guess
# 计算 2 的平方根
root = sqrt_newton_method(2)
print(f"2 的平方根近似值为：{root}")
# 这里的pow()函数虽然没有直接用到，但它是我们验证结果的一个工具
print(f"验证：{pow(root, 2)} 接近于 2")
# 2 的平方根近似值为：1.4142135623746899
# 验证：2.0000000000045106 接近于 2
 
# 示例4：统计学中的指数分布(使用了math库做为替代方案)
import math
# 假设 λ = 0.5
lambda_param = 0.5
# 计算在 x = 2 处的概率密度
x = 2
pdf_value = lambda_param * math.exp(-lambda_param * x)
print(f"当 λ = {lambda_param} 且 x = {x} 时，指数分布的概率密度函数值为：{pdf_value}")
# 当 λ = 0.5 且 x = 2 时，指数分布的概率密度函数值为：0.18393972058572117
 
# 应用三：密码学
def generate_keypair(p, q):
    # 生成 RSA 密钥对
    n = p * q  # 模数 n
    phi = (p - 1) * (q - 1)  # 欧拉函数 φ(n)
    # 选择公钥 e，使得 e 与 φ(n) 互质，并且 e < φ(n)
    e = 65537  # 常见的公钥 e 值
    # 使用扩展欧几里得算法计算私钥 d，使得 e*d mod φ(n) = 1
    d = pow(e, -1, phi)  # 这里使用了 pow() 函数的模幂运算功能
    return ((e, n), (d, n))  # 返回公钥和私钥
def encrypt(pk, plaintext):
    # 使用公钥加密
    key, n = pk
    ciphertext = [pow(ord(char), key, n) for char in plaintext]
    return ciphertext
def decrypt(pk, ciphertext):
    # 使用私钥解密
    key, n = pk
    plaintext = [chr(pow(char, key, n)) for char in ciphertext]
    return ''.join(plaintext)
# 示例
# 选择两个不同的质数 p 和 q
p = 61
q = 53
# 生成密钥对
public_key, private_key = generate_keypair(p, q)
print("公钥:", public_key)
print("私钥:", private_key)
# 要加密的消息
message = "Hello, RSA!"
# 加密消息
encrypted = encrypt(public_key, message)
print("加密后的消息:", encrypted)
# 解密消息
decrypted = decrypt(private_key, encrypted)
print("解密后的消息:", decrypted)
# 公钥: (65537, 3233)
# 私钥: (2753, 3233)
# 加密后的消息: [3000, 1313, 745, 745, 2185, 678, 1992, 1859, 2680, 2790, 1853]
# 解密后的消息: Hello, RSA!
 
# 应用四：图像处理和计算机图形学
import numpy as np
from PIL import Image
def adjust_brightness_contrast(image_path, brightness=1.0, contrast=1.0):
    # 加载图像为灰度图
    image = Image.open(image_path).convert('L')
    image_np = np.array(image)
    # 调整亮度：添加亮度偏移量
    # 注意：这里我们假设亮度调整是线性的，通过添加一个常数来实现
    # 在实际应用中，亮度调整可能更复杂
    adjusted_image = np.clip(image_np * brightness, 0, 255).astype(np.uint8)
    # 调整对比度：使用pow()函数进行非线性变换
    # 这里我们假设对比度调整是通过对像素值应用幂函数来实现的
    # alpha参数控制对比度的强度，你可以根据需要调整它
    alpha = contrast
    gamma_corrected = np.clip(np.power(adjusted_image / 255.0, alpha) * 255.0, 0, 255).astype(np.uint8)
    # 将调整后的图像转换回PIL图像对象
    result_image = Image.fromarray(gamma_corrected)
    # 显示图像或保存图像(取消注释以保存图像)
    # result_image.save('adjusted_image.png')
    result_image.show()
# 使用示例
adjust_brightness_contrast('input.jpg', brightness=1.2, contrast=1.5)
 
# 应用五：机器学习
# 示例1：数据预处理-特征转换
import numpy as np
# 假设我们有一个特征数组
X = np.array([1, 2, 3, 4, 5])
# 我们想将这个特征转换为它的平方
X_squared = np.power(X, 2)
print(X_squared)
# 现在，你可以将 X_squared 作为新特征添加到你的数据集中
# [ 1  4  9 16 25]
 
# 示例2：特征工程-多项式特征
import numpy as np
from sklearn.preprocessing import PolynomialFeatures
# 假设我们有两个特征
X = np.array([[1, 2], [3, 4], [5, 6]])
# 我们想添加这些特征的平方和乘积作为新的特征
poly = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly.fit_transform(X)
# 但如果你想手动做这件事（只是为了说明）
X_manual_poly = np.column_stack((
    X[:, 0],
    X[:, 1],
    np.power(X[:, 0], 2),
    np.power(X[:, 1], 2),
    X[:, 0] * X[:, 1]
))
print(X_poly)  # 这将输出与 X_manual_poly 类似的结果
 
# 示例3：评估模型-计算均方误差(MSE)的平方根
from sklearn.metrics import mean_squared_error
import math
import numpy as np
# 假设 y_true 是真实值，y_pred 是模型预测值
y_true = np.array([3, -0.5, 2, 7])
y_pred = np.array([2.5, 0.0, 2, 8])
# 计算 MSE
mse = mean_squared_error(y_true, y_pred)
# 使用pow()计算RMSE(尽管在实践中，我们会直接使用 np.sqrt())
rmse = math.pow(mse, 0.5)
print(rmse)  # 输出RMSE的值
 
# 示例4：正则化项-L2正则化(权重衰减)
import numpy as np
# 假设w是模型的权重向量
w = np.array([0.5, -0.2, 0.3])
# 计算L2正则化项(注意：在实际应用中，你会乘以一个正则化系数)
l2_reg = np.sum(np.power(w, 2))
print(l2_reg)  # 输出权重的平方和
# 0.38
 
# 应用六：物理模拟和动画
import matplotlib.pyplot as plt
import numpy as np
# 初始化参数
g = 9.81  # 重力加速度
m = 1.0  # 物体质量
v0 = 0.0  # 初始速度
y0 = 10.0  # 初始高度
damping_exponent = 0.5  # 阻尼的非线性指数
time_step = 0.1  # 时间步长
total_time = 5.0  # 总模拟时间
# 初始化数组来存储时间和位置
times = np.arange(0, total_time, time_step)
positions = np.zeros_like(times)
velocities = np.zeros_like(times)
# 模拟下落过程
positions[0] = y0
for i in range(len(times) - 1):
    # 使用牛顿第二定律 F = ma 来计算加速度
    # 在这里，我们假设阻尼力与速度的非线性幂次成正比
    acceleration = -g - np.sign(velocities[i]) * np.abs(velocities[i]) ** damping_exponent
    # 更新速度和位置
    velocities[i + 1] = velocities[i] + acceleration * time_step
    positions[i + 1] = positions[i] + velocities[i + 1] * time_step
# 绘制结果
plt.figure(figsize=(10, 6))
plt.plot(times, positions, label='Position')
plt.plot(times, velocities, label='Velocity')
plt.xlabel('Time (s)')
plt.ylabel('Value')
plt.legend()
plt.title('Non-linear Damping Simulation')
plt.grid(True)
plt.show()
 
# 应用七：金融和经济学
# 示例1：计算复利
def compound_interest(principal, rate, time, periods_per_year):
    # 假设rate是年利率(小数形式)，time 是年数，periods_per_year 是一年中的计息次数（如12表示月复利）
    # 计算每个计息周期的利率
    period_rate = rate / periods_per_year
    # 使用pow()函数计算复利后的总金额
    future_value = principal * pow(1 + period_rate, periods_per_year * time)
    return future_value
# 示例：本金1000元，年利率5%，投资5年，按年复利计算
principal = 1000
annual_rate = 0.05
time_years = 5
periods_per_year = 1  # 年复利
future_value = compound_interest(principal, annual_rate, time_years, periods_per_year)
print(f"After {time_years} years, the future value is: {future_value:.2f}")
# After 5 years, the future value is: 1276.28
 
# 示例2：计算股票投资的指数增长
def stock_price_after_years(initial_price, growth_rate, years):
    # 假设 growth_rate 是年增长率（小数形式）
    final_price = initial_price * pow(1 + growth_rate, years)
    return final_price
# 示例：初始价格100元，年增长率10%，5年后的价格
initial_price = 100
growth_rate = 0.10
years = 5
final_price = stock_price_after_years(initial_price, growth_rate, years)
print(f"After {years} years, the stock price is expected to be: {final_price:.2f}")
# After 5 years, the stock price is expected to be: 161.05
 
# 示例3：计算折旧
def straight_line_depreciation(cost, salvage_value, useful_life):
    """
    计算直线折旧法下的年折旧额
    :param cost: 资产原值
    :param salvage_value: 残值
    :param useful_life: 使用年限
    :return: 年折旧额
    """
    depreciable_cost = cost - salvage_value
    annual_depreciation = depreciable_cost / useful_life
    return annual_depreciation
# 示例
cost = 100000  # 资产原值 100,000 元
salvage_value = 10000  # 残值 10,000 元
useful_life = 5  # 使用年限 5 年
annual_depreciation = straight_line_depreciation(cost, salvage_value, useful_life)
print(f"年折旧额是: {annual_depreciation} 元")
# 年折旧额是: 18000.0 元
 
# 示例4：指数增长
def exponential_growth(base, growth_rate, time):
    """
    计算指数增长
    :param base: 基期值
    :param growth_rate: 增长率（小数形式）
    :param time: 时间（年）
    :return: 最终值
    """
    return base * pow(1 + growth_rate, time)
# 示例
base = 100  # 基期值
growth_rate = 0.03  # 增长率 3%
time = 10  # 时间 10 年
final_value = exponential_growth(base, growth_rate, time)
print(f"最终值: {final_value:.2f}")
# 最终值: 134.39
 
# 应用八：数据分析
# 示例1：指数衰减函数
import numpy as np
import matplotlib.pyplot as plt
def exponential_decay(time, initial_value, decay_rate):
    """
    计算指数衰减
    :param time: 时间数组
    :param initial_value: 初始值
    :param decay_rate: 衰减率（通常是一个小于1的正数）
    :return: 衰减后的值数组
    """
    return initial_value * np.power(decay_rate, time)
# 示例
time = np.arange(0, 10, 0.1)  # 从0到10，步长为0.1
initial_value = 100  # 初始值
decay_rate = 0.95  # 衰减率
decayed_values = exponential_decay(time, initial_value, decay_rate)
# 绘制结果
plt.plot(time, decayed_values)
plt.title('Exponential Decay')
plt.xlabel('Time')
plt.ylabel('Value')
plt.show()
 
# 示例2：加权指数移动平均线(WEMA)
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
def weighted_exponential_moving_average(data, alpha):
    """
    计算加权指数移动平均线
    :param data: 数据数组
    :param alpha: 平滑因子（0 < alpha <= 1）
    :return: 加权指数移动平均线数组
    """
    n = len(data)
    wema = np.zeros_like(data)
    wema[0] = data[0]  # 第一个值就是数据本身
    for i in range(1, n):
        wema[i] = (data[i] * alpha) + (wema[i - 1] * (1 - alpha))
    return wema
# 示例(假设我们有一个股票价格数组)
# 假设data是一个包含股票价格的pandas Series
data = pd.Series([100, 102, 103, 101, 104, 105, 107, 106, 108, 110])
alpha = 0.1  # 平滑因子
wema_values = weighted_exponential_moving_average(data, alpha)
# 绘制结果
plt.plot(data, label='Price')
plt.plot(wema_values, label='WEMA')
plt.title('Weighted Exponential Moving Average')
plt.xlabel('Day')
plt.ylabel('Price')
plt.legend()
plt.show()
 
# 应用九：编程优化
# 示例1：快速幂算法
def fast_power(base, exponent, mod=None):
    """
    快速幂算法
    :param base: 底数
    :param exponent: 指数
    :param mod: 如果需要取模，则提供模数
    :return: base 的 exponent 次幂（如果需要取模，则返回取模后的结果）
    """
    result = 1
    base = base % mod if mod else base
    while exponent > 0:
        # 如果指数为奇数，则乘以底数
        if exponent % 2 == 1:
            result = (result * base) % mod if mod else result * base
        # 底数平方
        base = (base * base) % mod if mod else base * base
        # 指数减半
        exponent //= 2
    return result
# 示例
base = 2
exponent = 10
print(f"{base} 的 {exponent} 次幂是 {fast_power(base, exponent)}")
# 带有取模的快速幂
base = 2
exponent = 100000000
mod = 1000000007
print(f"{base} 的 {exponent} 次幂模 {mod} 的结果是 {fast_power(base, exponent, mod)}")
# 2 的 10 次幂是 1024
# 2 的 100000000 次幂模 1000000007 的结果是 494499948
 
# 示例2：优化循环中的幂运算
# 假设我们有一个列表，并且我们想要计算列表中每个元素的平方
numbers = [1, 2, 3, 4, 5]
# 不优化的方法：在循环中计算平方
squares_slow = []
for num in numbers:
    squares_slow.append(num ** 2)
# 优化的方法：使用列表推导式和内置的pow()函数(尽管在这个简单例子中，** 更快)
squares_fast = [num ** 2 for num in numbers]
# 或者，如果你确实想使用pow()函数
squares_fast_pow = [pow(num, 2) for num in numbers]
print("不优化的方法结果:", squares_slow)
print("优化的方法结果:", squares_fast)
print("使用pow()函数优化的方法结果:", squares_fast_pow)
# 不优化的方法结果: [1, 4, 9, 16, 25]
# 优化的方法结果: [1, 4, 9, 16, 25]
# 使用pow()函数优化的方法结果: [1, 4, 9, 16, 25]

1-2、VBA：

略，待后补。

2、推荐阅读：

2-1、Python-VBA函数之旅-open()函数

Python算法之旅：Algorithm

Python函数之旅：Functions

个人主页：神奇夜光杯-CSDN博客