在 Python 编程语言中有两种类型的循环，即 for 循环和 while 循环。使用这些循环，我们可以在 Python 中创建嵌套循环。嵌套循环意味着循环内的循环。比如for循环里面的while循环，for循环里面的for循环等等。

Python 嵌套循环

Python 嵌套循环语法：

Outer_loop 表达式：

Inner_loop 表达式：

inner_loop 中的语句

Outer_loop 内的语句

Python 嵌套循环示例

示例 1：Python 嵌套循环的基本示例

Python3实现

x = [1, 2]

y = [4, 5]

  for i in x:

  for j in y:

    print(i, j)

 

输出：

1 4

1 5

2 4

2 5

时间复杂度：O(n²)

空间复杂度：O(1)

示例 2：使用 Python 嵌套 for 循环打印乘法表

Python3实现

# Running outer loop from 2 to 3

  for i in range(2, 4):

      # Printing inside the outer loop

    # Running inner loop from 1 to 10

    for j in range(1, 11):

          # Printing inside the inner loop

        print(i, "*", j, "=", i*j)

    # Printing inside the outer loop

    print()

输出：

2 * 1 = 2

2 * 2 = 4

2 * 3 = 6

2 * 4 = 8

2 * 5 = 10

2 * 6 = 12

2 * 7 = 14

2 * 8 = 16

2 * 9 = 18

2 * 10 = 20

3 * 1 = 3

3 * 2 = 6

3 * 3 = 9

3 * 4 = 12

3 * 5 = 15

3 * 6 = 18

3 * 7 = 21

3 * 8 = 24

3 * 9 = 27

3 * 10 = 30

时间复杂度：O(n²)

空间复杂度：O(1)

在上面的例子中，我们做的是一个从 2 到 3 运行的外部 for 循环，用于 2 和 3 的乘法表，然后在该循??环内，我们采用一个内部 for 循环，它在内部从 1 到 10 运行是 打印乘法表，通过将内循环的每个迭代值乘以外循环的 迭代值正如我们在下面的输出中看到的那样循环。

示例 3：使用不同的内部和外部嵌套循环打印

Python3实现

# Initialize list1 and list2

# with some strings

list1 = ['I am ', 'You are ']

list2 = ['healthy', 'fine', 'geek']

  # Store length of list2 in list2_size

list2_size = len(list2)

  # Running outer for loop to

# iterate through a list1.

for item in list1:

        # Printing outside inner loop

    print("start outer for loop ")

    # Initialize counter i with 0

    i = 0

    # Running inner While loop to

    # iterate through a list2.

    while(i < list2_size):

                # Printing inside inner loop

        print(item, list2[i])

        # Incrementing the value of i

        i = i+1

    # Printing outside inner loop

    print("end for loop ")

输出：

start outer for loop

I am  healthy

I am  fine

I am  geek

end for loop
start outer for loop
You are  healthy

You are  fine

You are  geek
end for loop

时间复杂度：O(n²)

空间复杂度：O(1)

在此示例中，我们使用一些 字符串 初始化两个 列表。使用 len() 函数将 list2 的大小存储在“list2_Size”中，并在 while 循环中用作计数器。之后运行外部 for 循环以 迭代 list1 并在该循环内运行内部 while 循环以使用 list indexing 里面我们为 list1 的每个值打印 list2 的每个值。

在嵌套循环中使用 break 语句

它是一种循环控制语句。在循环中，我们可以使用 break 语句 退出循环。当我们在循环中使用 break 语句时，它会跳过其余的迭代并终止循环。让我们用一个例子来理解它。

代码：

Python3实现

# Running outer loop from 2 to 3

for i in range(2, 4):

      # Printing inside the outer loop

    # Running inner loop from 1 to 10

    for j in range(1, 11):

      if i==j:

        break

      # Printing inside the inner loop

      print(i, "*", j, "=", i*j)

    # Printing inside the outer loop

    print()

输出：

2 * 1 = 2

3 * 1 = 3

3 * 2 = 6

时间复杂度：O(n²)

空间复杂度：O(1)

上面的代码与示例 2 中的代码相同。在这段代码中，我们通过 if 语句在内循环中使用了一个 break 语句。在内部循环中，如果“i”等于“j”，则内部循环将终止并且不执行剩余的迭代，正如我们在输出表中看到的 3 打印最多两次迭代，因为在下一次迭代中'i' 等于 'j' 并且循环中断。

在嵌套循环中使用 continue 语句

continue 语句也是一种循环控制语句。它与 break 语句正好相反。 continue 语句强制循环跳转到循环的下一次迭代，而 break 语句终止循环。让我们通过代码来理解它。

Python3实现

# Running outer loop from 2 to 3

for i in range(2, 4):

      # Printing inside the outer loop

    # Running inner loop from 1 to 10

    for j in range(1, 11):

      if i==j:

        continue

      # Printing inside the inner loop

      print(i, "*", j, "=", i*j)

    # Printing inside the outer loop

    print()

输出：

2 * 1 = 2

2 * 3 = 6

2 * 4 = 8

2 * 5 = 10

2 * 6 = 12

2 * 7 = 14

2 * 8 = 16

2 * 9 = 18

2 * 10 = 20

3 * 1 = 3

3 * 2 = 6

3 * 4 = 12

3 * 5 = 15

3 * 6 = 18

3 * 7 = 21

3 * 8 = 24

3 * 9 = 27

3 * 10 = 30

时间复杂度：O(n²)

空间复杂度：O(1)

在上面的代码中，我们使用的是 continue 语句，而不是使用 break 语句。在这里，当内部循环中的“i”等于“j”时，它会跳过内部循环中的其余代码并跳转到下一次迭代，正如我们在输出“2 * 2 = 4”和“3 * 3”中看到的那样= 9” 不会打印，因为此时 'i' 变为等于 'j'。

使用列表理解的单行嵌套循环

要将多行嵌套循环转换为单行，我们将使用 Python 中的列表推导。列表推导包括由表达式组成的括号，它对每个元素执行，以及用于迭代列表中每个元素的 for 循环。

列表理解的语法：

newList = [ 表达式(元素)for 元素在 oldList if条件]< span style="background-color:#f9f9f9;color:#273239">

代码：

Python3实现

# Using  list comprehension to make

# nested loop statement in single line.

list1 = [[j for j in range(3)]

         for i in range(5)]

# Printing list1

print(list1)

输出：

[[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]

在上面的代码中，我们在列表推导 [j for j in range(3)] 的内部循环中使用列表推导在列表中存储一个列表，以便为每次迭代创建一个列表 [0, 1, 2]外循环“for i in range(5)”。

时间复杂度：O(n²)

空间复杂度：O(n)