python语言基础（七）条件判断和循环控制

程序的三大流程

顺序 —— 从上向下，顺序执行代码
分支(条件) —— 根据条件判断，决定执行代码的 分支
循环 —— 让 特定代码 重复 执行

顺序执行(了解)

Python代码在执行过程中，从上至下，遵循下面的基本原则：

• 普通语句，直接执行；
• 碰到函数，将函数体载入内存，并不直接执行，只有被调用的时候才执行，调用函数放在函数体下面
• 碰到类，执行类内部的普通语句，但是类的方法只载入，不执行
• 碰到if、for等控制语句，按相应控制流程执行
• 碰到@，break，continue等，按规定语法执行
• 碰到函数、方法调用等，转而执行函数内部代码，执行完毕继续执行原有顺序代码

程序主入口(熟悉)

一个 .py，除了可以被直接运行外，还可以作为模块，被其他 .py文件导入。不管是直接运行还是被导入，.py 文件的最顶层代码都会被运行（Python 用缩进来区分代码层次）。
但是当一个 .py 文件作为模块被导入时，我们可能不希望一部分代码被运行。那么就可以将这部分代码的调用写在主程序中(if name == ‘main’。

def func_one():
    print('func_one')

def func_two():
    print('func_two')

func_one()  
func_two()
# 运行结果为func_one，func_two
print(__name__)  # __main__，而被调用的时候，调用函数输出的是这个文件的名字
# 如果再建立一个py文件，想要调用本文件，调用时不想让func_two被调用，就可以放到主函数中
if __name__ == '__main__':
    func_two()
# func_two()写在这个地方，另外的文件调用时候就调用不到

条件判断(掌握)

如果 条件满足，才能做某件事情；如果 条件不满足，就做另外一件事情，或者什么也不做。
条件判断是通过一条或多条判断语句的执行结果（True 或者 False）来决定执行的代码块。在Python 语法中，使用 if、elif 和 else 三个关键字来进行条件判断。elif 和 else 都必须和 if 联合使用，而不能单独使用；可以将 if、elif 和 else 以及各自缩进的代码，看成一个 完整的代码块。

条件判断使用原则

• 每个条件后面要使用 冒号 作为 判断行的结尾，所有符号都是英文状态下的，表示接下来是 满足条件（结果为True）后要执行的语句块。
• 除了 if 分支 必须有，elif 和 else 分支都可以根据情况 省略。
• 使用 缩进 来 划分语句块，相同缩进数的语句在一起组成一个语句块。
• 顺序判断每一个分支，任何一个分支首先被命中并执行，则其后面的所有分支被忽略，直接跳过！
• 可以有多个 elif ，但只能有一个 else
• 如果用多个if 代替 elif，则每个if都是单独的模块，不管条件成立与否，都会把每一个if都执行一遍，不会在条件成立后跳出循环。
• 在 Python 中 没有 switch – case 语句。

```python
if 条件1:
    条件1满足执行的代码
    ……
elif 条件2:
    条件2满足时，执行的代码
    ……
elif 条件3:
    条件3满足时，执行的代码
    ……
else:
    以上条件都不满足时，执行的代码
    ……

s_ipt = input('今天发工资了吗？y/n:')
if s_ipt.upper() == 'Y':
    print('吃大餐')
elif s_ipt.lower() == 'n':
    print('吃泡面')
else:
    print('输入有误！')

if 语句以及缩进部分是一个 完整的代码块；冒号等一定是英文状态下的；缩进尽量是一个tab键（四个空格）；elif后面跟条件，else后面不要跟条件；elif可以有多个，else只能有一个；顺序执行，执行满足条件的语句后，跳出程序，剩下的语句不再执行。

逻辑运算

在程序开发中，通常 在判断条件时，会需要同时判断多个条件，只有多个条件都满足，才能够执行后续代码，这个时候需要使用到 逻辑运算符（与 and／或 or／非 not ），逻辑运算符 可以把 多个条件 按照 逻辑 进行 连接，变成 更复杂的条件。

print(1 and 0)  # and只有前后都为真是才为真，1为真，0为假，返回右边的0
print(1 and 2)  # 1为真，2为真，and左边条件成立会向右找，后面也为真，就返回后面的2
print(0 and 2)  # 左边条件不成立，直接返回左边的0
print(1 or 2)   # 左边成立，直接返回左边的1
print(0 or 2)  # 左边不成立，判断右边，右边成立，返回右边的2
print(not 4)  # 返回False
print(not 0)  # 返回True
print(not "")  # 返回True

if 条件1 and 条件2:
    条件1满足 并且 条件2满足 执行的代码
    ……

练习1: 定义一个整数变量 age，编写代码判断年龄是否正确
age = 100

# 要求人的年龄在 0-120 之间
if age >= 0 and age <= 120:
    print("年龄正确")
else:
    print("年龄不正确")

# 练习2: 定义两个整数变量 python_score、c_score，编写代码判断成绩
python_score = 50
c_score = 50

# 要求只要有一门成绩 > 60 分就算合格
if python_score > 60 or c_score > 60:
    print("考试通过")
else:
    print("再接再厉！")

条件判断嵌套

if…elif…else 语句可以嵌套，也就是把 if…elif…else 结构放在另外一个 if…elif…else 结构中。elif 的应用场景是：同时 判断 多个条件，所有的条件是 平级 的。
在开发中，使用 if 进行条件判断，如果希望 在条件成立的执行语句中 再 增加条件判断，就可以使用 if 的嵌套。
if 的嵌套 的应用场景就是：在之前条件满足的前提下，再增加额外的判断。
if 的嵌套 的语法格式，除了缩进之外 和之前的没有区别。

if 条件 1:
    条件 1 满足执行的代码
    ……
    
    if 条件 1 基础上的条件 2:
        条件 2 满足时，执行的代码
        ……    
        
    # 条件 2 不满足的处理
    else:
        条件 2 不满足时，执行的代码
        
# 条件 1 不满足的处理
else:
    条件1 不满足时，执行的代码
    ……

s_ipt = input('今天发工资了吗？y/n:')
if s_ipt.upper() == 'Y':
    salary = float(input('请输入您的工资：'))
    debt = float(input('请输入欠花呗的金额：'))
    remain = salary - debt
    print(f'您还完花呗后剩余{remain}')
    if remain > 1000:
        print('吃大餐')
    else:
        print('吃土')
elif s_ipt.lower() == 'n':
    print('吃泡面')
else:
    print('输入有误！')

例题 掷色子

import random
guess = input("请猜大小：")
ret = random.randint(1, 6)
if ret <= 3 and guess == "小":
    print("你赢了")
elif ret >= 3 and guess == "大":
    print("你赢了")
else:
    print("你输了")

random.randint

import random
导入模块后，可以直接在 模块名称 后面敲一个 . 然后按 Tab 键，会提示该模块中包含的所有函数
random.randint(a, b) ，返回 [a, b] 之间的整数，包含 a 和 b
random.randrange(a,b),返回 [a, b) 之间的整数，包含 a ，但是不包含 b
例如：
random.randint(12, 20) # 生成的随机数n: 12 <= n <= 20
random.randint(20, 20) # 结果永远是 20
random.randint(20, 10) # 该语句是错误的，下限必须小于上限

循环控制

循环控制，就是让 程序循环运行某一段代码 直到 满足退出的条件，才 退出循环。
循环的作用就是让 指定的代码 重复的执行
Python 用关键字 for 和 while 来进行循环控制

while循环

当程序从上至下执行时，遇到 while 循环语句，则会判断表达式 是否成立 ，当 成立时 则会进入 while 循环体内，执行 循环体内部执行的代码块。直到判断表达式 不成立时 ，则 终止循环，执行循环后面的语句。
while 循环最常用的应用场景就是 让执行的代码 按照 指定的次数 重复 执行，切记需要计数器累加，while 语句以及缩进部分是一个 完整的代码块。
如果忘记 在循环内部 修改循环的判断条件(如计数器忘记了累加)，导致循环持续执行，程序无法终止！
常见的计数方法有两种，可以分别称为：
自然计数法（从 1 开始）—— 更符合人类的习惯
程序计数法（从 0 开始）—— 几乎所有的程序语言都选择从 0 开始计数，除非需求的特殊要求，否则 循环 的计数都从 0 开始。

初始条件设置 —— 通常是重复执行的 计数器

while 条件(判断 计数器 是否达到 目标次数):
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
    ...(省略)...
    
    处理条件(计数器 + 1)

练习1.打印 5 次 hello xiaoming

n = 1  # 计数器
while n <= 5:
    print('hello xiaoming')
    n += 1

练习2.求1-100之间的和

n = 1  # 初始化n， 相当于计数器，记录循环的次数
sum = 0
while n <= 100:
    sum += n
    n += 1
print(sum)

第一种：
result = 0
i = 0  # 计数器
while i <= 100:  # 开始循环
    # 判断偶数
    if i % 2 == 0:
        print(i)
        result += i
    # 处理计数器
    i += 1
print("0~100之间偶数求和结果 = %d" % result)

第二种：
result = 0
i = 0  # 计数器
while i <= 100:  # 开始循环    
    result += i
    # 处理计数器
    i += 2
print("0~100之间偶数求和结果 = %d" % result)

在程序开发中，通常会遇到 利用循环 重复计算 的需求，我们可以在 while 上方定义一个变量(sum)，用于 存放最终计算结果，在循环体内部，每次循环都用 最新的计算结果，更新 之前定义的变量(sum)。

break 与 continue 语句

break：
某一条件满足时，退出循环，不再执行后续重复的代码。当 循环体 执行的过程中想要 退出循环体，就可以使用到 break 语句。
continue：
continue 某一条件满足时，不执行后续重复的代码。用于 跳过 当前循环体 剩余部分的代码，直接 开始下一轮循环。它 不会退出和终止循环。
break 和 continue 只针对 当前所在循环 有效

当n=8时，终止循环
n = 1  # 初始化n， 相当于计算器，记录循环的次数
sum = 0
while n <= 100:
    print(n)
    if n == 8:
        break  # 退出整个循环，不是if的语句
    sum += n
    n += 1
print(sum)

当n=8时，退出当前循环，进入下一次循环
n = 1  # 初始化n， 相当于计算器，记录循环的次数
sum = 0
while n <= 100:

    n += 1  # (也可以把此句写道continue上方，在if内执行+1)
    if n == 8:
        continue  # 退出当前循环，进入下一次循环
    # n += 1  # 此时 n一直为8，不会执行+1的操作
    sum += n
    print(n)
print(sum)

while 的 else 从句

while 循环还可以增加一个 else 从句。当 while 循环 正常执行 完毕，会执行 else语句；当while里面有break的时候，不会执行else，break是强制结束循环体，所以不会执行else里的语句。
注意：

• else 与 while 平级的缩进方式，并不是if的从句。
• 如果是被 break 等机制 强制 提前 终止 的循环，不会执行 else 语句。

while循环嵌套使用

if 判断可以嵌套，while 当然也可以嵌套。但是建议大家不要嵌套 3 层以上，那样的效率会很低。

while 嵌套就是：while 里面还有 while
 
while 条件 1:
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
    ...(省略)...
    
    while 条件 2:
        条件满足时，做的事情1
        条件满足时，做的事情2
        条件满足时，做的事情3
        ...(省略)...
    
        处理条件 2
    
    处理条件 1

练习：
打印输出如下

*
**
***
****

第一种方法：
row = 1
while row <= 4:
    print(row * '*')
    row += 1

第二种方法：双while嵌套。每行显示的星星和当前所在的行数是一致的，嵌套一个小的循环，专门处理每一行中 列 的星星显示
row = 1
while row <= 4:
    lor = 1   # 控制列循环
    while lor <= row:
        print('*', end='')
        lor += 1
    print('')
    row += 1

作业1
作业调查，实现学习调研系统，效果如下：当输入为yes时，给出选项1.2.3；当选项为3，则退出系统；当选项不在选择范围内,则提示重新选择；当用户没有学习，则输出提示并退出系统；输入除yes/no其它值时，则提示输入有误。

ipt = input('最近学习了吗？y/n？：')
while True:
    if ipt.lower() == 'yes':
        print('very good!')
        ips = input('1.python\n2.高数\n3.退出\n请输入学习选项：')
        if ips == '1':
            print('python真不错！')
            break
        elif ips == '2':
            print('高数真难')
            break
        elif ips == '3':
            print('已退出')
            break
        else:
            print('选项输入有误，请重新输入：')
    elif ipt.upper() == 'NO':
        print('年轻人，好自为之！')
        break
    else:
        print('输入有误')
        break

作业2
生成了N个1～1000之间的随机整数(N<=1000),N是用户输入的，
对于其中重复的数字，只保留一个，把其余相同的数字去掉，然后再把这些数从小到大排序。

import random
ipt = int(input('请输入生成的个数：'))
s = set()
for i in range(1, ipt+1):
    num = random.randint(1, 1000)
    s.add(num)
print(sorted(s))  #集合没有append，sorted方法

作业3
打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，
其各位数字立方和等于该数本身。
例如：153是一个"水仙花数"，5.1^3 + 5^3+ 3^3 = 153

方法一：
for i in range(100, 1000):
    a = i // 100
    b = i % 100 // 10
    c = i % 10
    if a**3 + b**3 + c**3 == i:
        print(f'水仙花数为：{i}')

方法二：
for i in range(100, 1000):
    s = str(i)
    if int(s[0])**3 + int(s[1])**3 + int(s[2])**3 == i:
        print(f'水仙花数为：{i}')

for循环

range(start,stop,step)，默认步长为1，里面是逗号不是冒号（区别于切片），默认从0开始，返回的是range()对象，左闭右开。

print(type(range))  # <class 'type'> range 是类

print(range(10))  # range(0, 10)，默认从0开始，返回的是range()对象
print(list(range(10)))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]，左闭右开

# range(start, stop, step)
print(list(range(1, 10, 2)))  # [1, 3, 5, 7, 9] 步长默认为1，不是切片的”：“

虽然与 while 一样都是循环的关键字，但 for 循环通常用来遍历 可迭代 的对象。

for i in iterable:
    pass

注意：

• for … in …: 属于固定格式
• iterable 表示 可迭代的对象
• i 是 变量名(可更改)，代表可迭代对象里面的每个元素

for i in '12':
    print(type(i), i)  # <class 'str'> 1 2，字符串1和2
    
for i in 12:  # 整数是不可迭代的对象
    print(i)  # 报错，'int' object is not iterable
    
for i in range(4):  # range(4) --> [0, 1, 2, 3]
    print(type(i), i)  # <class 'int'> 0 1 2 3，整数

练习1：大小写转换

如下列表
ch_num = [‘零’,‘壹’,‘贰’,‘叁’,‘肆’,‘伍’,‘陆’,‘柒’,‘捌’,‘玖’]
ch = [‘圆’,‘拾’,‘佰’,‘仟’,‘萬’]
实现当 for循环嵌套

"""
取大写数字，比如12，1对应'壹'，2对应'贰'，直接循环打印出12，对应ch_num相应的下标 ch_num[int(i)]可以用列表的下标取值
取单位，与字符串的长度有关，2位数对应ch的下标1和0，3位数对应下标2，1和0 
len('12') --> 2-1 --> ch[2-1] 取到'拾'  ch[2-1-1] 取到'圆'
"""

ipt = input('请输入金额：')
len_ipt = len(ipt)
for i in ipt:
    len_ipt -= 1
    # print(i)
    # print(ch_num[int(i)], end="")
    # print(ch[len_ipt], end="")  # 也可以合成一句打印
    print(f'{ch_num[int(i)]}{ch[len_ipt]}', end="")
print('整')

练习2：打印输出九九乘法表

1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
1 * 3 = 3 2 * 3

# 外层循环控制行，控制的是1，2，3的值，
# 内层循环控制列，控制的是 第1行的1，第2行的 1，2 第3行的1，2，3
第一种for循环实现
for i in range(1, 10):
    for j in range(1, i+1):
        print(f'{j}*{i}={i*j}',end="\t")
    print()

第二种while循环实现
i = 1
while i <= 9:
    j = 1
    while j <= i:
        print('{}*{}={}'.format(j, i, i*j), end='\t')
        j += 1
    i += 1
    print()

break 与 continue 语句

在 while 循环中，拥有 break 与 continue 语句，那 for 循环中也有 break 与continue 语句，并且作用一致。

break
for i in range(1, 10):
    # print(i) # 1-9
    if i == 7:  # 当i=7时退出循环
        break
    print(i)  # 1-6
continue
for i in range(1, 10):
    # print(i) # 1-9
    if i == 7:  # 当i=7时跳过当前循环下的代码，执行下次循环
        continue
    print(i)  # 1-6，8，9

问题：

• 怎么跳出双层循环？在内层写break只能退出内层循环，没有退出外层循环，要在外层循环也要break
  实现：
• 第一层循环建立标志 flag=False
• 第二层循环改变标志为True，达到退出循环效

打印三三乘法表

第一种实现
for i in range(1, 10):
    if i ==4:
        break
    for j in range(1, i+1):
        if j ==4:
            break
        print(f'{j}*{i}={i*j}',end="\t")

    print()

建立循环标志
"""定义的循环标志默认是False，在外层循环不会执行，内层循环达到停止条件的时候，
改变flag的值为True，外层循环就会停止执行"""
flag = False
for i in range(1, 10):
    if flag:
        break
    for j in range(1, i+1):
        if j == 3:
            flag = True
        print(f'{j}*{i}={i*j}',end="\t")

    print()