Python面试宝典：循环结构相关知识和面试题（1000加python面试题助你轻松捕获大厂Offer）

---

更多面试题请查阅：Python面试宝典：1000加python面试题助你轻松捕获大厂Offer目录

---

第四章：控制流程

第二节：循环结构

Python中的循环结构允许我们执行一段代码块多次，这是编程中非常常见且强大的一个特性。Python提供了两种主要的循环结构：for循环和while循环。

1、 for循环

for循环用于在一个序列（如列表、元组、字符串或范围）上进行迭代，即它可以遍历序列中的每个元素，并针对每个元素执行代码块。

• 语法

for element in sequence:
    # 执行的代码块

• sequence是要迭代的序列。

• element是序列中的当前元素。

• 示例

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

此代码将打印出列表fruits中的所有元素。

• range()函数

range()函数生成一个数值序列，经常和for循环一起使用，来重复特定次数的操作。

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

这将打印数字0到4。

2、while循环

while循环用于在满足指定条件的情况下重复执行代码块。与for循环不同，while循环需要手动更新或更改触发循环继续执行的条件，否则可能导致无限循环。

• 语法

while condition:
    # 执行的代码块
    # 经常需要一个操作来更改条件

• condition是一个布尔表达式，只要其为True，循环就会继续执行。
• 示例

i = 1
while i < 6:
    print(i)
    i += 1

这段代码将打印数字1到5。当i增加到6时，条件不再为真，循环结束。

3、循环控制语句

• break: 用于提前退出循环。

• continue: 跳过当前循环的剩余代码并开始下一次迭代。

• else: 可以与for或while循环一起使用，当循环正常结束时（即没有通过break退出循环），执行else块。

• break示例

for i in range(5):
    if i == 3:
        break
    print(i)

这将打印数字0到2，当i等于3时终止循环。

• continue示例

for i in range(5):
    if i == 3:
        continue
    print(i)

这将打印出除了3以外的数字0到4。

• else示例

i = 1
while i < 6:
    print(i)
    i += 1
else:
    print("i is no longer less than 6")

这个循环会打印1到5，之后打印消息"i is no longer less than 6"。

总结：Python中的循环结构非常灵活且强大，能有效地处理需要重复操作的场景，无论是遍历数据结构中的每个元素，还是重复执行某些操作直到满足特定条件为止。正确使用循环控制语句可以使你的代码更加高效和可读。

4、python循环结构相关面试题

面试题1

问题：编写一个Python程序，使用一个循环来找出0到100之间所有的偶数，并将这些偶数按顺序存入一个列表中。

面试考题知识点：

• 理解和应用for循环遍历一定范围的数字。
• 使用range函数生成连续的整数序列。
• 利用条件语句if判断数字是否为偶数。
• 理解列表并使用列表方法append将符合条件的元素添加到列表中。

答案或代码：

even_numbers = []  # 创建一个空列表用于存放偶数
for number in range(101):  # 遍历0到100（包括100）
    if number % 2 == 0:  # 判断是否为偶数
        even_numbers.append(number)  # 将偶数添加到列表中

print(even_numbers)  # 输出偶数列表

答案或代码解析：
首先，使用range(101)生成从0到100的整数序列，因为range函数生成的序列不包括结束值，所以要设置为101以包含数字100。

接着，for循环遍历这个序列中的每个数字。在循环体内，使用if语句检查当前数字是否能被2整除（即number % 2 == 0），以此来判断它是否为偶数。如果是偶数，则使用append方法将其加入之前创建的空列表even_numbers中。

循环结束后，所有0到100之间的偶数都将被添加到even_numbers列表中，并通过print()函数打印这个列表，输出所有找到的偶数。

这道题目不仅检验了面试者对循环、条件判断和列表操作的掌握，而且通过实际操作检测了面试者用Python简洁高效解决问题的能力。

面试题2

问题：编写一个Python程序，实现一个函数，该函数接受两个参数：一个正整数n和一个列表。该函数应使用循环结构来返回一个新列表，其中包含原列表中每n个元素的平均值。如果列表长度不是n的倍数，最后一个元素应是剩余元素的平均值。

面试考题知识点：

• 使用while或for循环遍历列表。
• 理解列表分片和索引。
• 计算列表分片的平均值。
• 动态构造新列表以存储结果。

答案或代码：

def average_every_n_elements(n, input_list):
    averages = []  # 创建新列表用于存储平均值
    i = 0  # 初始索引
    # 循环终止条件为索引超出列表长度
    while i < len(input_list):
        # 分片获取当前片段，注意不要超过列表末尾
        slice = input_list[i:i+n]
        # 计算分片平均值并加入结果列表
        avg = sum(slice) / len(slice)
        averages.append(avg)
        # 更新索引到下一个片段的起始位置
        i += n
    return averages

# 示例使用
input_list = [1, 2, 3, 4, 5, 6, 7]
n = 3
print(average_every_n_elements(n, input_list))

答案或代码解析：
首先，函数通过参数接收一个正整数n和一个列表input_list。新列表averages用于存放计算得到的平均值。

在函数体中，我们使用while循环遍历输入列表。循环开始前设置初始索引i为0，循环条件是i小于输入列表的长度。

在每次循环中，我们使用列表分片操作input_list[i:i+n]获取从当前索引i开始的n个元素。如果索引接近列表末尾，这个分片可能包含少于n个元素。

使用sum(slice) / len(slice)计算当前分片的平均值，并将这个平均值添加到averages列表中。

循环每次迭代后，更新索引i，使其增加n，跳到下一个分片的开始位置。

循环结束后，函数返回存储了所有平均值的新列表averages。

这道题目考验了面试者对循环、列表操作（特别是分片和索引）以及基本数学计算的理解和应用。此外，它还涉及动态列表构建和片段处理的问题，检验了编码的灵活性和创造性思维能力。

面试题3

问题：编写一个Python程序，实现一个函数，该函数接受一个字符串作为输入参数，并使用循环结构返回一个新字符串，新字符串中的字母顺序与原字符串中的字母顺序相反，但数字和其他非字母字符的位置保持不变。

面试考题知识点：

• 理解和应用字符串索引和切片。
• 使用循环结构遍历字符串。
• 字符判断（判断字符是否为字母）。
• 字符串不可变性及如何有效组合字符串。

答案或代码：

def reverse_letters(original_str):
    letters = [c for c in original_str if c.isalpha()]  # 提取所有字母
    letters.reverse()  # 翻转字母顺序
    new_str_list = []
    letter_index = 0
    for c in original_str:
        if c.isalpha():  # 如果当前字符是字母，则从翻转后的字母列表中取出
            new_str_list.append(letters[letter_index])
            letter_index += 1
        else:  # 如果不是字母，保持原样
            new_str_list.append(c)
    # 将列表转换回字符串
    return ''.join(new_str_list)

# 示例使用
original_str = "Python3.8"
print(reverse_letters(original_str))

答案或代码解析：
首先，使用列表推导式和isalpha()方法提取输入字符串original_str中的所有字母，并将这些字母存储在列表letters中。然后，使用reverse()方法翻转letters列表中的字母顺序。

接下来，初始化一个空列表new_str_list用于构建新字符串，并设置一个变量letter_index用于追踪letters列表中当前字母的位置。

通过for循环遍历原始字符串original_str中的每个字符。在循环体内，使用isalpha()方法判断当前字符是否为字母：

• 如果是字母，则从letters列表中按letter_index索引取出相应的翻转字母（该字母添加到new_str_list列表中，并更新letter_index以指向下一个字母）。
• 如果当前字符不是字母，则直接将其添加到new_str_list列表中，保持该字符的原始位置不变。

循环结束后，使用join()方法将new_str_list列表中的元素连接成一个新字符串，并返回这个新字符串。

这道题目考察了面试者对字符串操作、循环结构以及条件判断的综合应用能力，同时也考验了对列表和字符串不可变特性的理解。通过这种方式，检验了面试者处理较复杂字符串操作问题的能力。

面试题4

问题：编写一个Python函数，使用while循环和for循环，找出0-100之间能被3, 5同时整除的数，并且一旦找到第一个能被7整除的数就立刻停止搜索。

面试考题知识点：

• 理解和掌握Python中的for循环和while循环。
• 掌握使用break控制循环的执行。
• 理解和使用条件语句进行判断。

答案或代码：

def find_special_numbers():
    number = 0
    while True:  # 开始一个无限循环
        for i in range(number, 101):  # for循环遍历从number到100的所有数
            if i % 3 == 0 and i % 5 == 0:  # 如果数i能同时被3, 5整除
                print(i)
                if i % 7 == 0:  # 如果数i还能被7整除
                    return  # 结束函数，跳出循环
        number += 1  # 每次while循环结束后，number增加1

# 示例使用
find_special_numbers()

答案或代码解析：
在函数find_special_numbers()中，我们使用一个无限while循环来控制整个函数的执行。在while循环内，我们再使用一个for循环来遍历从number到100的所有数。

在for循环的循环体内，使用条件语句检查数i是否能同时被3, 5整除。如果找到这样的数，则打印出来。然后我们再检查是否i同时能被7整除，如果能，就执行return语句结束函数，也就跳出了外部的while循环。

当进行下一次while循环时，增加number的值，而for循环则从新的number开始遍历，以此类推，直到找到符合条件的数。

这道题目考察了面试者对循环结构以及循环控制语句的理解和应用，并涉及了如何在满足特定条件时控制循环的结束。

面试题5

问题：编写一个Python函数，该函数接受一个整数列表作为输入，并返回一个新的列表。新列表应该包含输入列表中每个元素的累积乘积，但是，使用一个循环实现此功能，并在计算过程中遇到0时跳过这个数，继续乘下一个数。例如，input_list = [1, 2, 3, 0, 4, 5]，则返回的列表应为[1, 2, 6, 6, 24, 120]。

面试考题知识点：

• 理解和应用循环结构进行列表遍历和操作。
• 掌握使用continue来控制循环的执行。
• 理解列表的使用和累积乘积的计算方法。

答案或代码：

def cumulative_product(input_list):
    result = []  # 用于存储累积乘积的新列表
    product = 1
    for num in input_list:
        if num == 0:  # 遇到0时跳过
            continue
        product *= num  # 计算累积乘积
        result.append(product)  # 将当前的累积乘积添加到结果列表中
    return result

# 示例使用
input_list = [1, 2, 0, 3, 0, 4, 5]
print(cumulative_product(input_list))

答案或代码解析：
函数cumulative_product(input_list)通过一个for循环遍历输入的整数列表input_list。在循环体内，首先判断当前元素是否为0，如果是，则执行continue语句跳过当前循环的其余操作，移动到下一个元素。

如果当前元素不为0，则计算到目前为止所有非零元素的累积乘积，使用一个变量product来保存这个累积乘积值。在每次循环中，将当前元素乘以product并更新product的值，然后将product的新值添加到结果列表result中。

这道题目考察了面试者对于循环结构的掌握、对特殊情况（如列表中存在0）的处理能力，以及对于列表操作和累积计算的理解。通过这种方式，检验了面试者解决实际问题的能力及其编码实践。

面试题6

问题：编写一个Python函数以实现斐波那契数列的生成器，该生成器能根据用户输入的数n，生成斐波那契数列中的前n个数。但是，如果在数列生成过程中遇到第一个大于100的数，则停止生成并退回所有已生成的数，不管n的值如何。

面试考题知识点：

• 理解和应用Python的for循环和while循环。
• 熟悉斐波那契数列的计算方式。
• 掌握yield关键字，了解生成器的使用。
• 掌握使用break控制循环的执行。

答案或代码：

def fibonacci_generator(n):
    a, b = 0, 1
    count = 0
    while count < n:  # 进行循环直到生成了n个数
        if a > 100:  # 如果当前数大于100，停止生成
            break
        yield a  # 返回当前的斐波那契数
        a, b = b, a + b  # 计算下一个斐波那契数
        count += 1

# 示例使用
n = 10
print(list(fibonacci_generator(n)))

答案或代码解析：
函数fibonacci_generator(n)定义了一个生成器，用来产生斐波那契数列中的前n个数。该函数首先将初始的两个斐波那契数设定为0和1，然后使用一个while循环来持续生成后续的斐波那契数，直到生成了用户请求的n个数。

在生成过程中，使用yield关键字来返回当前的斐波那契数，这使得函数暂停执行并返回当前值，等待下一次迭代。如果在生成过程中遇到一个大于100的数，则使用break语句退出循环，停止生成。由于使用了yield，这个函数实际上是一个生成器，能够逐个生成斐波那契数，而不是一次性返回整个数列。

这道面试题不仅考察了面试者对循环结构、条件语句的掌握，也考查了对生成器和yield关键字的理解。此外，正确处理斐波那契数列的生成逻辑以及控制条件，展示了面试者解决问题的能力。

面试题7

问题：编写一个Python函数，该函数接收一个字符串作为参数，并返回一个字典。这个字典应包含每个字符出现的次数。但是，如果在统计过程中遇到空格(’ ')，不仅需要跳过不计算，而且需要立即停止统计剩余的字符，并返回当前已统计的结果。

面试考题知识点：

• 理解和应用Python的循环控制结构（特别是for循环和break语句）。
• 掌握字符串和字典的操作。
• 理解如何基于条件判断（遇到空格时的处理）控制循环的流程。

答案或代码：

def count_characters_until_space(s):
    char_count = {}  # 初始化一个空字典来存储字符计数
    for char in s:
        if char == ' ':  # 遇到空格时立即停止循环
            break
        if char not in char_count:  # 如果字符不在字典中，则添加
            char_count[char] = 1
        else:
            char_count[char] += 1  # 如果字符已存在，则计数加1
    return char_count

# 示例使用
test_str = "hello world"
print(count_characters_until_space(test_str))

答案或代码解析：
函数count_characters_until_space(s)遍历输入字符串s中的每个字符，并统计每个字符出现的次数。在进行字符遍历时使用了for循环，每遍历到一个字符就对其出现次数进行计数，并将结果存储在字典char_count中。

当遇到空格字符时，通过if char == ' ':语句进行判断，并使用break语句立即跳出循环，停止之后所有字符的统计。这样做实现了题目要求的“遇到空格立即停止统计”的功能。

这道题目不仅考查了面试者对Python基本数据结构（字符串和字典）的操作能力，也考查了对循环控制语句（特别是break）的应用能力，以及在特定条件下如何优雅地中断程序执行的能力。

面试题8

问题：设计一个Python函数，它可以接收一个整数列表作为输入参数，找出并返回列表中出现次数超过列表长度一半的元素，如果没有这样的元素，则返回None。面试题需要考虑效率问题，尽量只遍历列表一次，并且不使用额外的空间来存储计数信息。提示：尝试使用摩尔投票算法。

面试考题知识点：

• 理解和应用循环结构进行列表遍历。
• 掌握条件判断语句。
• 理解摩尔投票算法的原理和应用。
• 熟悉空间复杂度和算法效率的问题。

答案或代码：

def find_majority_element(nums):
    candidate = None
    count = 0
    for num in nums:
        if count == 0:
            candidate = num
            count = 1
        elif candidate == num:
            count += 1
        else:
            count -= 1
    
    # 验证候选是否确实是多数元素
    if nums.count(candidate) > len(nums) // 2:
        return candidate
    else:
        return None

# 示例使用
test_list = [3, 3, 4, 2, 4, 4, 2, 4, 4]
print(find_majority_element(test_list))

答案或代码解析：
这个函数find_majority_element(nums)使用摩尔投票算法来寻找出现次数超过列表长度一半的元素。算法的基本思路是维护一个候选元素candidate和一个计数器count。遍历列表过程中，如果计数器为0，则将当前元素作为候选元素，并将计数器设为1。如果遇到与候选元素相同的元素，则计数器加1；如果遇到一个不同的，则计数器减1。由于多数元素的数量超过列表长度的一半，因此遍历一遍后，候选元素就是我们要找的多数元素。

但是，由于上述过程可能会选出一个并非真正的多数元素（尤其在有多个相同数量但不足以超过半数的元素时），所以在得到一个候选元素后，需要重新遍历数组来验证这个候选元素是否确实是多数元素。这一步是必要的，确保函数的正确性。

这个面试题考察了面试者对于高效算法设计的理解，特别是在空间复杂度要求高（不使用额外空间）的情况下，如何巧妙地利用算法特性（摩尔投票算法）来实现要求的功能。此外，也考察了对问题细节的关注和应对（最后的验证步骤）。

面试题9

问题：编写一个Python函数，该函数接受一个正整数列表作为输入，并返回这个列表中所有元素的最大公约数(GCD)。要求只遍历输入列表一次，并且不使用Python库中的任何现成的GCD函数。

面试考题知识点：

• 理解循环结构（如for循环）来遍历列表。
• 掌握计算两个数最大公约数的算法（Euclid算法）。
• 能够将Euclid算法扩展应用到一组数的最大公约数计算。
• 理解递归和迭代的应用。

答案或代码：

def gcd(a, b):
    """计算两个数的最大公约数 using Euclid's algorithm."""
    while b:
        a, b = b, a % b
    return a

def find_gcd_list(numbers):
    """找到列表中所有数的最大公约数。"""
    list_gcd = numbers[0]  # 以列表中的第一个数作为初始的GCD
    for number in numbers[1:]:
        list_gcd = gcd(list_gcd, number)  # 计算当前的GCD与列表中下一个元素的GCD
        if list_gcd == 1:  # 如果最大公约数为1，直接返回，因为不可能有比1更小的正公约数了
            return 1
    return list_gcd

# 示例使用
test_list = [44, 88, 64, 128]
print(find_gcd_list(test_list))

答案或代码解析：
此函数首先定义了一个计算两个数最大公约数的辅助函数gcd，使用了Euclid的算法。Euclid算法基于这样一个事实：两个整数的最大公约数与这两个整数的差的最大公约数相同。因此，通过连续替换较大的数与较小数的差，最终可以找到两个数的最大公约数。

主函数find_gcd_list(numbers)使用gcd函数作为工具，通过迭代计算列表中所有数的最大公约数。程序假设列表中的第一个元素是当前的最大公约数，然后遍历列表中的其余元素，逐个计算与当前最大公约数的最大公约数。如果在任何时候计算的最大公约数变为1，则程序立即返回1，因为这意味着列表中的所有数是互素的，也就是说没有大于1的公约数。

这个面试题考察了面试者对算法的理解和应用能力，特别是如何将基本算法（Euclid算法）扩展到更复杂的场景（计算列表中所有元素的最大公约数），以及如何高效地处理问题，通过提前终止循环以优化性能。

面试题10

问题：编写一个Python函数，该函数将接收一个整数列表和一个目标值作为输入，返回一个布尔值，指示列表中是否存在一对数，其和等于目标值。该函数必须在不使用额外空间的情况下，尽量仅遍历列表一次。

面试考题知识点：

• 理解和应用循环结构（特别是for循环）和条件语句。
• 掌握如何有效地在一次遍历中处理和分析数据。
• 理解空间复杂度的概念以及如何实现空间高效的算法。

答案或代码：

def has_pair_with_sum(numbers, target):
    seen = set()  # 使用集合来存储遍历过程中遇到的数字，集合的查找时间为O(1)
    for number in numbers:
        if target - number in seen:  # 如果目标值减去当前数字在之前遇到的数字中，则返回True
            return True
        seen.add(number)  # 将当前数字添加到已看到数字的集合中
    return False  # 如果遍历完成没有找到符合条件的数字对，则返回False

# 示例使用
test_list = [1, 2, 4, 4]
target = 8
print(has_pair_with_sum(test_list, target))

答案或代码解析：
此函数has_pair_with_sum(numbers, target)利用一个集合seen来存储在遍历整数列表过程中遇到的数字。该集合记录每个数字是否出现过，以支持快速的查找操作（查找时间复杂度为O(1)）。

在遍历列表的每一步中，函数都会检查（target - 当前数字）是否已经在之前的遍历中出现过。如果是，这意味着存在一个之前遇到的数字加上当前数字等于目标值，因此函数返回True。如果遍历结束后还没有找到满足条件的数字对，函数返回False。

通过以上解法，函数只需遍历列表一次且不需要额外的空间来存储大量信息（除了输入列表和目标值之外），只需要一个集合来存储已遇到的数字。这样既实现了空间高效性，也保证了算法的效率。

这个面试题检验了面试者解决问题的创新能力，特别是在有限资源（例如，不使用额外空间）的约束下，如何巧妙地利用数据结构（这里是集合）来优化算法的性能。