Python教程：从字符串中高效提取数值列表的最大值与最小值

numbers_str = "8 3 -5 42 -1 0 0 -9 4 7 4 -4"
# 使用split()方法按空格拆分字符串
list_of_num_strings = numbers_str.split()
print(f"拆分后的字符串列表: {list_of_num_strings}")
# 输出: 拆分后的字符串列表: ['8', '3', '-5', '42', '-1', '0', '0', '-9', '4', '7', '4', '-4']

# 使用map()函数将字符串列表转换为整数列表
list_of_integers = list(map(int, list_of_num_strings))
print(f"转换为整数后的列表: {list_of_integers}")
# 输出: 转换为整数后的列表: [8, 3, -5, 42, -1, 0, 0, -9, 4, 7, 4, -4]

min_value = min(list_of_integers)
max_value = max(list_of_integers)
print(f"最小值: {min_value}, 最大值: {max_value}")
# 输出: 最小值: -9, 最大值: 42

sorted_list = sorted(list_of_integers)
min_value_sorted = sorted_list[0]
max_value_sorted = sorted_list[-1]
print(f"排序后最小值: {min_value_sorted}, 最大值: {max_value_sorted}")
# 输出: 排序后最小值: -9, 最大值: 42

# 使用f-string格式化输出
result_string = f"{max_value} {min_value}"
print(f"最终结果字符串: {result_string}")
# 输出: 最终结果字符串: 42 -9

def high_and_low(numbers_str: str) -> str:
    """
    从一个包含空格分隔数字的字符串中找出最大值和最小值，
    并以“最大值 最小值”的字符串格式返回。

    Args:
        numbers_str: 一个包含空格分隔整数的字符串，例如 "8 3 -5 42"

    Returns:
        一个字符串，包含最大值和最小值，用空格分隔，例如 "42 -5"
    """
    # 1. 拆分字符串获取数字字符串列表
    list_of_num_strings = numbers_str.split()

    # 2. 将字符串转换为整数列表
    # 这里使用列表推导式，效果等同于list(map(int, ...))，且更具Pythonic风格
    list_of_integers = [int(num_str) for num_str in list_of_num_strings]

    # 3. 查找最大值和最小值
    max_value = max(list_of_integers)
    min_value = min(list_of_integers)

    # 4. 格式化结果字符串并返回
    return f"{max_value} {min_value}"

# 测试函数
test_string = "8 3 -5 42 -1 0 0 -9 4 7 4 -4"
output = high_and_low(test_string)
print(f"输入: '{test_string}'")
print(f"输出: '{output}'")

test_string_2 = "1 2 3 4 5"
output_2 = high_and_low(test_string_2)
print(f"输入: '{test_string_2}'")
print(f"输出: '{output_2}'")

test_string_3 = "-1 -2 -3 -4 -5"
output_3 = high_and_low(test_string_3)
print(f"输入: '{test_string_3}'")
print(f"输出: '{output_3}'")

num_string = "8 3 -5 42 -1 0 0 9 4 7 4 -4 42 -9"
# 1. split() 拆分字符串
# 2. map(int, ...) 转换为整数迭代器
# 3. sorted(...) 对整数进行排序，得到一个有序列表
# 4. num_min, *_, num_max = ... 将排序后的列表解包
#    num_min 得到第一个元素（最小值）
#    num_max 得到最后一个元素（最大值）
#    *_: 这是一个“星号表达式”，用于捕获中间的所有元素并丢弃（赋值给一个不使用的变量名 `_`）
num_min, *_, num_max = sorted(map(int, num_string.split()))
print(f"使用解构赋值的最小值: {num_min}, 最大值: {num_max}")
print(f"格式化输出: {num_max} {num_min}")

def high_and_low_robust(numbers_str: str) -> str:
    if not numbers_str.strip(): # 检查是否为空字符串或只包含空白字符
        return "" # 或根据需求返回特定错误信息

    list_of_num_strings = numbers_str.split()
    list_of_integers = []
    for num_str in list_of_num_strings:
        try:
            list_of_integers.append(int(num_str))
        except ValueError:
            # 忽略无效数字，或抛出自定义错误，或记录日志
            print(f"警告: '{num_str}' 不是一个有效的整数，已跳过。")
            continue

    if not list_of_integers: # 检查是否所有数字都无效
        return "" # 或返回特定错误信息

    max_value = max(list_of_integers)
    min_value = min(list_of_integers)
    return f"{max_value} {min_value}"

print(f"健壮函数测试: {high_and_low_robust('1 2 abc 4')}") # 输出: 警告... 4 1
print(f"健壮函数测试: {high_and_low_robust('')}") # 输出: 
print(f"健壮函数测试: {high_and_low_robust('   ')}") # 输出: 
print(f"健壮函数测试: {high_and_low_robust('abc def')}") # 输出: 警告... 警告... 

def high_and_low_float(numbers_str: str) -> str:
    list_of_floats = [float(num_str) for num_str in numbers_str.split()]
    max_value = max(list_of_floats)
    min_value = min(list_of_floats)
    return f"{max_value} {min_value}"

print(f"浮点数测试: {high_and_low_float('1.5 2.3 -0.5 4.0')}") # 输出: 2.3 -0.5