Python if语句结合循环结构的使用

Python if 语句基础

if 语句语法结构

在Python中，if语句用于条件判断。其基本语法结构如下：

if condition:
    # 当条件condition为True时执行的代码块
    statement

这里的condition是一个可以求值为布尔值（True或False）的表达式。例如，比较两个数的大小：

num1 = 10
num2 = 5
if num1 > num2:
    print(f"{num1} 大于 {num2}")

在上述代码中，num1 > num2就是condition，如果这个条件为True，就会执行print语句。

if - else 结构

除了简单的if语句，我们经常会用到if - else结构，用于在条件为True和False时分别执行不同的代码块。语法如下：

if condition:
    # 条件为True时执行的代码块
    statement1
else:
    # 条件为False时执行的代码块
    statement2

例如，判断一个数是偶数还是奇数：

number = 7
if number % 2 == 0:
    print(f"{number} 是偶数")
else:
    print(f"{number} 是奇数")

这里number % 2 == 0是判断条件，根据条件的真假分别执行不同的print语句。

if - elif - else 结构

当需要进行多个条件判断时，可以使用if - elif - else结构。elif是else if的缩写。语法如下：

if condition1:
    # 条件1为True时执行的代码块
    statement1
elif condition2:
    # 条件1为False且条件2为True时执行的代码块
    statement2
else:
    # 所有条件都为False时执行的代码块
    statement3

比如，根据学生的成绩给出不同的评价：

score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

在这个例子中，程序会依次判断每个条件，只要有一个条件为True，就会执行对应的代码块，后续的条件判断就不再执行。

循环结构基础

for 循环

for循环用于遍历可迭代对象（如列表、元组、字符串等）。基本语法如下：

for variable in iterable:
    # 对可迭代对象中的每个元素执行的代码块
    statement

例如，遍历一个列表并打印每个元素：

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

在上述代码中，fruit是每次循环时从fruits列表中取出的元素，循环会依次打印列表中的每个水果名称。

for循环还可以结合range()函数使用。range()函数生成一个整数序列，语法为range(start, stop, step)，其中start（默认为0）是起始值，stop是结束值（不包含），step（默认为1）是步长。例如，打印0到4的数字：

for i in range(5):
    print(i)

这里range(5)生成了一个包含0, 1, 2, 3, 4的序列，for循环依次将这些值赋给i并执行print语句。

while 循环

while循环会在指定条件为True时重复执行一段代码。基本语法如下：

while condition:
    # 条件为True时执行的代码块
    statement

例如，计算1到10的累加和：

sum_num = 0
num = 1
while num <= 10:
    sum_num += num
    num += 1
print(f"1到10的累加和为: {sum_num}")

在这个例子中，只要num <= 10这个条件为True，就会执行循环体中的代码，每次循环num增加1，直到num大于10时循环结束。

循环控制语句

1. break：用于立即终止循环。例如，在一个循环中找到某个特定值后停止循环：

numbers = [1, 2, 3, 4, 5, 6]
for num in numbers:
    if num == 4:
        break
    print(num)

上述代码会打印1, 2, 3，当num等于4时，break语句终止循环，后续元素不再处理。

2. continue：用于跳过当前循环的剩余部分，直接进入下一次循环。比如，只打印奇数：

for i in range(10):
    if i % 2 == 0:
        continue
    print(i)

这里当i是偶数时，continue语句使程序跳过print(i)，直接进入下一次循环，所以只会打印奇数。

Python if 语句与 for 循环结合使用

在 for 循环中使用 if 进行条件筛选

在遍历可迭代对象时，常常需要根据某些条件筛选出符合要求的元素。例如，从一个列表中筛选出所有偶数：

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_nums = []
for num in nums:
    if num % 2 == 0:
        even_nums.append(num)
print(f"偶数列表: {even_nums}")

在这个例子中，for循环遍历nums列表，if语句判断每个元素是否为偶数，如果是，则将其添加到even_nums列表中。

我们还可以在嵌套的for循环中使用if语句。例如，打印九九乘法表中乘积大于20的部分：

for i in range(1, 10):
    for j in range(1, 10):
        product = i * j
        if product > 20:
            print(f"{i} * {j} = {product}")

这里外层for循环控制行数，内层for循环控制列数，if语句筛选出乘积大于20的乘法表达式并打印。

根据 if 条件控制 for 循环的执行

if语句可以在循环开始前根据条件决定是否执行整个for循环。比如，只有当用户输入为正数时才进行数字累加：

user_input = int(input("请输入一个正数: "))
total = 0
if user_input > 0:
    for i in range(1, user_input + 1):
        total += i
    print(f"1到 {user_input} 的累加和为: {total}")
else:
    print("输入的不是正数，不进行累加")

在上述代码中，if语句先判断用户输入是否为正数，如果是，则执行for循环进行累加操作；否则，提示用户输入不符合要求。

使用 if 和 for 循环处理复杂逻辑

假设我们有一个列表，其中包含一些数字和字符串，我们要将数字提取出来并计算它们的平方和。代码如下：

mixed_list = [1, 'two', 3, 'four', 5]
square_sum = 0
for item in mixed_list:
    if isinstance(item, int):
        square_sum += item ** 2
print(f"数字的平方和为: {square_sum}")

这里for循环遍历mixed_list，if语句使用isinstance()函数判断每个元素是否为整数，如果是，则计算其平方并累加到square_sum中。

Python if 语句与 while 循环结合使用

在 while 循环中使用 if 进行条件判断

与for循环类似，while循环中也经常使用if语句进行条件判断。例如，模拟一个猜数字游戏，用户输入数字，程序根据输入提示猜大了还是猜小了，直到猜对为止：

import random
target_num = random.randint(1, 100)
while True:
    guess = int(input("请猜一个1到100之间的数字: "))
    if guess > target_num:
        print("猜大了")
    elif guess < target_num:
        print("猜小了")
    else:
        print("猜对了")
        break

在这个while循环中，if - elif - else结构根据用户的猜测与目标数字的比较结果给出相应提示，猜对时使用break语句终止循环。

根据 if 条件控制 while 循环的执行

if语句可以在while循环前决定是否启动循环。比如，只有当用户选择继续时才进行新一轮的计算：

continue_flag = 'y'
while continue_flag.lower() == 'y':
    num1 = float(input("请输入第一个数字: "))
    num2 = float(input("请输入第二个数字: "))
    operator = input("请输入运算符(+,-,*,/): ")
    if operator == '+':
        result = num1 + num2
    elif operator == '-':
        result = num1 - num2
    elif operator == '*':
        result = num1 * num2
    elif operator == '/':
        if num2 != 0:
            result = num1 / num2
        else:
            print("除数不能为0")
            continue
    else:
        print("无效的运算符")
        continue
    print(f"计算结果为: {result}")
    continue_flag = input("是否继续(y/n)? ")

在这段代码中，while循环的条件依赖于continue_flag的值，每次循环内if - elif - else结构根据用户输入的运算符进行相应计算，当出现错误情况（如除数为0或无效运算符）时，使用continue跳过本次循环剩余部分，继续下一次循环询问用户是否继续。

使用 if 和 while 循环处理动态条件

考虑一个场景，有一个银行账户，用户可以进行存款和取款操作，账户余额不能为负数。代码如下：

balance = 1000
while True:
    print(f"当前账户余额: {balance}")
    action = input("请选择操作(d:存款, w:取款, q:退出): ")
    if action == 'd':
        amount = float(input("请输入存款金额: "))
        balance += amount
    elif action == 'w':
        amount = float(input("请输入取款金额: "))
        if amount <= balance:
            balance -= amount
        else:
            print("余额不足")
    elif action == 'q':
        break
    else:
        print("无效的操作选择")

在这个while循环中，if - elif - else结构根据用户选择的操作进行不同处理。对于取款操作，if语句判断取款金额是否小于等于余额，以确保账户余额不会为负数。当用户选择退出（q）时，使用break终止循环。

嵌套的 if 语句与循环结构

嵌套 if 语句在循环中的应用

在循环中，我们可能需要进行多层次的条件判断，这就用到了嵌套的if语句。例如，在一个矩阵（二维列表）中查找特定元素，并记录其位置：

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
target = 5
found = False
for i in range(len(matrix)):
    for j in range(len(matrix[i])):
        if matrix[i][j] == target:
            print(f"找到目标元素 {target}，位置为 ({i}, {j})")
            found = True
            break
    if found:
        break
if not found:
    print(f"未找到目标元素 {target}")

在这个例子中，外层for循环遍历矩阵的行，内层for循环遍历每行的列。嵌套的if语句判断当前元素是否为目标元素，如果找到则记录位置并设置found标志，通过break语句跳出内层和外层循环。如果遍历完整个矩阵都未找到，则输出提示信息。

循环嵌套与 if 语句的复杂组合

假设有一个电商系统，要根据用户的购买金额和会员等级计算折扣。不同会员等级有不同的折扣规则，且购买金额达到一定阈值会有额外折扣。代码如下：

member_level = input("请输入会员等级(普通会员: normal, 银牌会员: silver, 金牌会员: gold): ")
purchase_amount = float(input("请输入购买金额: "))
discount = 0
if member_level == 'normal':
    if purchase_amount >= 100:
        discount = 0.05
elif member_level =='silver':
    discount = 0.1
    if purchase_amount >= 200:
        discount += 0.05
elif member_level == 'gold':
    discount = 0.15
    if purchase_amount >= 300:
        discount += 0.1
else:
    print("无效的会员等级")
total_amount = purchase_amount * (1 - discount)
print(f"折扣后应付金额: {total_amount}")

在这段代码中，外层if - elif - else结构根据会员等级设置初始折扣，内层if语句根据购买金额进行额外折扣计算。最后根据折扣计算应付金额。

处理嵌套结构中的特殊情况

在嵌套的循环和if语句结构中，有时需要处理一些特殊情况。例如，在一个文件处理程序中，要读取文件内容，按行处理，每行又按单词处理，并且要跳过一些特定格式的行。代码如下：

try:
    with open('example.txt', 'r') as file:
        for line in file:
            if line.startswith('//'):
                continue
            words = line.split()
            for word in words:
                if word.isdigit():
                    print(f"数字: {word}")
                else:
                    print(f"单词: {word}")
except FileNotFoundError:
    print("文件未找到")

在这个例子中，外层for循环逐行读取文件内容，if语句判断是否以//开头，如果是则跳过该行。对于其他行，将其拆分为单词，内层for循环遍历单词，if语句判断单词是否为数字并进行相应处理。同时，使用try - except结构处理文件未找到的异常情况。

优化 if 语句与循环结构的结合使用

减少不必要的判断

在if语句与循环结合使用时，要尽量减少不必要的条件判断。例如，在下面的代码中，每次循环都进行了两次条件判断：

nums = [1, 2, 3, 4, 5]
result = []
for num in nums:
    if num % 2 == 0:
        if num > 2:
            result.append(num)

可以将两个条件合并，减少判断次数：

nums = [1, 2, 3, 4, 5]
result = []
for num in nums:
    if num % 2 == 0 and num > 2:
        result.append(num)

这样在每次循环时只进行一次条件判断，提高了代码的执行效率。

提前终止循环

如果在循环中一旦满足某个条件就不需要继续循环，可以使用break语句提前终止循环。比如，在一个有序列表中查找某个元素：

sorted_nums = [1, 3, 5, 7, 9]
target_num = 5
found = False
for num in sorted_nums:
    if num == target_num:
        found = True
        break
    elif num > target_num:
        break
if found:
    print(f"找到目标元素 {target_num}")
else:
    print(f"未找到目标元素 {target_num}")

在这个例子中，当找到目标元素或者当前元素大于目标元素时，使用break语句提前终止循环，避免了不必要的循环迭代，提高了查找效率。

使用列表推导式替代简单循环和 if 语句

对于一些简单的循环结合if语句的情况，可以使用列表推导式来简化代码。例如，从一个列表中筛选出所有偶数并计算它们的平方：

nums = [1, 2, 3, 4, 5]
squared_even_nums = []
for num in nums:
    if num % 2 == 0:
        squared_even_nums.append(num ** 2)

使用列表推导式可以写成：

nums = [1, 2, 3, 4, 5]
squared_even_nums = [num ** 2 for num in nums if num % 2 == 0]

列表推导式不仅代码更简洁，而且在执行效率上也有一定优势，因为它是在底层使用C语言实现的快速迭代。

合理使用生成器

生成器是一种特殊的迭代器，可以在需要时生成值，而不是一次性生成所有值，这在处理大数据集时非常有用。例如，我们要生成1到1000000中所有偶数的平方：

def even_square_generator():
    for i in range(1, 1000001):
        if i % 2 == 0:
            yield i ** 2
gen = even_square_generator()
for square in gen:
    print(square)

在这个例子中，even_square_generator函数是一个生成器函数，yield语句使函数成为生成器。这样，在需要时才生成偶数的平方，而不是一次性生成所有结果，节省了内存空间。与if语句结合，只生成符合条件的数值。

常见错误与解决方法

if 条件判断错误

1. 逻辑运算符使用错误：在if语句的条件中，逻辑运算符and、or、not的使用要特别注意。例如，以下代码想判断一个数是否在1到10之间，但逻辑运算符使用错误：

num = 15
if num > 1 or num < 10:
    print("在范围内")
else:
    print("不在范围内")

这里应该使用and运算符，正确代码如下：

num = 15
if num > 1 and num < 10:
    print("在范围内")
else:
    print("不在范围内")

2. 比较运算符错误：使用比较运算符时，要确保比较的对象类型一致。例如，以下代码比较字符串和数字：

num = 10
string_num = '10'
if num == string_num:
    print("相等")
else:
    print("不相等")

这里num是整数类型，string_num是字符串类型，直接比较会得到False。如果要比较值是否相等，需要将其中一个转换为相同类型，比如：

num = 10
string_num = '10'
if num == int(string_num):
    print("相等")
else:
    print("不相等")

循环相关错误

1. 无限循环：在while循环中，如果条件始终为True，就会导致无限循环。例如：

while True:
    print("这是一个无限循环")

要避免无限循环，确保在循环体中修改影响循环条件的变量。例如，以下代码修正了无限循环问题：

count = 0
while count < 5:
    print(f"计数: {count}")
    count += 1

2. 循环变量未初始化：在使用for循环或while循环时，循环变量需要正确初始化。例如，在以下代码中，sum_num未初始化：

num = 1
while num <= 10:
    sum_num += num
    num += 1
print(f"累加和为: {sum_num}")

正确的做法是在循环前初始化sum_num：

sum_num = 0
num = 1
while num <= 10:
    sum_num += num
    num += 1
print(f"累加和为: {sum_num}")

if 与循环结合的错误

1. 缩进错误：Python中通过缩进来表示代码块，在if语句和循环结构结合时，缩进错误很常见。例如：

nums = [1, 2, 3, 4, 5]
for num in nums:
if num % 2 == 0:
print(f"{num} 是偶数")

这里if语句和print语句的缩进不正确，正确代码应该是：

nums = [1, 2, 3, 4, 5]
for num in nums:
    if num % 2 == 0:
        print(f"{num} 是偶数")

2. 条件判断位置错误：在循环中，if语句的条件判断位置要根据需求合理安排。例如，在以下代码中，想统计列表中正数的个数，但条件判断位置错误：

nums = [1, -2, 3, -4, 5]
count = 0
for num in nums:
    count += 1
    if num > 0:
        pass
print(f"正数的个数为: {count}")

这里count的增加应该在if语句判断之后，正确代码如下：

nums = [1, -2, 3, -4, 5]
count = 0
for num in nums:
    if num > 0:
        count += 1
print(f"正数的个数为: {count}")

通过对以上内容的学习，相信你对Python中if语句与循环结构的结合使用有了更深入的理解和掌握。在实际编程中，要根据具体需求灵活运用这些知识，编写出高效、健壮的代码。