深圳杯数学建模大赛Python知识点

当条件过于严格或目标函数的定义不当时，优化过程可能会遇到困难，导致无法找到可行解或过早地停止在非最优解上。为解决这些问题，给出了几种策略，如调整初始猜测值、放宽约束条件、修改目标函数等。在某些情况下，增加优化次数或检查数值不稳定性也可能是有效的解决方案。概述了如何导入numpy库、创建numpy数组、访问和修改numpy数组等基础知识。

中心主题

• 导入必要的库
  • 导入必要的数据
    • 问题3残骸位置和音爆时间true_positions_and_times
    • 问题3检测设备位置stations
    • 双循环得到列表的每个元素
      • 都进行解包
        • 计算残骸和设备的距离distance
          • 计算预测时间 arrival_time = t0 + distance / speed_of_sound
            • 得到音爆抵达时间并返回
              • 传入参数
                • 子主题
    • 音速speed_of_sound
• 可存储多维数组
  • 元组
  • 列表
  • 解包操作
    • 遍历
      • a,b,c,d = list #/tuple
        • # 问题3中给出的监测设备位置 stations = [ (110.241, 27.204, 824), (110.783, 27.456, 727), (110.762, 27.785, 742), (110.251, 28.025, 850), (110.524, 27.617, 786), (110.467, 28.081, 678), (110.047, 27.521, 575) ] speed_of_sound = 340 # m/s def calculate_arrival_times(true_positions_and_times, stations): arrival_times = [] for station in stations: station_times = [] for true_position in true_positions_and_times: lon, lat, alt, t0 = true_position s_lon, s_lat, s_alt = station distance = np.sqrt((lon - s_lon) ** 2 * 97.304**2 + (lat - s_lat) ** 2 * 111.263**2 + (alt - s_alt) ** 2) arrival_time = t0 + distance / speed_of_sound station_times.append(arrival_time) arrival_times.append(station_times) return arrival_times
• 最小二乘法
  • from scipy.optimize import least_squares
  • result = least_squares(residuals, initial_guess, args=(stations, arrival_times))
    • residuals：残差（预测减真实）
    • initial_guess：初始预测值
    • args=(stations, arrival_times)：传入必要的数据
    • 自动传入：px, py, pz, t = x 的x 作为预测值、
    • return result.x ：返回优化后的值
• Python的numpy库的相关语法以及作用
  • 导入numpy库
    • 使用import numpy as np语句导入numpy库
      • np是numpy的别名，方便在代码中使用numpy库
      • import numpy as np # 现在可以使用np作为numpy的别名来调用numpy库中的函数
      • from numpy import * # 现在可以直接使用numpy库中的所有函数，而无需前缀
    • 使用from numpy import *语句导入numpy库中的所有函数
      • 可以在代码中直接使用numpy库中的所有函数
  • 创建numpy数组
    • 使用numpy的array函数创建numpy数组
      • array函数接受一个列表作为参数，返回一个numpy数组
      • import numpy as np array1 = np.array([1, 2, 3, 4]) print(array1) # 输出：[1 2 3 4]
      • import numpy as np array3d = np.array([ [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[10, 11, 12], [13, 14, 15], [16, 17, 18]], [[19, 20, 21], [22, 23, 24], [25, 26, 27]] ]) # 访问第二个二维数组中的第一个一维数组的第一个元素 print(array3d[1, 0, 0]) # 输出 10
    • 使用numpy的zeros函数创建全0数组
      • zeros函数接受一个元组作为参数，返回一个指定形状的全0数组
      • import numpy as np zeros_array = np.zeros((2, 3)) print(zeros_array) # 输出： # [[0. 0. 0.] # [0. 0. 0.]]
    • 使用numpy的ones函数创建全1数组
      • ones函数接受一个元组作为参数，返回一个指定形状的全1数组
      • import numpy as np ones_array = np.ones((2, 3)) print(ones_array) # 输出： # [[1. 1. 1.] # [1. 1. 1.]]
    • 使用numpy的full函数创建指定值的数组
      • full函数接受一个元组和一个值作为参数，返回一个指定形状的指定值数组
  • 访问numpy数组
    • 使用索引访问numpy数组的元素
      • 可以使用索引访问numpy数组中的任意元素
    • 使用切片访问numpy数组的子数组
      • 可以使用切片访问numpy数组中的任意子数组
  • 修改numpy数组
    • 使用索引修改numpy数组的元素
      • 可以使用索引修改numpy数组中的任意元素
      • import numpy as np array3d = np.array([ [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[10, 11, 12], [13, 14, 15], [16, 17, 18]], [[19, 20, 21], [22, 23, 24], [25, 26, 27]] ]) # 修改第二个二维数组中的第一个一维数组的第一个元素 array3d[1, 0, 0] = 100 print(array3d)
    • 使用切片修改numpy数组的子数组
      • 可以使用切片修改numpy数组中的任意子数组
  • 计算numpy数组
    • 使用numpy的sum函数计算numpy数组的和
      • sum函数接受一个numpy数组作为参数，返回一个包含所有元素和的数组
    • 使用numpy的mean函数计算numpy数组的平均值
      • mean函数接受一个numpy数组作为参数，返回一个包含所有元素平均值的数组
    • 使用numpy的max函数计算numpy数组的最大值
      • max函数接受一个numpy数组作为参数，返回一个包含所有元素最大值的数组
    • 使用numpy的min函数计算numpy数组的最小值
      • min函数接受一个numpy数组作为参数，返回一个包含所有元素最小值的数组;
• 实现为某数组添加随机误差 （存在0.5 s的随机误差）
  • import numpy as np stations = {'A': (110.241, 27.204, 824, [100.767, 164.229, 214.85, 270.065]), 'F': (110.467, 28.081, 678, [67.274, 166.27, 175.482, 266.871]), 'B': (110.783, 27.456, 727, [92.453, 112.22, 169.362, 196.583]), 'D': (110.251, 28.025, 850, [94.653, 141.409, 196.517, 258.985])} def add_random_errors(times): # 生成随机误差 random_errors = np.random.uniform(-0.5, 0.5, times.shape) # 将随机误差添加到原始时间数据上 times_with_errors = times + random_errors # # 将结果转换回列表并返回 # return times_with_errors.tolist() result = add_random_errors(np.array([100.767, 164.229, 14.85, 270.065])) print(result)
• 双循环：初次循环每遍历一次就进入下一次循环 （循环实现：遍历可迭代对象的元素进行操作 ）
  • for station in stations:
    • 设备a
      • for true_position in true_positions_and_times:
        • 音爆点1
        • 2
        • 3
        • 4
        • 得到实际到达时间1
    • b
    • c
    • d
    • e
    • f
    • g
    • 7个设备实际的音爆抵达时间
• 定义函数
  • def 函数名（变量名（形参）） 对变量进行操作并返回或打印 调用+传参（打印）
  • 调用函数必须在定义函数的同模块
• zip(a,b)
  • 将俩个可迭代对象的元素分别用：拼在一起，形成一个一个元组
• 优化失败的原因可能有多种，包括初始猜测值不合理、约束条件过于严格、目标函数的定义不当等。我们可以尝试以下方法来解决这个问题： 调整初始猜测值：选择更接近预期结果的初始猜测值。 放宽约束条件：检查约束条件是否过于严格，可以适当放宽。 修改目标函数：检查目标函数是否定义正确，有无逻辑错误。 增加优化次数：增大优化的最大迭代次数，确保优化算法有足够的时间收敛。
  • 惩罚项的值过于严格可能会导致优化过程难以找到可行解，或者导致优化过程过早地停止在非最优解上。具体而言，这会导致以下几种情况： 优化失败：惩罚项过于严格会使得几乎所有可能的解都被排除，从而导致优化算法无法找到任何满足条件的解。这可能会导致 solution.success 返回 False，并且最终导致我们无法获得任何有效的测量结果。 局部最优解：严格的惩罚项可能会引导优化算法过早地停在局部最优解，而不是全局最优解。这是因为惩罚项过大可能会强制优化算法在某些参数范围内停止搜索，而这些范围内的解可能并不是最优的。 数值不稳定性：过大的惩罚项可能会引入数值不稳定性，尤其是当惩罚项的值远大于目标函数中的其他项时。这可能会导致优化算法在计算过程中出现数值误差，从而影响最终结果的准确性。
• 嵌套函数
  • def make_fruit_salad(fruits): def cut_fruit(fruit): # 内部函数，用于切水果 print(f"切 {fruit}") return f"{fruit} 切块" def mix_fruits(cut_fruits): # 内部函数，用于混合切好的水果 print(f"混合 {cut_fruits}") return f"混合好的水果沙拉" # 切所有的水果 cut_fruits = [cut_fruit(fruit) for fruit in fruits] #调用并通过列表推导式传入参数 # 混合切好的水果 fruit_salad = mix_fruits(cut_fruits) return fruit_salad fruits = ["苹果", "香蕉", "橙子"] salad = make_fruit_salad(fruits) print(salad)
  • what: 一个函数内部定义另一个函数
  • why: 封装： 嵌套函数可以将辅助函数隐藏在主要函数内部，从而防止它们在全局范围内被访问或调用。这有助于减少命名冲突和提升代码的可读性。 作用域管理: 嵌套函数可以访问外部函数的变量，但这些变量对外部函数之外的代码是不可见的。这有助于管理变量的作用域，避免变量污染全局命名空间。 逻辑分离： 嵌套函数可以将复杂的任务分解为更小、更易管理的子任务。每个子任务由一个内部函数处理，从而使代码更易于理解和维护。 闭包： 嵌套函数可以形成闭包，闭包是指内部函数可以记住并访问它们被定义时的外部函数的变量。这使得函数可以携带其作用域上下文，从而实现更强的功能。
  • when: 什么时候使用 辅助函数： 当一个函数需要多个辅助函数来完成一个复杂任务时，可以将这些辅助函数定义为嵌套函数。例如，在数据处理、计算和格式化过程中，辅助函数可以被嵌套在主要函数内部。 临时函数： 当某个函数只在特定函数内部使用时，可以将其定义为嵌套函数，以保持其作用范围有限。 闭包和回调： 在需要使用闭包或回调函数时，可以通过嵌套函数来实现。例如，在事件处理和异步编程中，嵌套函数可以捕获和保存其创建时的环境。
  • how