Python教程：寻找浮点数列表的最小公倍乘数以转换为整数

def get_simplified_denominators(my_list):
    """
    为浮点数列表中的每个元素提取并简化其最简分母。
    """
    denominators = []
    for item in my_list:
        # 将浮点数转换为字符串，分离整数部分和小数部分
        splitted_item = str(item).split('.')
        # 整数部分
        int_part = splitted_item[0]
        # 小数部分
        fraction_part = ""
        if len(splitted_item) > 1:
            fraction_part = splitted_item[1]

        # 初始分母是10的len(fraction_part)次幂
        # 初始分子是 item * d
        d = 10**len(fraction_part)
        int_item = int(round(d * item)) # 使用round处理浮点数精度问题

        # 持续通过因子2简化分子和分母
        while int_item % 2 == 0 and d % 2 == 0:
            int_item //= 2
            d //= 2
        # 持续通过因子5简化分子和分母
        while int_item % 5 == 0 and d % 5 == 0:
            int_item //= 5
            d //= 5

        denominators.append(int(d))
    return denominators

def get_simplified_denominators_optimized(my_list):
    """
    优化版：为浮点数列表中的每个元素提取并简化其最简分母。
    通过跟踪2和5的因子幂次来避免大数运算。
    """
    denominators = []
    for item in my_list:
        splitted_item = str(item).split('.')
        int_part_str = splitted_item[0]
        fraction_part_str = ""
        if len(splitted_item) > 1:
            fraction_part_str = splitted_item[1]

        # 初始分母是 2^p2 * 5^p5 的形式
        # p2_initial 和 p5_initial 都是小数部分的长度
        p2_initial = len(fraction_part_str)
        p5_initial = len(fraction_part_str)

        # 将整数部分和小数部分拼接成一个字符串，代表原始分数的分子
        numerator_str = int_part_str + fraction_part_str

        # 统计分子字符串末尾的2和5的因子，减少分母的2和5的幂次
        temp_numerator = int(numerator_str) # 转换为整数进行除法

        # 减少2的幂次
        while p2_initial > 0 and temp_numerator % 2 == 0:
            temp_numerator //= 2
            p2_initial -= 1

        # 减少5的幂次
        while p5_initial > 0 and temp_numerator % 5 == 0:
            temp_numerator //= 5
            p5_initial -= 1

        # 最终的最简分母是 2^p2_initial * 5^p5_initial
        min_d_amount = (2**p2_initial) * (5**p5_initial)
        denominators.append(min_d_amount)
    return denominators

from math import gcd as get_gcd

def calculate_lcm_of_list(numbers):
    """
    计算列表中所有数字的最小公倍数（LCM）。
    """
    if not numbers:
        return 1 # 空列表的LCM可以视为1

    lcm_result = numbers[0]
    for i in range(1, len(numbers)):
        lcm_result = (lcm_result * numbers[i]) // get_gcd(lcm_result, numbers[i])
    return lcm_result

def apply_multiplier(original_list, multiplier):
    """
    将列表中的所有元素乘以给定的乘数。
    """
    return [item * multiplier for item in original_list]

import math

def get_simplified_denominators_optimized(my_list):
    """
    优化版：为浮点数列表中的每个元素提取并简化其最简分母。
    通过跟踪2和5的因子幂次来避免大数运算。
    """
    denominators = []
    for item in my_list:
        # 对于整数，其分母为1
        if item == int(item):
            denominators.append(1)
            continue

        splitted_item = str(item).split('.')
        int_part_str = splitted_item[0]
        fraction_part_str = splitted_item[1]

        p2_initial = len(fraction_part_str)
        p5_initial = len(fraction_part_str)

        numerator_str = int_part_str + fraction_part_str
        temp_numerator = int(numerator_str) 

        while p2_initial > 0 and temp_numerator % 2 == 0:
            temp_numerator //= 2
            p2_initial -= 1

        while p5_initial > 0 and temp_numerator % 5 == 0:
            temp_numerator //= 5
            p5_initial -= 1

        min_d_amount = (2**p2_initial) * (5**p5_initial)
        denominators.append(min_d_amount)
    return denominators

def calculate_lcm_of_list(numbers):
    """
    计算列表中所有数字的最小公倍数（LCM）。
    """
    if not numbers:
        return 1 

    lcm_result = numbers[0]
    for i in range(1, len(numbers)):
        lcm_result = (lcm_result * numbers[i]) // math.gcd(lcm_result, numbers[i])
    return lcm_result

def find_lowest_multiplier_and_convert(float_list):
    """
    找到将浮点数列表所有元素转换为整数的最小乘数，并返回转换后的列表。
    """
    if not float_list:
        return 1, []

    # 步骤一：提取并简化分母
    denominators = get_simplified_denominators_optimized(float_list)
    print(f"原始列表: {float_list}")
    print(f"提取的简化分母: {denominators}")

    # 步骤二：计算所有简化分母的最小公倍数 (LCM)
    lowest_multiplier = calculate_lcm_of_list(denominators)
    print(f"最小公倍数 (LCM): {lowest_multiplier}")

    # 步骤三：应用最小公倍数
    converted_list = [item * lowest_multiplier for item in float_list]
    print(f"转换后的列表: {converted_list}")

    return lowest_multiplier, converted_list

# 运行示例
my_float_list = [2.25, 3.5]
multiplier, new_list = find_lowest_multiplier_and_convert(my_float_list)
# 预期输出:
# 原始列表: [2.25, 3.5]
# 提取的简化分母: [4, 2]
# 最小公倍数 (LCM): 4
# 转换后的列表: [9.0, 14.0] (注意浮点数乘法结果仍是浮点数，但值是整数)

print("\n--- 另一个示例 ---")
my_float_list_2 = [0.125, 0.75, 1.5]
multiplier_2, new_list_2 = find_lowest_multiplier_and_convert(my_float_list_2)
# 0.125 = 1/8 -> 分母 8
# 0.75 = 3/4 -> 分母 4
# 1.5 = 3/2 -> 分母 2
# LCM(8, 4, 2) = 8
# 预期输出: 8, [1.0, 6.0, 12.0]