python-2/06-Python流程控制.md

# 06-Python流程控制

**内置函数range()**

内置函数 [`range()`](https://docs.python.org/zh-cn/3.12/library/stdtypes.html#range) 用于生成等差数列：

```python
>>> for i in range(5):
...     print(i)
0
1
2
3
4
```

生成的序列绝不会包括给定的终止值；`range(10)` 生成 10 个值——长度为 10 的序列的所有合法索引。range 可以不从 0 开始，且可以按给定的步长递增（即使是负数步长）：

```python
>>> list(range(5, 10))
[5, 6, 7, 8, 9]

>>> list(range(0, 10, 3))
[0, 3, 6, 9]

>>> list(range(-10, -100, -30))
[-10, -40, -70]
```

如果直接打印一个 range 会发生意想不到的事情：

```
>>> range(10)
range(0, 10)
```

[`range()`](https://docs.python.org/zh-cn/3.12/library/stdtypes.html#range) 返回的对象在很多方面和列表的行为一样，但其实它和列表不一样。该对象只有在被迭代时才一个一个地返回所期望的列表项，并没有真正生成过一个含有全部项的列表，从而节省了空间。

这种对象称为可迭代对象 [iterable](https://docs.python.org/zh-cn/3.12/glossary.html#term-iterable)，适合作为需要获取一系列值的函数或程序构件的参数。[`for`](https://docs.python.org/zh-cn/3.12/reference/compound_stmts.html#for) 语句就是这样的程序构件；以可迭代对象作为参数的函数例如 [`sum()`](https://docs.python.org/zh-cn/3.12/library/functions.html#sum)：

```python
>>> sum(range(4))  # 0 + 1 + 2 + 3
6
# 注意：虽然可迭代对象有很多，但sum只适用于list和tuple,不支持str和字典
```

## 一、Python 条件判断

Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。

Python程序语言指定任何非0和非空（null）值为true，0 或者 null为false。

**基本形式**

```python
if 判断条件：
	执行语句……
else：
	执行语句……
```

其中"判断条件"成立时（非零），则执行后面的语句，而执行内容可以多行，以缩进来区分表示同一范围。
else 为可选语句，当需要在条件不成立时执行内容则可以执行相关语句

**判断条件**

​	可以用>、<、==、>=、<=来表示其关系。

**多条件判断**

```python
if 判断条件1:
	执行语句1……
elif 判断条件2:
	执行语句2……
elif 判断条件3:
	执行语句3……
else:
	执行语句4……
```

Python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断时，可以使用  or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。

```python
#!/usr/bin/python3.8
num = 9
if num >= 0 and num <= 10:    
    print('hello')
        
num = 10
if num < 0 or num > 10:   
    print('hello')
else:
    print('undefine')

num = 8
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):    
    print('hello')
else:
    print('undefine')
```

**简单语句组**
可以在同一行的位置上使用if条件判断语句

```python
var = 100 
if ( var  == 100 ) : print("变量 var 的值为100") 
```

**match语句**

在Python 3.10中，引入了一种新的结构，即“结构化匹配”，通过`match`语句实现。`match`语句类似于`switch`语句，可以用来匹配一些特定的模式。就像是`if-elif-else`语句的升级版，提供了更多的功能和灵活性。

`match`语句常用于处理这样一些情况：当你有一个变量，你想在这个变量满足不同的条件时做不同的事情。例如，你可能想将一个变量与几个不同的常数比较，或者你可能想检查一个变量是否具有特定的结构，比如它是一个列表并且具有特定的长度。

以下是使用`match`的基本语法：

```python
match expression:
    case pattern1:
        # 做一些事
    case pattern2:
        # 做其他事
```

`expression` 是你想匹配的表达式，`pattern1`和`pattern2`等是你定义的模式。各种不同的模式可以用来匹配值的类型，列表的长度，或者字典是否有某个键，等等。

例如

```python
def http_response_status(code):
    match code:
        case 200:
            return "Success"
        case 404:
            return "Not Found"
        # 当没有匹配的值时，使用`_`作为默认模式
        case _:
            return "Unknown status"

print(http_response_status(200))  # 输出：Success
print(http_response_status(500))  # 输出：Unknown status
```

在这个例子中，`match`语句将`code`和变量后面的每一种可能进行比较，然后执行第一个匹配的`case`语句的代码块。如果没有匹配的`case`语句，那么就执行默认的`_`模式的代码块。

## 二、Python迭代

​    迭代是重复反馈过程的活动，其目的通常是为了接近并到达所需的目标或结果。每一次对过程的重复被称为一次"迭代"，而每一次迭代得到的结果会被用来作为下一次迭代的初始值。

​	迭代是程序中对一组指令（或一定步骤）的重复。它既可以被用作通用的术语（与"重复"同义），也可以用来描述一种特定形式的具有可变状态的重复。

​    比如for循环就是一种编程语言的迭代陈述，能够让代码反复的执行。


## 三、Python 循环语句

循环语句允许我们执行一个语句或语句组多次

**循环类型**

Python提供了for和while循环（Python中没do..while）:

| 循环类型   | 描述                                                   |
| ---------- | ------------------------------------------------------ |
| while 循环 | 在给定的判断条件为 true 时执行循环体，否则退出循环体。 |
| for 循环   | 重复执行语句                                           |
| 嵌套循环   | 可以在while循环体中嵌套for循环，反之亦可               |

**循环控制**
    循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句：

| 控制语句      | 描述                                                         |
| ------------- | ------------------------------------------------------------ |
| break 语句    | 在语句块执行过程中终止循环，并且跳出整个循环                 |
| continue 语句 | 在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。 |
| pass 语句     | pass是空语句，是为了保持程序结构的完整性。                   |

**while循环**
语法：

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

执行语句

​	可以是单个语句或语句块。

判断条件

​	可以是任何表达式，任何非零、或非空（null）的值均为true。
​	当判断条件假false时，循环结束。

例：

```python
#!/usr/bin/python3.8
count = 0
while (count < 9):
   print('The count is:', count)
   count = count + 1
print("Good bye!") 
```

continue 用于跳过该次循环，break 则是用于退出循环，此外"判断条件"还可以是个常值，表示循环必定成立，具体用法如下：

```python
#!/usr/bin/python3.8
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
```

**无限循环**
    如果条件判断语句永远为 true，循环将会无限的执行下去，如下实例： 

```python
#!/usr/bin/python3.8
var = 1
while var == 1 :        # 该条件永远为true，循环将无限执行下去
   num = input("Enter a number  :")
   print("You entered: ", num)
print("Good bye!" )
```

**循环使用 else 语句**
    在 python 循环里，else 中的语句会在循环正常执行完，即循环不是通过 break 跳出而中断的情况下执行

```python
#!/usr/bin/python3.8
count = 0
while count < 5:
   print(count, " is  less than 5")
   count = count + 1
else:
   print(count, " is not less than 5")
```

**简单语句组**
类似if语句的语法，如果你的while循环体中只有一条语句，你可以将该语句与while写在同一行中， 如下所示：

```python
flag = 1
while (flag): print("Given flag is really true!")
```

**for循环**
for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
语法：
for iterating_var in sequence:
   statements(s)   

实例：

```python
#!/usr/bin/python3.8
for letter in 'Python': 
   print('当前字母 :', letter)
fruits = ['banana', 'apple',  'mango']
for fruit in fruits: 
   print('当前字母 :', fruit)
```

​    以上实例输出结果:
​    当前字母 : P
​    当前字母 : y
​    当前字母 : t
​    当前字母 : h
​    当前字母 : o
​    当前字母 : n
​    当前字母 : banana
​    当前字母 : apple
​    当前字母 : mango

**通过序列索引迭代**
另外一种执行循环的遍历方式是通过索引，如下实例：

```python
#!/usr/bin/python3.8
fruits = ['banana', 'apple',  'mango']
for index in range(len(fruits)):
	print('当前水果 :', fruits[index])
```

以上实例输出结果：
    当前水果 : banana
    当前水果 : apple
    当前水果 : mango

注：内置函数 len() 和 range()
      len()     返回列表的长度，即元素的个数。
      range() 返回一个序列的数。

**循环使用 else 语句**
实例：

```python
#!/usr/bin/python3.8
for num in range(10,20):   			# 迭代 10 到 20 之间的数字
   for i in range(2,num):     		# 根据因子迭代
      if num%i == 0:           		# 确定第一个因子
         j=num/i                    # 计算第二个因子
         print ('%d 等于 %d * %d' % (num,i,j))
         break                      # 跳出当前循环
   else:                            # 循环的 else 部分
      print (num, '是一个质数')

输出结果：
    10 等于 2 * 5
    11 是一个质数
    12 等于 2 * 6 
    13 是一个质数
    14 等于 2 * 7
    15 等于 3 * 5
    16 等于 2 * 8
    17 是一个质数
    18 等于 2 * 9
    19 是一个质数
```



**循环嵌套**
Python 语言允许在一个循环体里面嵌入另一个循环。

```python
for 循环嵌套语法：
    for iterating_var in sequence:
       for iterating_var in sequence:
          statements(s)
       statements(s)

while 循环嵌套语法：
    while expression:
       while expression:
          statement(s)
       statement(s)
```

**continue和break语句：**
    continue 语句跳出本次循环，而break跳出整个循环。
    continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。

**pass语句**
pass是空语句，不做任何事情，一般用做占位语句,为了保持程序结构的完整性。

```python
语法：
    pass
```



**itertools模块**
包含特殊用途的迭代器函数
 **1、 chain()    用于同时迭代不同类型的数据，比如列表和元组，可同时传入多个迭代类型数据参数**

```python
import itertools
for item in  itertools.chain([1,2],('a','b'),[3,4]):
    print(item)
   
1
2
a
b
3
4

```

**2、cycle()  用于迭代且循环访问一个可迭代数据,只能传一个迭代类型的数据参数**

```python
import itertools
for item in itertools.cycle([1,2]):
  print(item)
1
2
1
2
...
```



******

```
******
******
******

*
**
***
****
*****

    *
   ***
  *****
 *******
*********


    *
   ***
  *****
 *******
*********
  *****
 *******
*********
   ***
   ***
   ***
------------------
    *
   * *
  *   *
 *     *
*********







```






​