跟着查老四学Python Day 2：控制结构与循环

老猫：这是之前我们制定的第二天的学习计划

第二天：控制结构与循环

1. 学习条件判断（if-elif-else结构）
2. 学习循环结构（for循环、while循环）
3. 学习列表（list）和元组（tuple）的基本操作
4. 动手编写一些涉及条件判断和循环的Python程序，加深对这些概念的理解

我们要不开始今天的学习，或者说，你这边需要根据第一天的进展调整内容和进度吗

查老四：抱歉刚刚的回复中有误，感谢您提醒。现在我们按照第二天的学习计划进行，即学习控制结构与循环。

根据第一天的进展，我们可以按照原计划进行。以下是今天的学习内容：

第二天：控制结构与循环

1. 学习条件判断（if-elif-else结构）
2. 学习循环结构（for循环、while循环）
3. 学习列表（list）和元组（tuple）的基本操作
4. 动手编写一些涉及条件判断和循环的Python程序，加深对这些概念的理解

请告诉我您是否准备好开始学习这些内容，我将为您提供相应的学习材料和示例。祝您学习愉快！

条件判断（if-elif-else结构）

老猫：我准备好了，请开始，我希望每次你讲其中一节，比如接下来就讲“学习条件判断（if-elif-else结构）” 给出定义和示范，然后给我一个具体的代码样例，我看明白之后你给我练习，确定我练习也完成之后，我们再进入到下一节，请放慢节奏，毕竟我们每天的学习时间至少有三个小时，谢谢。

查老四：当然可以！我们将按照您的要求逐步进行。现在，让我们开始学习条件判断（if-elif-else结构）。

学习条件判断（if-elif-else结构）

在 Python 中，条件判断语句用于根据条件执行不同的代码块。最基本的条件判断语句是 if 语句。if 语句后面跟着一个条件表达式，如果该条件表达式的值为 True，则执行紧跟在 if 语句后面的代码块。除此之外，还可以使用 elif（else if 的简写）和 else 语句来处理多个条件。

以下是 if-elif-else 结构的基本语法

if condition1:
    # code block for condition1
elif condition2:
    # code block for condition2
else:
    # code block if none of the conditions are True

以下是一个简单的示例，根据输入的成绩判断等级：

score = int(input("请输入您的成绩："))

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"

print(f"您的等级是：{grade}")

在这个示例中，我们首先获取用户输入的成绩，然后使用 if-elif-else 结构根据成绩判断等级，并将等级赋值给变量 grade。最后，我们输出等级结果。

现在，请您阅读和理解上述代码示例。如果您有任何疑问，请随时向我提问。当您准备好进行练习时，请告诉我，我将为您提供一些练习题来巩固这部分知识。

老猫：我想问一下，在 python中空格 缩进 换行有讲究吗，比如缩进一般是缩几个空格，是否可以使用tab健

查老四：在 Python 中，缩进和换行具有特殊的意义。它们用于表示代码块的边界。代码块是一系列按顺序执行的语句，可以是函数体、循环体、条件语句等。Python 使用缩进（空格或制表符）来表示代码块，而不是其他语言中常用的大括号（{ }）。

关于缩进，有以下几点需要注意：

1. Python 官方建议使用 4 个空格作为缩进。虽然也可以使用其他数量的空格或制表符（Tab 键），但使用 4 个空格是最佳实践，因为它可以保持代码的可读性和一致性。
2. 在同一代码块中，所有行的缩进量必须相同。否则，Python 会抛出缩进错误。
3. 请勿在同一个文件中混用空格和制表符进行缩进，这会导致不可预测的结果。大多数代码编辑器和集成开发环境（IDE）可以配置为使用空格替代制表符，或者在按下 Tab 键时插入指定数量的空格。
4. Python 中的换行符用于分隔语句。在大多数情况下，每行代码包含一个独立的语句。然而，在某些情况下，如列表、元组或字典的声明，您可能需要将一个语句拆分成多行以提高可读性。在这种情况下，可以使用圆括号、方括号或花括号来包裹多行语句，或者使用反斜杠（\）表示行的延续。

下面是一个多行语句的例子：

my_list = [
    1,
    2,
    3,
    4,
    5,
]

希望这些信息对您有所帮助。如果您有其他问题，请随时提问。如果您准备好进行条件判断的练习，请告诉我。祝学习愉快！

老猫：请给我练习吧

查老四：当然，以下是一些关于条件判断（if-elif-else 结构）的练习题：

练习1：编写一个程序，根据输入的数字判断它是正数、负数还是零。

练习2：编写一个程序，判断输入的年份是否是闰年。闰年的条件如下：

• 能被4整除，但不能被100整除；
• 能被400整除。

练习3：编写一个程序，找出输入的三个数字中的最大值。

练习4：编写一个程序，根据输入的成绩，给出以下评级：

• 90分及以上：优秀
• 80分（含）至90分：良好
• 70分（含）至80分：一般
• 60分（含）至70分：及格
• 60分以下：不及格

请先尝试完成这些练习。如果您在完成练习过程中遇到困难或需要查看答案，请随时告诉我。祝您学习愉快

练习1

可以使用Python的条件语句if-elif-else来实现根据输入的数字判断它是正数、负数还是零。代码如下：

num = float(input("请输入一个数字："))

if num > 0:
    print(f"{num} 是正数")
elif num < 0:
    print(f"{num} 是负数")
else:
    print(f"{num} 是零")

首先，使用input()函数获取用户输入的数字，并将其转换为float类型。然后使用if-elif-else语句进行判断，如果num大于0，则打印“输入的数字为正数”，如果num小于0，则打印“输入的数字为负数”，否则打印“输入的数字为零”。

练习2：

可以使用以下条件来判断一个年份是否是闰年：

1. 如果该年份能被4整除但不能被100整除，则是闰年；
2. 如果该年份能被400整除，则也是闰年。

根据上述条件，可以编写如下Python程序来判断输入的年份是否是闰年：

year = int(input("请输入一个年份："))

if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print(f"{year} 是闰年")
else:
    print(f"{year} 不是闰年")

首先，使用input()函数获取用户输入的年份，并将其转换为int类型。然后，使用if-else语句进行判断，如果年份能够同时被4整除且不能被100整除，或者能够被400整除，则输出“是闰年”，否则输出“不是闰年”。

练习3

可以使用Python的条件语句和比较运算符来实现找出输入的三个数字中的最大值。代码如下：

num1 = float(input("请输入第一个数字："))
num2 = float(input("请输入第二个数字："))
num3 = float(input("请输入第三个数字："))

if num1 >= num2 and num1 >= num3:
    max_num = num1
elif num2 >= num1 and num2 >= num3:
    max_num = num2
else:
    max_num = num3

print(f"输入的三个数字中的最大值为：{max_num}")

首先，使用input()函数获取用户输入的三个数字，并将其转换为float类型。然后，使用if-elif-else语句进行判断，如果num1大于等于num2且大于等于num3，则max_num为num1；如果num2大于等于num1且大于等于num3，则max_num为num2；否则max_num为num3。最后，使用print()函数输出结果。

练习4 （略）

对了一下答案，前两个练习都一样，第三题查老四给出的是：

num1 = int(input("请输入第一个数字："))
num2 = int(input("请输入第二个数字："))
num3 = int(input("请输入第三个数字："))

max_num = num1

if num2 > max_num:
    max_num = num2
if num3 > max_num:
    max_num = num3

print(f"最大值为：{max_num}")

老猫：练习三，我的代码是

num1 = float(input("请输入第一个数字："))
num2 = float(input("请输入第二个数字："))
num3 = float(input("请输入第三个数字："))

if num1 >= num2 and num1 >= num3:
    max_num = num1
elif num2 >= num1 and num2 >= num3:
    max_num = num2
else:
    max_num = num3

print(f"输入的三个数字中的最大值为：{max_num}")

请和你的代码做个对比，哪一个更规范一点

查老四：两个解决方案都是正确的，它们仅在实现方式上略有不同。您的代码使用了逻辑表达式 and 来组合多个条件，这使得代码更具可读性。另外，您的代码使用了 float 类型来接收用户输入的数字，这允许您处理浮点数，而我的代码仅接受整数。这种方法在有需要处理实数的情况下更具通用性。

所以，从通用性和可读性的角度来看，您的代码可能更具优势。但请注意，两个解决方案都是有效的，您可以根据自己的喜好和需要选择适当的解决方案。

循环结构（for循环、while循环）

老猫：好的，这一节内容没问题了，我们可以继续下一节 “学习循环结构（for循环、while循环）”

很好，接下来我们将学习 Python 中的两种主要循环结构：for 循环和 while 循环。

for 循环：for 循环通常用于在一定范围内（例如列表、元组或字符串中的每个元素）进行迭代。for 循环的基本语法如下：

for variable in iterable:
    # 循环体（需要执行的代码）

示例

# 定义一个列表
fruits = ['apple', 'banana', 'orange', 'grape']

# 使用 for 循环遍历列表中的每个元素
for fruit in fruits:
    # 在循环体内，打印当前元素
    print(fruit)

while 循环：while 循环在指定条件为真（True）时重复执行。while 循环的基本语法如下：

while condition:
    # 循环体（需要执行的代码）

示例

# 初始化计数器变量
counter = 0

# 当计数器的值小于 5 时，执行循环体
while counter < 5:
    # 在循环体内，打印当前计数器的值
    print(counter)
    # 计数器值加 1
    counter += 1

接下来，我将为您提供一些涉及 for 循环和 while 循环的示例代码。请您阅读并理解这些示例，然后我会给您提供一些练习题。

示例代码基本和讲解部分一致，开始出练习题

老猫：请给我出练习题吧，不要和之前的示例有重复

查老四：好的，以下是一些涉及 for 循环和 while 循环的练习题：

练习1：编写一个程序，使用 for 循环计算 1 到 10（包含）之间所有偶数的和。

练习2：编写一个程序，使用 while 循环计算 1 到 10（包含）之间所有奇数的和。

练习3：编写一个程序，使用 for 循环遍历一个字符串，统计字符串中大写字母和小写字母的个数。

练习4：编写一个程序，使用 while 循环生成一个斐波那契数列（Fibonacci sequence），要求生成的数列包含前 10 个斐波那契数。

请尝试完成这些练习，如果您在编写代码过程中遇到任何问题，请随时向我提问。完成练习后，我可以为您提供答案和解释

练习1：

以下是使用for循环计算1到10之间所有偶数的和的Python程序，它使用了一个变量sum来累加偶数。在每次迭代中，如果当前数字是偶数，则将其添加到sum变量中：

sum = 0

for i in range(1, 11):
    if i % 2 == 0:
        sum += i

print(f"The sum of even numbers between 1 to 10 is {sum}")

输出：The sum of even numbers between 1 to 10 is 30

练习2：

以下是使用while循环计算1到10之间所有奇数的和的Python程序，它使用了一个变量sum来累加奇数。在每次迭代中，如果当前数字是奇数，则将其添加到sum变量中：

sum = 0
i = 1

while i <= 10:
    if i % 2 != 0:
        sum += i
    i += 1

print(f"The sum of odd numbers between 1 to 10 is {sum}")

输出：The sum of odd numbers between 1 to 10 is 25

练习 3

以下是一个统计字符串中大写字母和小写字母个数的Python程序，它使用了for循环遍历字符串，并使用isupper()和islower()方法检查每个字符是否为大写或小写字母。如果是，则相应的计数器会增加：

string = "Hello World"
uppercase_count = 0
lowercase_count = 0

for char in string:
    if char.isupper():
        uppercase_count += 1
    elif char.islower():
        lowercase_count += 1

print(f"Number of uppercase letters: {uppercase_count}")
print(f"Number of lowercase letters: {lowercase_count}")

输出：

Number of uppercase letters: 2
Number of lowercase letters: 8

练习4：

以下是使用while循环生成斐波那契数列的Python程序，它使用两个变量a和b来跟踪数列中的前两个数字，并使用while循环生成指定数量的斐波那契数：

a = 0
b = 1
count = 0

print("Fibonacci sequence:")

while count < 10:
    print(a, end=" ")
    nth = a + b
    # 更新变量
    a = b
    b = nth
    count += 1

输出：

Fibonacci sequence:
0 1 1 2 3 5 8 13 21 34

老猫：练习答案公布一下，请做好注释

查老四：以下是带有注释的练习答案：

练习1

# 初始化和变量
even_sum = 0

# 使用 for 循环遍历 1 到 10（包含）之间的整数
for i in range(1, 11):
    # 判断当前整数是否为偶数
    if i % 2 == 0:
        # 如果是偶数，将其加到 even_sum 中
        even_sum += i

# 输出偶数和
print(f"1 到 10 之间所有偶数的和为：{even_sum}")

练习2

# 初始化和变量
odd_sum = 0
# 初始化计数器
counter = 1

# 使用 while 循环，当计数器小于等于 10 时执行循环体
while counter <= 10:
    # 判断计数器是否为奇数
    if counter % 2 == 1:
        # 如果是奇数，将其加到 odd_sum 中
        odd_sum += counter
    # 计数器加 1
    counter += 1

# 输出奇数和
print(f"1 到 10 之间所有奇数的和为：{odd_sum}")

练习3

# 定义一个字符串
text = "Hello, World! This is a Python Program."

# 初始化计数器变量
upper_count = 0
lower_count = 0

# 使用 for 循环遍历字符串中的每个字符
for char in text:
    # 判断字符是否为大写字母
    if char.isupper():
        upper_count += 1
    # 判断字符是否为小写字母
    elif char.islower():
        lower_count += 1

# 输出大写字母和小写字母的数量
print(f"字符串中的大写字母数量：{upper_count}")
print(f"字符串中的小写字母数量：{lower_count}")

练习4

# 初始化斐波那契数列的前两个数字
num1, num2 = 0, 1
# 初始化计数器
counter = 0

# 使用 while 循环，当计数器小于 10 时执行循环体
while counter < 10:
    # 输出当前斐波那契数
    print(num1, end=" ")
    # 计算下一个斐波那契数
    num1, num2 = num2, num1 + num2
    # 计数器加 1
    counter += 1

列表和元素

貌似会话的token超标了，所以另外起了一个会话，风格可能有些变化，后续得进行调教

查老四：好的，既然你已经学到了第二天的第三个内容，我们就从学习列表（list）和元组（tuple）的基本操作开始。请确保你已经熟悉了条件判断和循环结构。

1. 列表（list）： 列表是一种有序的、可变的数据结构，可以存储任意类型的元素。列表使用方括号（[]）表示。

创建列表

my_list = [1, 2, 3, 'apple', True]

列表的一些常见操作：

• 访问列表中的元素：my_list[0] 返回第一个元素，my_list[-1] 返回最后一个元素
• 修改列表中的元素：my_list[1] = 20 将第二个元素修改为20
• 添加元素：my_list.append('banana') 在列表末尾添加元素
• 删除元素：my_list.remove('apple') 删除指定元素，del my_list[0] 删除指定位置的元素
• 切片：my_list[1:4] 返回列表中从索引1（包含）到索引4（不包含）的子列表

2. 元组（tuple）： 元组是一种有序的、不可变的数据结构，可以存储任意类型的元素。元组使用圆括号（()）表示。

创建元组：

my_tuple = (1, 2, 3, 'apple', True)

元组的一些常见操作：

• 访问元组中的元素：my_tuple[0] 返回第一个元素，my_tuple[-1] 返回最后一个元素
• 切片：my_tuple[1:4] 返回元组中从索引1（包含）到索引4（不包含）的子元组

请注意，元组是不可变的，所以你不能修改、添加或删除元组中的元素。

现在，你可以尝试编写一些涉及条件判断和循环的Python程序，以加深对这些概念的理解。在编写程序时，尝试使用列表和元组来实现一些功能。祝你学习愉快！

老猫：请把列表的常见操作分别给个范例，并请做好注释

查老四：当然可以，以下是列表的常见操作的示例代码：

# 创建一个列表
my_list = [1, 2, 3, 'apple', True]
print("原始列表:", my_list)

# 访问列表中的元素
first_element = my_list[0]
print("列表中的第一个元素:", first_element)

last_element = my_list[-1]
print("列表中的最后一个元素:", last_element)

# 修改列表中的元素
my_list[1] = 20
print("修改后的列表:", my_list)

# 添加元素到列表末尾
my_list.append('banana')
print("在列表末尾添加元素:", my_list)

# 在指定位置插入元素
my_list.insert(2, 'orange')
print("在指定位置插入元素:", my_list)

# 删除指定元素
my_list.remove('apple')
print("删除指定元素后的列表:", my_list)

# 删除指定位置的元素
del my_list[0]
print("删除指定位置元素后的列表:", my_list)

# 切片操作
sub_list = my_list[1:4]
print("子列表:", sub_list)

# 求列表长度
length = len(my_list)
print("列表长度:", length)

# 列表排序（仅适用于相同类型的元素）
numbers = [3, 1, 4, 2, 5]
numbers.sort()
print("排序后的列表:", numbers)

# 反转列表
numbers.reverse()
print("反转后的列表:", numbers)

这些示例代码涵盖了列表的常见操作。你可以逐个运行这些示例，观察它们的输出，以加深对列表操作的理解。

老猫：元组基本操作的示例也给一些吧

查老四：当然可以，以下是元组的基本操作的示例代码：

# 创建一个元组
my_tuple = (1, 2, 3, 'apple', True)
print("原始元组:", my_tuple)

# 访问元组中的元素
first_element = my_tuple[0]
print("元组中的第一个元素:", first_element)

last_element = my_tuple[-1]
print("元组中的最后一个元素:", last_element)

# 切片操作
sub_tuple = my_tuple[1:4]
print("子元组:", sub_tuple)

# 求元组长度
length = len(my_tuple)
print("元组长度:", length)

# 元组中元素的个数
count = my_tuple.count(1)
print("元素 1 在元组中出现的次数:", count)

# 元素在元组中的索引
index = my_tuple.index('apple')
print("元素 'apple' 在元组中的索引:", index)

# 遍历元组
for item in my_tuple:
    print(item)

# 将元组转换为列表（可变的）
my_list = list(my_tuple)
print("将元组转换为列表:", my_list)

# 将列表转换为元组（不可变的）
new_tuple = tuple(my_list)
print("将列表转换为元组:", new_tuple)

这些示例代码涵盖了元组的基本操作。你可以逐个运行这些示例，观察它们的输出，以加深对元组操作的理解。请注意，元组是不可变的，因此它们没有像列表那样的修改、添加或删除元素的操作。

老猫：基本操作我大概知道了，能否分别给我一个代码范例，我看看在程序里怎么使用列表和元组

查老四：当然可以。下面分别给出一个列表和元组在程序中的使用示例。

示例1：使用列表

这个示例展示了如何使用列表来存储用户输入的一组整数，并计算它们的和与平均值。

# 获取用户输入的整数个数
num_count = int(input("请输入整数个数："))

# 使用列表存储输入的整数
num_list = []

# 获取用户输入的整数，并添加到列表中
for i in range(num_count):
    num = int(input(f"请输入第 {i + 1} 个整数："))
    num_list.append(num)

# 计算整数和与平均值
num_sum = sum(num_list)
num_avg = num_sum / num_count

# 输出结果
print(f"整数和为：{num_sum}")
print(f"平均值为：{num_avg}")

示例2：使用元组

这个示例展示了如何使用元组来表示一个点的二维坐标，并计算两点之间的欧氏距离。

import math

# 获取两个点的坐标
x1, y1 = float(input("请输入点1的x坐标：")), float(input("请输入点1的y坐标："))
x2, y2 = float(input("请输入点2的x坐标：")), float(input("请输入点2的y坐标："))

# 使用元组表示两个点的坐标
point1 = (x1, y1)
point2 = (x2, y2)

# 计算两点之间的欧氏距离
distance = math.sqrt((point2[0] - point1[0]) ** 2 + (point2[1] - point1[1]) ** 2)

# 输出结果
print(f"两点之间的距离为：{distance}")

老猫在notebook里运行第一段代码，报错了，询问了查老四 这个问题可能是由于在之前的代码中使用了变量名 sum，导致内置函数 sum被覆盖。请确保在您的代码中没有使用sum 作为变量名。要解决这个问题，您可以重启您的 Python 环境或者尝试在一个新的环境中运行

老猫：那请给我出练习题吧，练习题不要和之前的示例重复，谢谢

查老四：练习1：计算列表中正数的和

给定一个包含整数的列表，编写一个程序来计算其中所有正数的和。

# 示例列表
numbers = [1, -2, 3, 4, -5, 6, -7, 8, 9]

练习2：合并两个有序列表

给定两个升序排列的整数列表，编写一个程序将它们合并成一个新的升序排列的列表。

# 示例列表
list1 = [1, 3, 5, 7]
list2 = [2, 4, 6, 8]

练习3：元组元素交换

给定一个包含两个元素的元组，编写一个程序交换这两个元素的位置。

# 示例元组
my_tuple = (3, 5)

练习4：找出列表中最接近给定值的数

给定一个浮点数列表和一个目标值，编写一个程序找出列表中最接近目标值的数。

# 示例列表和目标值
float_numbers = [1.3, 3.5, 4.8, 7.2, 9.1]
target_value = 4.0

请尝试完成这些练习题，以巩固您对列表和元组概念的理解。如果您需要帮助或答案，请随时告诉我。祝您学习愉快！

练习 1

以下是计算列表中所有正数之和的Python程序，它使用for循环遍历整个列表，并将正数相加：

numbers = [1, -2, 3, 4, -5, 6, -7, 8, 9]

positive_sum = 0

for num in numbers:
    if num > 0:
        positive_sum += num

print(f"The sum of all positive numbers is: {positive_sum}")

输出：The sum of all positive numbers is: 31

练习 2

以下是将两个升序排列的整数列表合并为一个新的升序排列列表的Python程序，它使用while循环和指针来比较两个列表中的元素，并按顺序将它们添加到新列表中：

list1 = [1, 3, 5, 7]
list2 = [2, 4, 6, 8]

merged_list = []
i = 0
j = 0

while i < len(list1) and j < len(list2):
    if list1[i] < list2[j]:
        merged_list.append(list1[i])
        i += 1
    else:
        merged_list.append(list2[j])
        j += 1

# 将剩余的元素添加到合并的列表中
merged_list += list1[i:]
merged_list += list2[j:]

print(f"The merged sorted list is: {merged_list}")

输出：The merged sorted list is: [1, 2, 3, 4, 5, 6, 7, 8]

练习 3

以下是交换元组中两个元素位置的Python程序，它使用变量来存储原始元组中的值，然后将其赋值给新的元组：

my_tuple = (3, 5)
print(f"Original tuple: {my_tuple}")

# 解构元组并交换位置
a, b = my_tuple
new_tuple = (b, a)

print(f"Tuple after swapping: {new_tuple}")

输出：

Original tuple: (3, 5)
Tuple after swapping: (5, 3)

练习4

以下是找出浮点数列表中最接近目标值的数的Python程序，它使用for循环遍历列表并计算每个元素与目标值之间的差。然后使用abs()函数来计算差的绝对值，并使用min()函数找到最小的绝对差值，以确定最接近目标值的元素：

float_numbers = [1.3, 3.5, 4.8, 7.2, 9.1]
target_value = 4.0

# 初始化最小差和最接近目标值的元素
min_diff = float('inf')
closest_num = None

for num in float_numbers:
    # 计算元素与目标值之间的差
    diff = abs(num - target_value)
    # 如果差更小，则更新最小差和最接近目标值的元素
    if diff < min_diff:
        min_diff = diff
        closest_num = num

print(f"The closest number to {target_value} is {closest_num}")

输出：The closest number to 4.0 is 4.8

老猫：请给出练习答案，，并请做好注释

查老四：当然可以，以下是练习题的答案及相应注释。

练习1：计算列表中正数的和

# 示例列表
numbers = [1, -2, 3, 4, -5, 6, -7, 8, 9]

# 计算列表中正数的和
positive_sum = sum(num for num in numbers if num > 0)

# 输出结果
print("列表中正数的和为：", positive_sum)

练习2：合并两个有序列表

# 示例列表
list1 = [1, 3, 5, 7]
list2 = [2, 4, 6, 8]

# 合并两个有序列表
merged_list = sorted(list1 + list2)

# 输出结果
print("合并后的列表为：", merged_list)

练习3：元组元素交换

# 示例元组
my_tuple = (3, 5)

# 元组元素交换
swapped_tuple = (my_tuple[1], my_tuple[0])

# 输出结果
print("交换后的元组为：", swapped_tuple)

练习4：找出列表中最接近给定值的数

# 示例列表和目标值
float_numbers = [1.3, 3.5, 4.8, 7.2, 9.1]
target_value = 4.0

# 找出列表中最接近目标值的数
closest_number = min(float_numbers, key=lambda x: abs(x - target_value))

# 输出结果
print("列表中最接近目标值的数为：", closest_number)