Python分支结构与循环结构

程序的基本结构共有三种，「任何程序都可以由这三种基本结构组合来实现」。

顺序结构
分支结构
循环结构

一、分支结构

　　分支结构是根据判断条件结果而选择不同向前路径的运行方式，分支结构分为：单分支，二分支和多分支。

1）单分支结构

　　单分支结构是分支结构中最简单的一种方式，它的使用方法如下：

1 2	`if` `<条件>:` `<语句块>`

　单分支结构只需要判断一个条件，根据这个条件是否成立来决定是否执行一段语句。

实例1：猜数字

num_in=eval(input("请输入数字："))
if num_in==59:
    print("猜对了")

2）二分支

　　二分支结构是根据条件判断的不同而选择不同执行路径的一种分支结构，它的使用方法如下：

if <条件>:
    <语句块1>
else:
    <语句块2>　

二分支结构也只需要判断一个条件，根据这个条件来决定执行的语句块，成立执行语句块1，不成立执行语句块2。

实例2：猜数字

num_in=eval(input("请输入数字："))
if num_in==59:
    print("猜对了")
else:
    print("猜错了")

3）多分支　　

多分支结构是根据不同条件来选择语句块运行的一种分支结构，它的使用方法如下：

if <条件1>:
    <语句块1>
elif <条件2>:
    <语句块2>
......
else:
    <语句块n>

多分支结构需要判断多个条件，根据判断当前条件是否成立来决定是否执行当前语句块，当所有条件都不成立时，执行else的语句块。

实例3：猜数字

num_in=eval(input("请输入数字："))
if num_in>59:
    print("数字大了")
elif num_in<59:
    print("数字小了")
else:
    print("数字正确")

if、elif、else嵌套

score=80
if score>=60:
    if score>=90:
        print("优秀")
    else:
        print("及格")
else:
    print("不及格")

my_name='Mike'
while True:
    print("输入你的姓名：")
    name=input("输入你的姓名")
 
    if name==my_name:
        print(f"你好，{name}")
        break
    elif name=='q':
        break
    else:
        print("猜的不对，再猜一次")

price=9600
guess_price=0
while guess_price!=price:
    try:
        print("请输入猜测的价格：")
        guess_price=int(input("输入猜测的价格"))
        if guess_price>price:
            print("您猜测的数字大了")
            continue
        elif guess_price<price:
            print("您猜测的数字小了")
            continue
        else:
            print("恭喜你猜对了")    
            break
    except ValueError:
        print("您输入的价格有误")

(3)、异常处理　　

　当使用以下实例时

1 2	`num_in=eval(input("请输入数字："))` `print(num_in)`

　如果不输入数字，而输入字符串，此时会出现如下报错：　

此时就需要使用到Python通过的异常处理的相关机制，异常处理有两种非常基本的使用方法，使用保留字try和except，格式如下：

try:
    <语句块1>
except <异常类型>:
    <语句块2>

while True:
    try:
        score=int(input("请输入成绩"))
        break
    except ValueError:
        print("输入的数字有误")
    except Exception as e:
        # 处理未知错误，防止解释器抛出异常而被终止运行
        print(F"未知错误：{e}")

放在try中的语句块1如果出现异常，将会在except中查找相同的异常类型，执行相应的语句块。如果except后面不跟随异常类型，那么就必须是最后一个except，表示除以上提到的异常类型，其余的异常都采用这个except的语句块。　　

实例：　　

try:
    num_in=eval(input("请输入数字："))
    print(num_in)
except NameError:
    print("当前输入不是数字")

异常处理的高级用法使用到了保留字try、except、else和finally，格式如下：　

try:
    <语句块1>
except <异常类型>:
    <语句块2>
else:
    <语句块3>
finally:
    <语句块4>

　多出来的else语句块在没有发生异常时执行，finally语句块一定执行。　

(4)、循环结构

　　循环语句分为：遍历循环和无限循环

1）遍历循环

遍历循环指遍历某一个结构形成的循环运行方式，它的使用方法如下：

1 2	`for` `<循环变量>` `in` `<遍历结构>:` `<语句块>`

简单说遍历循环是由for in保留字构成的循环结构，它可以从遍历结构中逐一提取元素放到循环变量里。当遍历结构中的所有元素都放入循环变量，并且都已循环执行之后，那么循环程序退出。注意：遍历结构不是一种特殊的类型，它可以是range(m,n,k)、字符串、序列等等。

当遍历结构采用range(m,n,k)时，可以称这种遍历循环结构为计数循环，通过range(m,n,k)产生一个数字序列，这个序列包含(n-m)/k个元素，每个元素都是整数。实例如下：

for count1 in range(5):
    print(count1,end=",")
print()
for count2 in range(1,6,2):  #从1开始到6之间的等差数列，差为2
    print(count2,end=",")

range()字面意思是范围，生成可迭代对象，支持三个参数

range(开始，截止，步长)

range(0,10) 生成0-9一共10个数字的可迭代对象

range(10)只有一个参数，默认起0

range（0,10,2）0起 10止 2步长

0,2,4,6,8

#range()与for是绝配
#先看看range(开始，截止，步长)
#特别注意range()是惰性的 即不叫我我不动，叫我一下我动一下！
print(range(10))
#我们用列表数据类型调用一下看看
print(list(range(10)))
#1、for输出了range返回的10个数字即0-9，这样for就可以有10次运行机会
#2、range实际上是控制了for的循环次数
#3、注意大家看到的0-9输出实际上是range里的元素，只是元素内容是0-9
for num in range(10):
    print(num)
# print('hello,python')
for num in range(0,10,2):
    print(num)
    print('hello,python')

输出结果：

range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0
1
2
3
4
5
6
7
8
9
0
hello,python
2
hello,python
4
hello,python
6
hello,python
8
hello,python

当遍历结构采用字符串时，可以称这种遍历循环结构为字符串遍历循环，循环变量将会遍历字符串的每一个字符。实例如下：

1 2	`for` `str` `in` `"Hello,world":` `print(str,end=",")`

当遍历结构采用列表时，可以称这个遍历结构为列表遍历循环，循环变量将会遍历列表中的每一个元素。（其他序列也可作为遍历结构）实例如下：

1 2	`for` `i` `in` `[123,"PY",567]:` `print(i,end=",")`

当变量结构采用文件（标识符）时，可以称这个遍历结构为文件遍历循环，循环变量将会遍历文件的每一行。

一般只要是多个元素组成的数据类型，都可以被采用。

2）无限循环

无限循环是由条件控制的循环运行方式，它的使用方法如下：

1 2	`while` `<条件判断>:` `<语句块>`

简单来说，它已经不再是遍历某一个结构，而是根据条件判断来进行循环。如果这个条件成立，那么下面的语句块就会被执行，执行之后再次判断条件，如果这个条件再次成立，它就会继续再执行下面的语句块，然后再回来判断循环。所以无限循环是反复执行语句块，直到条件不满足时结束。　

实例：　　

a=3
while a>0:
    a-=1
    print(a)

2
1
0
如果不小心写成了死循环，可以使用<Ctrl>+<C>退出循环。

3）循环控制保留字break和continue、pass

和其他语言一样，Python通过了两个循环控制保留字break和continue（几乎所有的语言都是这两个）。break表示结束当前所在循环，continue表示跳过当次循环并不影响循环的继续，它们都可以与for循环和while循环搭配使用。

continue实例：

for i in "PYTHON":
    if i=='T':
        continue
    print(i,end=",")

break实例：

for i in "PYTHON":
    if i=='T':
        break
    print(i,end=",")

使用break时，注意其所在的循环位置，只跳出break所在的循环。

pass实例：

for letter in 'Python':
    if letter == 'y':
        pass
    print('Letter is',letter)

输出：

Letter is P
Letter is y
Letter is t
Letter is h
Letter is o
Letter is n

如果letter=='y'，遇到pass直接通过接着执行，如果if for while下无代码，系统会报错，可以用pass占位

import time
for letter in 'Python':
    if letter == 'y':
        pass
    time.sleep(2)
    print('Letter is',letter)

每次打印的时候休息2秒　　

4）循环的高级用法　

循环可以和else搭配使用，else与循环处于同一级，在循环语句之后，使用方法如下：

for <循环变量> in <遍历结构>:
    <语句块1>
else:
    <语句块2>
  
while <条件>:
    <语句块1>
else:
    <语句块2>

无论是for还是while，当循环没有被break保留字退出时（允许存在break），此时执行else的语句块。简单来讲，else语句块可以作为“正常”完成循环的一种奖励，与异常处理中的else类似。　　

实例1：　　

for c in "PYTHON":
    if c=="T":
        continue
    print(c,end="")
else:
    print("正常退出")

实例2：　　

for c in "PYTHON":
    if c=="T":
        break
    print(c,end="")
else:
    print("正常退出")

for循环打印99乘法表

for count1 in range(1,10):
    for count2 in range(1,count1+1):
        print(f"{count1}*{count2}={count1*count2}",end="\t")
    print()

输出如下：　　

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