# 02.流程控制

接下来将要讲下流程控制

## 分支语句

前面操作的时候都是一条条顺序往下执行的，现在来学习一下如何选择执行语句块

### 条件语句

#### **if语句**

```
语法:

if 表达式为真:
    执行语句块
```

先来看下实例:

```
>>> if 1 < 2:
...     print("1小于2")
...
1小于2
```

这里可以看到1比2要小，所以值为真，if条件语句的执行条件是值为真，便可以往下执行，所以这里打印了“1小于2”。如果条件为假，语句块就不会被执行(你猜到了，不是吗)

#### **else 子句**

```
语法:

if 表达式为真:
    执行语句块
else:
    否者执行这个语句块
```

上面利用if语句，添加了一个选项，现在使用else为它多加一个可以选择的选项

(之所以叫子句，是因为else不是独立的语句，需要和if语句一起使用)

实例:

```
>>> if 1 == 2:
...     print("1等于2")
... else:
...     print("1不等于2")
...
1不等于2
```

#### **elif 子句**

如果需要检查多个条件该怎么办?那么就可以使用elif了，elif是else if的简写

```
语法:

if 条件1:
    执行语句块1
elif 条件2:
    执行语句块2
    .....
else:
    都不满足执行这个语句块
```

实例:

```
>>> a = 1
>>> if a==1:
...     print("*")
... elif a==2:
...     print("**")
... else:
...     print("无")
...
*
```

#### 条件表达式(三元操作符)

有时候只需执行if语句以及else子句就可以了，看下实例

```
>>> if 1 == 2:
...     print("1等于2")
... else:
...     print("1不等于2")
...
1不等于2
```

但是会发现如果这样写的话，感觉有点长，那现在可以使用三目运算符来简写这个条件语句

简写这个条件语句之前，先看下三目运算符的语法

```
语法: 输出a if 表达式b else 输出c

解释:如果表达式b条件为真，就执行输出1，否者执行输出c
```

实例:

```
>>> print("1") if 1 < 2 else print("2")
1


>>> print("1等于2") if 1==2 else print("1不等于2")
1不等于2
```

## 断言函数

断言函数用来什么某个条件是真的，其作用是测试一个条件是否成立，如果不成立，则抛出异常

先来看看断言函数assert的语法:

```
语法:

assert condition (expression)
```

如果`condition为false`，就抛出一个`AssertionError`异常

`expression`为可选参数，可以自定以打印的内容

实例:

```
>>> a = 1
>>> b = 2
>>> assert a > b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

>>> assert a > b,'{} is less than {}'.format(a,b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: 1 is less than 2
```

## 循环语句

在实际编程中，需要重复的去执行某些代码的时候不必要去书写多次，而是使用循环语句，重复的执行代码块

### for 循环语句

在讲之前，先来看下for循环语句的语法

```
语法:

for 迭代值 in 序列:
    代码块
```

先看下实例，再来理解

```
items = [2,3,5,6,8,10]

for item in items:
    print(item)

运行结果:    
-------------------------

2
3
5
6
8
10
```

从上面可以知道，迭代的值是从序列中一个一个往后获取的

#### **通过序列索引迭代**

在讲之前需要大致了解下几个内置的函数的用法:

* range()函数:返回一个序列的数

实例：

```
>>> list(range(10))  # 将数据以列表的形式返回
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```

可以到range()函数,可以返回一个从0到9的数，不包括10

```
>>> list(range(0,10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(0,11))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(1,11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
```

* len()函数:返回列表的长度，即元素的个数

实例:

```
>>> len([2,3,5])
3
>>> len([2,3,5,6])
4
```

接下来讲解下如何通过序列索引进行迭代

看下实例:

```
>>> foods = ["apple","banana","fish"]
>>> for i in range(len(foods)):
...     print("当前食物:"+foods[i])
...
当前食物:apple
当前食物:banana
当前食物:fish
```

这里利用len()函数获取foods序列的元素个数，然后利用range()函数返回一个序列\[0,1,2]，然后通过下标获取序列的元素

#### **else语句**

在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样

实例:

```
>>> for food in range(len(foods)):
...     print("当前食物:"+foods[food])
... else:
...     print("循环结束了")
...
当前食物:apple
当前食物:banana
当前食物:fish
循环结束了
```

### while 循环语句

Python 编程中 while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。

来看下while的语法

```
while 判断条件：
    执行语句……
```

执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。

当判断条件假false时，循环结束。

实例:

```
>>> k = 1
>>> while k < 9:
...     print(k)
...     k+=1
...
1
2
3
4
5
6
7
8
```

可以使用continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于退出循环

```
i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非双数时跳过输出
        continue
    print(i)       # 输出双数2、4、6、8、10

i = 1
while 1:            # 循环条件为1必定成立
    print(i)         # 输出1~10
    i += 1
    if i > 10:     # 当i大于10时跳出循环
        break
```

#### **else语句**

在 python 中，while … else 在循环条件为 false 时执行 else 语句块

```
>>> k = 1
>>> while k < 9:
...     print(k)
...     k+=1
... else:
...     print("循环结束了")
```

#### **简写语句**

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

```
>>> while 1<2 : print("1小于2")
```

可以使用`Ctrl+C`来中断循环

### 嵌套循环

用一个九九乘法表的小例子来讲解下什么是嵌套循环？

```
for i in range(1,10):
    for j in range(1,i+1):
        # print("{}*{}={} ".format(j,i,i*j),end="")
        print("%d*%-2d=%-4d" % (j,i,i*j),end=" ")
    print()
```

运行结果：

```
1*1 =1    
1*2 =2    2*2 =4    
1*3 =3    2*3 =6    3*3 =9    
1*4 =4    2*4 =8    3*4 =12   4*4 =16   
1*5 =5    2*5 =10   3*5 =15   4*5 =20   5*5 =25   
1*6 =6    2*6 =12   3*6 =18   4*6 =24   5*6 =30   6*6 =36   
1*7 =7    2*7 =14   3*7 =21   4*7 =28   5*7 =35   6*7 =42   7*7 =49   
1*8 =8    2*8 =16   3*8 =24   4*8 =32   5*8 =40   6*8 =48   7*8 =56   8*8 =64   
1*9 =9    2*9 =18   3*9 =27   4*9 =36   5*9 =45   6*9 =54   7*9 =63   8*9 =72   9*9 =81
```

可以从例子知道，嵌套循环就是在循环中在放入循环，这样做的目的是为了减少代码量的书写，不然上面的九九乘法表不知道要写多少个一个一个的单度的循环，所以要合理利用嵌套循环

## range()

前面讲了下range()函数的一些用法，现在来好好了解下详细的range()函数的用法

range()函数返回的是一个可迭代的对象，而不是列表类型，如果想使range()函数返回的可迭代对象转换为一个列表，需要使用list()函数。

### **函数语法**

```
|  range(stop) -> range object
|  range(start, stop[, step]) -> range object


start:从start开始计数，默认值为0
stop:从stop开始结束，但不包括stop这个数
step:步长，默认为1
```

> 温馨提示
>
> 如果range()函数中，如果不使用start参数，则默认从1开始，如果不使用step参数，则返回的数据之间的间隔为1

实例:

```
>>> range(10) # 返回的是可迭代对象
range(0, 10)

>>> list(range(10)) # 从0开始，到10结束，但不包括10，步长为1即数字之间的差为1，默认值为1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(range(0,10))  # 等价于上面
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(range(2,10)) # 从2开始，到10结束，但不包括10，步长为1即数字之间的差为1，默认值为1
[2, 3, 4, 5, 6, 7, 8, 9]

>>> list(range(2,10,3))  # 从2开始，到10结束，但不包括10，步长为3即数字之间的差为3
[2, 5, 8]

>>> list(range(2,10,5)) # 从2开始，到10结束，但不包括10，步长为5即数字之间的差为5
[2, 7]
```

## break 语句

break 用于终止循环语句。即使循环条件不是 False 或者序列还没被完全递归完，也会终止。

注意:在嵌套循环语句中使用break，break则将结束最深层的循环

实例:

```
for i in range(1,10):
    if i<10:
        print("当前数值:",i)
        break



运行结果
------------------------------
当前数值: 1
```

## continue 语句

continue用于跳过当前循环中剩下的语句，然后继续进行下一轮的循环

实例：

```
for i in range(1,10):
    if i<10:
        print("当前数值:",i)
        continue

运行结果：
--------------------------------
当前数值: 1
当前数值: 2
当前数值: 3
当前数值: 4
当前数值: 5
当前数值: 6
当前数值: 7
当前数值: 8
当前数值: 9
```

## pass 声明

pass语句什么也不做，在程序不需要操作时，可以使用pass语句，一般用看做占位语句

实例：

```
while True:
    pass


def init():
    pass
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://luoran.gitbook.io/luo-ran-de-bi-ji-ben/python-bian-cheng/01python-ji-chu/02.-liu-cheng-kong-zhi.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.