程序员scholar
scholar
2025-07-20
目录

循环综合练习

# 循环综合练习

# 1. 输出 1 到 10 的所有数字

  • 题目：编写一个程序，打印出从 1 到 10 的所有整数。
  • 核心思路：使用 for 循环与 range() 函数生成一个从 1 到 10 的数字序列，然后逐个打印。
  • 代码实现：
    for i in range(1, 11):
    print(i)
    1
    2
  • 代码解析：
    • range(1, 11) 会生成一个从 1 开始，到 11 结束（但不包含 11）的整数序列，即 1, 2, 3, 4, 5, 6, 7, 8, 9, 10。
    • for 循环会依次将这些数字赋值给变量 i，然后执行循环体内的 print(i) 语句。
  • 输出结果：
    1
2
3
4
5
6
7
8
9
10
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

# 2. 计算 1 到 100 的累加和

  • 题目：计算从 1 到 100 所有整数的和。
  • 核心思路：初始化一个累加变量 total为 0。使用 for 循环遍历 1 到 100 的所有数字，在每次循环中，将当前数字加到 total 上。
  • 代码实现：
    total = 0
for i in range(1, 101):
    total += i  # 等价于 total = total + i
print(f"1到100的和为: {total}")
    1
    2
    3
    4
  • 代码解析：
    • total = 0：在循环开始前，必须初始化一个变量来存放总和。
    • range(1, 101)：生成从 1 到 100 的数字。
    • total += i：这是核心的累加操作，将每次循环的 i 值加到 total 中。
  • 输出结果：
    1到100的和为: 5050
    1

# 3. 遍历并打印列表中的所有元素

  • 题目：给定一个列表，打印出其中的每一个元素。
  • 核心思路：直接使用 for 循环遍历列表，Python 会自动将列表中的每个元素依次赋值给循环变量。
  • 代码实现：
    fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)
    1
    2
    3
  • 代码解析：
    • for fruit in fruits: 是 Python 中遍历序列最直接、最优雅的方式。在每次迭代中，fruit 变量会依次被赋值为 "apple", "banana", "cherry"。
  • 输出结果：
    apple
banana
cherry
    1
    2
    3

# 4. 打印 1 到 50 中的所有偶数

  • 题目：找出并打印出从 1 到 50 之间的所有偶数。
  • 核心思路：遍历 1 到 50 的所有数字，使用取模运算符 % 判断每个数字是否能被 2 整除。如果余数为 0，则该数是偶数。
  • 代码实现：
    print("1到50之间的所有偶数:")
for i in range(1, 51):
    if i % 2 == 0:
        print(i)
    1
    2
    3
    4
  • 代码解析：
    • i % 2 == 0：这是判断一个数是否为偶数的经典方法。如果 i 除以 2 的余数是 0，条件就为 True。
  • 输出结果：
    1到50之间的所有偶数:
2
4
... (中间省略)
48
50
    1
    2
    3
    4
    5
    6

# 5. 计算列表中所有数字的和

  • 题目：给定一个只包含数字的列表，计算其中所有元素的和。
  • 核心思路：这与第 2 题类似，但这次是遍历一个给定的列表而不是 range() 对象。
  • 代码实现：
    numbers = [10, 20, 30, 40, 50]
total = 0
for num in numbers:
    total += num
print(f"列表数字的和为: {total}")
    1
    2
    3
    4
    5
  • 代码解析：
    • 这个例子展示了 for 循环处理不同可迭代对象（range 和 list）时的通用性。
  • 输出结果：
    列表数字的和为: 150
    1

# 6. 找到列表中的最大值

  • 题目：在一个数字列表中，找到最大的那个数（不使用内置的 max() 函数）。
  • 核心思路：先假设列表的第一个元素是最大值，然后遍历列表的其余部分。如果发现有比当前最大值更大的数，就更新最大值。
  • 代码实现：
    numbers = [3, 5, 7, 2, 8, 6]
# 必须确保列表不为空，否则 numbers[0] 会报错
if not numbers:
    print("列表为空，无法找到最大值")
else:
    max_num = numbers[0]  # 1. 假设第一个数是最大值
    for num in numbers:   # 2. 遍历列表中的每一个数
        if num > max_num: # 3. 如果当前数比已知的最大值还大
            max_num = num # 4. 更新最大值
    print(f"列表中的最大值是: {max_num}")
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
  • 代码解析：
    • 这是一个经典的“打擂台”算法。max_num 是当前的“擂主”，列表中的每个 num 都来挑战它，胜者成为新的“擂主”。
  • 输出结果：
    列表中的最大值是: 8
    1

# 7. 打印九九乘法表

  • 题目：在控制台输出标准的九九乘法表。
  • 核心思路：使用嵌套的 for 循环。外层循环控制行（乘数 i），内层循环控制列（被乘数 j）。关键点在于内层循环的范围是 range(1, i + 1)，确保每行的表达式数量正确。
  • 代码实现：
    for i in range(1, 10):      # 外层循环：控制行，从1到9
    for j in range(1, i + 1): # 内层循环：控制列，从1到i
        print(f"{j}x{i}={i*j}\t", end="") # 使用\t制表符对齐，end=""防止换行
    print() # 在每行结束后，打印一个换行符
    1
    2
    3
    4
  • 代码解析：
    • 嵌套循环是处理二维结构的利器。
    • end="" 是 print 函数的一个重要参数，它能阻止 print 默认的换行行为，让所有列的表达式能打印在同一行。
    • \t 是一个制表符，可以帮助对齐文本，使格式更美观。
  • 输出结果：
    1x1=1	
1x2=2	2x2=4	
1x3=3	2x3=6	3x3=9	
... (以此类推)
1x9=9	2x9=18 ... 9x9=81
    1
    2
    3
    4
    5

# 8. 反转一个字符串

  • 题目：将一个字符串的顺序颠倒（不使用切片 [::-1]）。
  • 核心思路：初始化一个空字符串。从头到尾遍历原字符串，在每次循环中，将当前字符拼接到新字符串的最前面。
  • 代码实现：
    text = "hello"
reversed_text = ""
for char in text:
    reversed_text = char + reversed_text
print(f"'{text}' 反转后是: '{reversed_text}'")
    1
    2
    3
    4
    5
  • 代码解析：
    • reversed_text = char + reversed_text 是反转的核心。例如，处理 "hello" 时：
      • char='h', reversed_text='h'
      • char='e', reversed_text='e' + 'h' = 'eh'
      • char='l', reversed_text='l' + 'eh' = 'leh'
      • ...以此类推。
  • 输出结果：
    'hello' 反转后是: 'olleh'
    1

# 9. 统计列表中正数的个数

  • 题目：给定一个包含正数、负数和零的列表，计算其中正数的数量。
  • 核心思路：初始化一个计数器为 0。遍历列表，如果当前数字大于 0，则计数器加一。
  • 代码实现：
    numbers = [-5, 3, 0, 8, -2, 6, 1]
positive_count = 0
for num in numbers:
    if num > 0:
        positive_count += 1
print(f"列表中正数的个数为: {positive_count}")
    1
    2
    3
    4
    5
    6
  • 代码解析：
    • 这是一个典型的计数问题，通过 if 条件筛选出符合要求的元素，然后累加计数。
  • 输出结果：
    列表中正数的个数为: 4
    1

# 10. 找到两个列表的交集

  • 题目：找出两个列表中都含有的元素。
  • 核心思路：
    1. 方法一 (循环嵌套)：遍历第一个列表，对于它的每一个元素，再检查它是否存在于第二个列表中。
    2. 方法二 (高效)：利用集合 set 的特性。将一个列表转换为集合可以极大地提高查找效率。
  • 代码实现 (方法二)：
    list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]

set2 = set(list2) # 将 list2 转换为集合，O(n)
intersection = []
for item in list1:
    if item in set2: # 在集合中查找元素是 O(1)，非常快
        intersection.append(item)
        
print(f"两个列表的交集为: {intersection}")
# 更 Pythonic 的写法：
# intersection = list(set(list1) & set(list2))
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
  • 代码解析：
    • 为什么方法二更高效？在列表中查找一个元素（item in list2），平均需要遍历列表的一半，时间复杂度为 O(n)。而在集合中查找（item in set2），时间复杂度仅为 O(1)。当列表很大时，性能差异巨大。
  • 输出结果：
    两个列表的交集为: [4, 5]
    1

# 11. 移除列表中的所有零

  • 题目：给定一个列表，创建一个新列表，其中不包含原列表中的 0。
  • 核心思路：创建一个新的空列表。遍历原列表，只将非零的元素添加到新列表中。
  • 代码实现：
    numbers = [0, 5, 3, 0, 8, 0]
non_zero_numbers = []
for num in numbers:
    if num != 0:
        non_zero_numbers.append(num)
print(f"移除零后的列表为: {non_zero_numbers}")
    1
    2
    3
    4
    5
    6
  • 代码解析：
    • 这种“过滤”操作是循环的常见应用：遍历一个集合，根据条件筛选出部分元素来构建一个新的集合。
    • 重要提示：不推荐在遍历列表的同时从中删除元素（如 numbers.remove(num)），这可能会导致意想不到的跳过元素的问题。创建一个新列表是更安全、更清晰的做法。
  • 输出结果：
    移除零后的列表为: [5, 3, 8]
    1

# 12. 提取字符串中的所有字母

  • 题目：从一个包含字母、数字和其他符号的字符串中，只提取出字母。
  • 核心思路：遍历字符串中的每个字符，使用字符串方法 isalpha() 判断该字符是否为字母。
  • 代码实现：
    text = "Hello, World! 123"
letters_only = ""
for char in text:
    if char.isalpha(): # isalpha() 检查字符是否为字母
        letters_only += char
print(f"提取出的字母为: '{letters_only}'")
    1
    2
    3
    4
    5
    6
  • 代码解析：
    • isalpha() 是一个非常有用的字符串方法，可以轻松判断一个字符是否属于 a-z 或 A-Z。
  • 输出结果：
    提取出的字母为: 'HelloWorld'
    1

# 13. 计算一个数的阶乘

  • 题目：计算一个非负整数 n 的阶乘（n! = 1 * 2 * ... * n）。
  • 核心思路：初始化结果变量为 1。使用 for 循环从 1 乘到 n。
  • 代码实现：
    n = 5
factorial = 1
if n < 0:
    print("负数没有阶乘")
elif n == 0:
    print("0的阶乘是: 1")
else:
    for i in range(1, n + 1):
        factorial *= i # 累乘
    print(f"{n} 的阶乘是: {factorial}")
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
  • 代码解析：
    • 需要处理 n=0 的特殊情况，0 的阶乘定义为 1。
    • factorial *= i 是核心的累乘操作。
  • 输出结果：
    5 的阶乘是: 120
    1

# 14. 打印列表中奇数索引位置的元素

  • 题目：给定一个列表，打印出所有位于奇数索引（1, 3, 5, ...）上的元素。
  • 核心思路：使用 range() 函数的第三个参数（步长）来直接生成奇数索引序列。
  • 代码实现：
    numbers = [10, 20, 30, 40, 50, 60]
print("奇数索引位置的元素:")
for i in range(1, len(numbers), 2): # range(start, stop, step)
    print(f"索引 {i}: {numbers[i]}")
    1
    2
    3
    4
  • 代码解析：
    • range(1, len(numbers), 2) 从索引 1 开始，每次跳过 2 个单位，从而生成 1, 3, 5, ... 这样的奇数索引。
  • 输出结果：
    奇数索引位置的元素:
索引 1: 20
索引 3: 40
索引 5: 60
    1
    2
    3
    4

# 15. 计算 1 到 50 所有数的平方和

  • 题目：计算 1² + 2² + ... + 50² 的值。
  • 核心思路：与累加和类似，但这次是累加每个数的平方。
  • 代码实现：
    sum_of_squares = 0
for i in range(1, 51):
    sum_of_squares += i ** 2  # `**` 是幂运算符
print(f"1到50的平方和为: {sum_of_squares}")
    1
    2
    3
    4
  • 代码解析：
    • i ** 2 计算 i 的平方。
  • 输出结果：
    1到50的平方和为: 42925
    1

# 16. 提取字符串中的所有数字

  • 题目：从一个混合字符串中，只提取出所有数字字符。
  • 核心思路：遍历字符串，使用 isdigit() 方法判断每个字符是否为数字。
  • 代码实现：
    text = "Product-ID: 987, Price: $12, Stock: 345"
digits_only = ""
for char in text:
    if char.isdigit(): # isdigit() 检查字符是否为 0-9
        digits_only += char
print(f"提取出的数字为: '{digits_only}'")
    1
    2
    3
    4
    5
    6
  • 代码解析：
    • isdigit() 是与 isalpha() 类似的实用字符串方法。
  • 输出结果：
    提取出的数字为: '98712345'
    1

# 17. 找出 2 到 50 之间的所有质数

  • 题目：打印出从 2 到 50 范围内的所有质数。质数是只能被 1 和它本身整除的大于 1 的自然数。
  • 核心思路：使用嵌套循环。外层循环遍历 2 到 50 的每一个数 num。内层循环尝试用从 2 到 num 的平方根之间的数去除 num。如果能被整除，说明 num 不是质数，立即跳出内层循环。
  • 代码实现：
    print("2到50之间的所有质数:")
for num in range(2, 51):
    is_prime = True # 先假设当前数是质数
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            is_prime = False # 发现一个因子，说明它不是质数
            break # 无需再继续检查，跳出内层循环
    if is_prime:
        print(num)
    1
    2
    3
    4
    5
    6
    7
    8
    9
  • 代码解析：
    • 优化：内层循环只需要检查到 num 的平方根即可。因为如果 num 有一个大于其平方根的因子 a，那么它必定有一个小于其平方根的因子 b（num = a * b）。
    • is_prime 标志位用于记录检查结果。
  • 输出结果：
    2到50之间的所有质数:
2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

# 18. 找到列表中的最小值

  • 题目：在一个数字列表中，找到最小的那个数（不使用内置的 min() 函数）。
  • 核心思路：与第 6 题找最大值的方法完全相同，只是将比较条件从 > 改为 <。
  • 代码实现：
    numbers = [4, 2, 9, 1, 5, -3]
if not numbers:
    print("列表为空")
else:
    min_num = numbers[0]
    for num in numbers:
        if num < min_num:
            min_num = num
    print(f"列表中的最小值为: {min_num}")
    1
    2
    3
    4
    5
    6
    7
    8
    9
  • 输出结果：
    列表中的最小值为: -3
    1

# 19. 判断一个字符串是否是回文

  • 题目：判断一个字符串是否是回文。回文是指正读和反读都一样的字符串，如 "level" 或 "madam"。
  • 核心思路：最简单的方法是比较原字符串和它反转后的版本是否相等。
  • 代码实现：
    text = "level"
# Python 的切片 [::-1] 是反转序列最快的方式
is_palindrome = (text == text[::-1])

if is_palindrome:
    print(f"'{text}' 是回文。")
else:
    print(f"'{text}' 不是回文。")
    1
    2
    3
    4
    5
    6
    7
    8
  • 代码解析：
    • text[::-1] 通过一个步长为 -1 的切片，高效地创建了一个原字符串的反转副本。
  • 输出结果：
    'level' 是回文。
    1

# 20. 统计字符串中每个字符的出现次数

  • 题目：计算一个字符串中，每个不重复的字符分别出现了多少次。
  • 核心思路：使用一个字典来存储结果。遍历字符串，对于每个字符，如果它已经是字典的键，就将其对应的值（计数）加 1；如果不是，就将其作为新键添加到字典，并设其值为 1。
  • 代码实现：
    text = "hello world"
char_counts = {}
for char in text:
    # dict.get(key, default) 是一个安全又方便的方法
    char_counts[char] = char_counts.get(char, 0) + 1
    
print(f"'{text}' 中每个字符的出现次数为:")
print(char_counts)
    1
    2
    3
    4
    5
    6
    7
    8
  • 代码解析：
    • char_counts.get(char, 0) 会尝试获取 char 键对应的值。如果 char 不在字典中，它不会报错，而是返回默认值 0。这行代码巧妙地实现了计数逻辑。
  • 输出结果：
      'hello world' 中每个字符的出现次数为:
  {'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1}
    1
    2
编辑此页 (opens new window)
上次更新: 2025/07/23, 06:33:16
while循环
Python函数

← Python函数→

Theme by Vdoing | Copyright © 2019-2025 程序员scholar