Python 中的控制流要包含 if、for、while循环：

条件控制

if语句是最常用的条件控制语句，关键字有if、elif、else。

if 条件一：
    statements!
elif 条件二：
    statements 2
else:
    statements3

注意：

• 1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。

• 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。

if 嵌套

在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。

match...case

Python 3.10 增加了 match...case 的条件判断，不需要再使用一连串的 if-else 来判断了。

match 后的对象会依次与 case 后的内容进行匹配，如果匹配成功，则执行匹配到的表达式，否则直接跳过，_ 可以匹配一切。

match subject:
    case <pattern_1>:
        <action_1>
    case <pattern_2>:
        <action_2>
    case <pattern_3>:
        <action_3>
    case _:
        <action_wildcard>

case _: 类似于 C 和 Java 中的 default:，当其他 case 都无法匹配时，匹配这条，保证永远会匹配成功。

一个 case 也可以设置多个匹配条件，条件使用 ｜ 隔开，例如：case 401|403|404:

循环语句

while 循环

语句的形式为：
while 条件一：
    statementsl

我们可以通过设置条件表达式永远不为 false 来实现无限循环

while 循环使用 else 语句

如果 while 后面的条件语句为 false 时，则执行 else 的语句块。

语法格式如下：

#expr 条件语句为 true 则执行 statement(s) 语句块，如果为 false，则执行 additional_statement(s)。
while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>

简单语句组

类似 if 语句的语法，如果你的 while 循环体中只有一条语句，你可以将该语句与 while 写在同一行中

for 语句

for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。

for循环的一般格式如下：

for <variable> in <sequence>:
    <statements>
else:
    <statements>

for...else

在 Python 中，for...else 语句用于在循环结束后执行一段代码。

语法格式如下：

for item in iterable:
    # 循环主体
else:
    # 循环结束后执行的代码

当循环执行完毕（即遍历完 iterable 中的所有元素）后，会执行 else 子句中的代码，如果在循环过程中遇到了 break 语句，则会中断循环，此时不会执行 else 子句。

在for循环中，使用切片

如果在循环体内，执行语句对for后面的序列数据进行了修改，这会影响到for语句的初始循环次数。

words＝['I', 'love','Python']    #定义一个列表
for  item  in  words [ :] :      #for后面没有使用words，而是使用了切片作为words的副本
    words.insert(O ,  item)      #向words里插入一个元素
    print(item)                  #打印item，三次迭代分别输出：I,love,Python
print(words)                    #打印整个words，输出：［’Python’,'love’,'I','I','love','Python']

内置函数range

range的意思是返回一个数字区间的所有整数。

range中的参数默认是从0开始。

range函数中还可以有第三个参数一一步长。即，从起始到结束，每隔“步长个数字”返回一次。

内置函数zip

for语句还可以配合内置函数zip，以同时遍历多个序列。

zip函数可以将任意多的“序列”类型数据结合起来，生成新序列数据。生成的新序列数据中，每个元素都是一个元组。该元组的元素是由传入zip函数中的多个序列数据的元素组成。

x=[l, 2, 3)                #定义俩个列表，x与y
y=[3 , 2 ,"hello"]
t =  zip(x , y)            #通过zip生成一个新的序列t，这时t是zip类型
print  (tuple(t))          #将t转成元组，并打印。输出：((1 , 3) ,  (2,  2),  (3,  ‘hello'))

需要注的是，当zip对象（t）被转化为元组或列表后，就会自动销毁。如果再使用t，将得不到具体的元素。

x=[l,2,3]                     #定义俩个列表，x与y
y=[3,2 ,"hello" ]
t =  zip(x , y)               # 通过zip生成一个新的序列t，这时t是zip类型  
print(list(t))                #将t转成列表并打印，输出：[(1 , 3) ,  (2,  2),  (3,  ‘hello')]
print(tuple(t))               #再次将t转成元组，得到的是空数组，输出：()

zip对象还可以通过前面加个字符“＊”的方式来完成unzip的过程，所谓unzip，就是将zip生成的数据返回。

x=[l,2,3]                     #定义俩个列表，x与y
y=[3,2 ,"hello" ]
t =  zip(x , y)               # 通过zip生成一个新的序列t，这时t是zip类型  
print(*)                      #在t面加一个*，完成unzip。输出：(1 , 3)  (2, 2)  (3,  'hello')
print(*)                      #同样，t只能unzip一次，再次使用时，会返回空位。没任何输出

如果zip里面的序列长度不同，就会以最短的序列数据为主。

内置函数enumerate

enumerate函数的作用是，将“序列”类型的数据生成带序号的新序列数据。

使用enumerate生成的新序列中，每个元素都是一个元组，该元组是由传入enumerate函数中序列的元素与其对应的索引组成的。

x =[ "hello", 5,  6]          #定义l个列表x
t =  enumerate(x)              #通过enumerate生成一个新的序列t，这时t是enumerate类型
print(tuple(t))                #将t转成元组，并打印，输出：((0,'hello'), ( 1,  5) ,  (2 ,  6))

#for循环中，需要定义两个变量来接收enumerate后的返回值：一个是元素的索引，一个是具体的元素。
for i , t2  in  enumerate(x):      #循环边历enumerate后的x  
    print(i , t2)                  #将i、t2打印出来
#输出
0  hello
1 5
2 6

enumerate与for的结合为程序提供了更大的方便性。enumerate的第一个返回值在循环里同时也起到计数的作用，可以直接当作循环的次数来使用。

循环控制

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。

continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

pass：该语句什么都不做，是为了保持程序结构的完整性。常用在语法上需要一条语句但又不需要任何操作的情况下。

迭代器

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器：

#!/usr/bin/python3
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")


import sys         # 引入 sys 模块
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print (next(it))    #使用 next() 函数
    except StopIteration:
        sys.exit()

创建一个迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。

__iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。

__next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。

创建一个返回数字的迭代器，初始值为 1，逐步递增 1：

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    x = self.a
    self.a += 1
    return x
 
myclass = MyNumbers()
myiter = iter(myclass)
 
print(next(myiter))

StopIteration

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

在 20 次迭代后停止执行：

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
 
myclass = MyNumbers()
myiter = iter(myclass)
 
for x in myiter:
  print(x)

生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

调用一个生成器函数，返回的是一个迭代器对象。

#!/usr/bin/python3
 
import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

函数 input()

函数 input() 让程序暂停运行，等待用户输入一些文本。获取用户输入后，Python将其存储在
一个变量中，以方便你使用。

使用函数 input() 时，Python将用户输入解读为字符串。可使用函数 int() ，它让Python将输入视为数值。