02 条件语句和循环语句

1. 条件语句

条件语句有很多种,需要哪种取决于测试的条件数。分为最简单if语句、if-else语句、if-elif-else语句。

  1. 条件测试(最简单的if语句)

每条if语句的核心都是一个值为True或False的表达式 expression ,根据 expression的值来决定是否执行if语句缩进的代码expr_true_suite
如果为True就执行紧跟在if语句后面的代码expr_true_suite,如果为False,就忽略这些代码expr_true_suite

if expression:
    expr_true_suite

最简单的条件测试是测试变量的值是否与特定值相等?在检查是否相等的时候是考虑大小写的。
这里也回顾下01的内容,关于isis not以及==!=

a11=5
a12=6
a13=5
if a11 == a12:
    print("a11(5) == a12(6)")
if a11 != a12:
    print("a11(5) != a12(6)")
if a11 == a13:
    print("a11(5) == a13(5)")
if a11 is a12:
    print("a11(5) is a12(6)")
if a11 is not a12:
    print("a11(5) is not a12(6)")
if a11 is a13:
    print("a11(5) is a13(5)")
print("a11、a12和a13的type分别是:",type(a11),type(a12),type(a13))
# a11(5) != a12(6)
# a11(5) == a13(5)
# a11(5) is not a12(6)
# a11(5) is a13(5)
# a11、a12和a13的type分别是:   
a21="一号"
a22="二号"
a23="一号"
if a21 == a22:
    print("a21(""一号"") == a22(""二号"")")
if a21 != a22:
    print("a21(""一号"") != a22(""二号"")")
if a21 == a23:
    print("a21(""一号"") == a23(""一号"")")
if a21 is a22:
    print("a21(""一号"") is a22(""二号"")")
if a21 is not a22:
    print("a21(""一号"") is not a22(""二号"")")
if a21 is a23:
    print("a21(""一号"") is a23(""一号"")")
print("a21、a22和a23的type分别是:",type(a21),type(a22),type(a23))
# a21(一号) != a22(二号)
# a21(一号) == a23(一号)
# a21(一号) is not a22(二号)
# a21(一号) is a23(一号)
# a21、a22和a23的type分别是:   
a31=["一号"]
a32=["二号"]
a33=["一号"]
if a31 == a32:
    print("a31([""一号""]) == a32([""二号""])")
if a31 != a32:
    print("a31([""一号""]) != a32([""二号""])")
if a31 == a33:
    print("a31([""一号""]) == a33([""一号""])")
if a31 is a32:
    print("a31([""一号""]) is a32([""二号""])")
if a31 is not a32:
    print("a31([""一号""]) is not a32([""二号""])")
if a31 is a33:
    print("a31([""一号""]) is a33([""一号""])")
print("a31、a32和a33的type分别是:",type(a31),type(a32),type(a33))
# a31([一号]) != a32([二号])
# a31([一号]) == a33([一号])
# a31([一号]) is not a32([二号])
# a31、a32和a33的type分别是:   

is, is not 对比的是两个变量的内存地址
==, != 对比的是两个变量的值
比较的两个变量,如果指向的都是地址不可变的类型(str等),那么isis not==!= 是完全等价的。如果指向的是地址可变的类型(list,dict等),则两者是有区别的。
以上是单纯针对二者。下面是多重条件的判断。
单个 if 语句中的 expression 条件表达式可以通过布尔操作符 andornot 实现多重条件判断。

if 2 > 1 and not 2 > 3:
    print('2 > 1 and not 2 > 3 is True')
# 2 > 1 and not 2 > 3 is True
  1. if-else语句
    条件expression测试通过时执行一个操作expr_true_suite,没有通过的时候执行另一个操作expr_false_suite
    else语句表明条件测试未通过时执行的操作,所以是执行两个操作中的一个。
if expression:
    expr_true_suite
else:
    expr_false_suite
temp = input("猜一猜今年广东高考提前批分数线是多少?")
guess = int(temp) # input 函数将接收的任何数据类型都默认为 str。
if guess == 500:
    print("你可真厉害,可以去补习机构开课了")
else:
    print("猜错了!去谷歌一下吧!")
print("下次见")

这里要注意,input 函数将接收的任何数据类型都默认为 str
并且if语句支持嵌套,即在一个if语句中嵌入另一个if语句,从而构成不同层次的选择结构。

temp = input("我们又见面了,猜一猜今年广东高考提前批分数线是多少?")
guess = int(temp) # input 函数将接收的任何数据类型都默认为 str。
if guess < 400:
    print("比去年还低怎么可能!")
else:
    if guess == 500:
        print("你可真厉害,可以去补习机构开课了")
    else:
        print("猜错了!去谷歌一下吧!")
    print("下次见")

3.if-elif-else语句
应用于需要检查超过两个的情形,依次检查每个条件测试,直到遇到通过了的条件测试,测试通过,执行紧跟着后面的操作,并跳过余下的测试。

if expression1:
    expr1_true_suite
elif expression2:
    expr2_true_suite
    .
    .
elif expressionN:
    exprN_true_suite
else:
    expr_false_suite

以下几点注意下:
(1)使用多个elif:可以使用多个elif,根据需要使用任意数量的elif
(2)省略else:不要求if-elif-else一定要有else,因为else包罗万象,只要不满足任何if或elif中的条件测试,就会执行其中的代码,可能会引入恶意数据。如果知道最终测试条件,使用elif来代替else比较好,所以有时使用一条elif处理特定的情形更清晰。
(3)if-elif-else语句适用于只有一个条件满足的情况:遇到了通过的测试就跳过剩余的测试.如果只想执行一个代码就用if-elif-else结构,如果想要运行多个代码就使用一系列的独立的if语句。

temp = input("我们又又见面了,猜一猜今年广东高考提前批分数线是多少?")
guess = int(temp) # input 函数将接收的任何数据类型都默认为 str。
if guess < 300:
    print("比去年还低两百分怎么可能?")
elif 300 <= guess < 500:
    print("你猜的有点低!")
elif guess == 500:
    print("你可真厉害,可以去补习机构开课了")
elif 650> guess > 500:
    print("猜错了!高了一点")
else:
    print("这也太高了")

2. assert 关键词

assert这个关键词我们称之为“断言”,当这个关键词后边的条件为 False 时,程序自动崩溃并抛出AssertionError的异常。
可以用来在程序中置入检查点,只有条件为 True 才能让程序正常工作。
额外:
关于注释要更新

'关于'
print("""输出什么,三引号吗?""")
print("输出什么,应该都没有")
print('什么呢')
# 输出什么,三引号吗?
# 输出什么,应该都没有
# 什么呢

# 有
''
''''''
""""""
# 

3. 循环语句

  1. while循环
    while语句最基本的形式包括一个位于顶部的布尔表达式,一个或多个属于while代码块的缩进语句。
while 布尔表达式:
    代码块

while循环的代码块会一直循环执行,直到布尔表达式的值为布尔假。
02 条件语句和循环语句_第1张图片

注意:
(1)如果布尔表达式不带有<>==!=innot in等运算符,仅仅给出数值之类的条件,也是可以的。
(2)当while后写入一个非零整数时,视为真值,执行循环体;写入0时,视为假值,不执行循环体。
(3)可以写入strlist或任何序列,长度非零则视为真值,执行循环体;否则视为假值,不执行循环体。

a41 = 1             # 为了后面的条件能满足,先把a设为1
while a41 != 0:     # 如果a不等于0就循环(1不等于0)
    print("please input:",end='')
    a41 = int(input())     # 在循环内部获取输入,改变a的值(想想看不改会怎样?)
print("over")    # 程序执行后,会不断向你询问输入,直到你输入0,条件 a!=0 不满足,循环结束
# please input:3
# please input:4
# please input:5
# please input:0
# over
a43=["panda","cat","rabbit"]
print("type(a43):",type(a43))
print("现在a43中有:",a43)
while a43:
    print(a43[-1])
    print("准备删除:",a43[-1])
    del a43[-1]
    print("现在a43中还剩下:",a43)
# type(a43): 
# 现在a43中有: ['panda', 'cat', 'rabbit']
# rabbit
# 准备删除: rabbit
# 现在a43中还剩下: ['panda', 'cat']
# cat
# 准备删除: cat
# 现在a43中还剩下: ['panda']
# panda
# 准备删除: panda
# 现在a43中还剩下: []
  1. while-else
while 布尔表达式:
    代码块
else:
    代码块

while循环正常执行结束后的情况下,执行else输出。
如果while循环中执行了跳出循环的语句,比如 break,将不执行else代码块的内容。

count = 0
while count < 5:
    print("%d is  less than 5" % count)
    count = count + 1
else:
    print("%d is not less than 5" % count)
    
# 0 is  less than 5
# 1 is  less than 5
# 2 is  less than 5
# 3 is  less than 5
# 4 is  less than 5
# 5 is not less than 5
count = 0
while count < 5:
    print("%d is  less than 5" % count)
    count = 6
    break
else:
    print("%d is not less than 5" % count)

# 0 is  less than 5
  1. for循环
    for循环是迭代循环,在Python中相当于一个通用的序列迭代器,可以遍历任何有序序列,如str、list、tuple等,也可以遍历任何可迭代对象,如dict
for 迭代变量 in 可迭代对象:
    代码块
'字符串'
a51s="zifuchuan"
for a52 in a51s:
    print(a52,end=' ')
print()
# z i f u c h u a n 
'字典'
a53 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
for key,value in a53.items():
    print(key,value,sep=':',end=' ')
print()
# a:1 b:2 c:3 d:4 
'列表'
members = ['一号', '二号', '三号', '四号', '五号']
for each in members:
    print(each)
# 一号
# 二号
# 三号
# 四号
# 五号
  1. for-else循环
    for循环正常执行完的情况下,执行else输出,如果for循环中执行了跳出循环的语句,比如 break,将不执行else代码块的内容,与while - else语句一样。
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 是一个质数
  1. range()函数
range([start,] stop[, step=1])

这个BIF(Built-in functions)有三个参数,其中用中括号括起来的两个表示这两个参数是可选的。
step=1 表示第三个参数的默认值是1。
range 这个BIF的作用是生成一个从start参数的值开始到stop参数的值结束的数字序列,该序列包含start的值但不包含stop的值。

  1. enumerate()函数
enumerate(sequence, [start=0])

sequence – 一个序列、迭代器或其他支持迭代对象。 start – 下标起始位置。 返回 enumerate(枚举) 对象。
enumerate(A) 不仅返回了 A 中的元素,还顺便给该元素一个索引值 (默认从 0 开始)。此外,用 enumerate(A, j) 还可以确定索引起始值为 j

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
lst = list(enumerate(seasons))
print(lst)
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
lst = list(enumerate(seasons, start=1))  # 下标从 1 开始
print(lst)
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
  1. break语句
    break语句可以跳出当前所在层的循环。
    可以参考前面。

  2. continue语句
    continue终止本轮循环并开始下一轮循环。

for i in range(10):
    if i % 2 != 0:
        print(i)
        continue
    i += 2
    print(i)

# 2
# 1
# 4
# 3
# 6
# 5
# 8
# 7
# 10
# 9
  1. pass语句
    pass 语句的意思是“不做任何事”,如果你在需要有语句的地方不写任何语句,那么解释器会提示出错,而 pass 语句就是用来解决这些问题的。
def a_func():
    pass
  1. 推导式
    (1)列表
[ expr for value in collection [if condition] ]
a61= [1, 2, 3, 4, 5]
a63 = [a62 + 2 for a62 in a61]
print(a63)
# [3, 4, 5, 6, 7]

这里的a61也可以替换成range(1, 10)
此外还可以对a62添加限定条件

x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x)

# [3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99]

又或者是两个元素ij

a65= [(i, j) for i in range(0, 3) for j in range(0, 3)]
print("type(a65)",type(a65))
print(a65)
# type(a65) 
# [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
a66 = [[i, j] for i in range(0, 3) for j in range(0, 3)]
print("type(a66)",type(a66))
print(a66)
# type(a66) 
# [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2]]

又或者两个元素以及添加限定条件

a67 = [(i, j) for i in range(0, 3) if i < 1 for j in range(0, 3) if j > 1]
print(a67)
# [(0, 2)]

(2)元组

( expr for value in collection [if condition] )

和列表的推导式类似
(3)字典

{ key_expr: value_expr for value in collection [if condition] }

和列表的推导式类似
(4)集合

{ expr for value in collection [if condition] }
c = {i for i in [1, 2, 3, 4, 5, 5, 6, 4, 3, 2, 1]}
print(c)
# {1, 2, 3, 4, 5, 6}

(5)其他

3. 练习题

  1. 编写一个Python程序来查找那些既可以被7整除又可以被5整除的数字,介于1500和2700之间。
a71 = [a71 for a71 in range(1500,2700) if (a71 % 7) == 0 and (a71 % 5) == 0]
print("介于1500和2700之间,既可以被7整除又可以被5整除的数字有:")
print(a71)
# [1505, 1540, 1575, 1610, 1645, 1680, 1715, 1750, 1785, 1820, 1855, 1890, 1925, 1960, 1995, 2030, 2065, 2100, 2135, 2170, 2205, 2240, 2275, 2310, 2345, 2380, 2415, 2450, 2485, 2520, 2555, 2590, 2625, 2660, 2695]
  1. 话说这个世界上有各种各样的兔子和乌龟,但是研究发现,所有的兔子和乌龟都有一个共同的特点——喜欢赛跑。于是世界上各个角落都不断在发生着乌龟和兔子的比赛,小华对此很感兴趣,于是决定研究不同兔 子和乌龟的赛跑。他发现,兔子虽然跑比乌龟快,但它们有众所周知的毛病——骄傲且懒惰,于是在与乌龟的比赛中,一旦任一秒结束后兔子发现自己领先t米或以 上,它们就会停下来休息s秒。对于不同的兔子,t,s的数值是不同的,但是所有的乌龟却是一致——它们不到终点决不停止。
    然而有些比赛相当漫长,全程观看会耗费大量时间,而小华发现只要在每场比赛开始后记录下兔子和乌龟的数据——兔子的速度v1(表示每秒兔子能跑v1 米),乌龟的速度v2,以及兔子对应的t,s值,以及赛道的长度l——就能预测出比赛的结果。但是小华很懒,不想通过手工计算推测出比赛的结果,于是他找 到了你——清华大学计算机系的高才生——请求帮助,请你写一个程序,对于输入的一场比赛的数据v1,v2,t,s,l,预测该场比赛的结果。
    输入:
    输入只有一行,包含用空格隔开的五个正整数v1,v2,t,s,l,其中(v1,v2< =100;t< =300;s< =10;l< =10000且为v1,v2的公倍数)
    输出:
    输出包含两行,第一行输出比赛结果——一个大写字母“T”或“R”或“D”,分别表示乌龟获胜,兔子获胜,或者两者同时到达终点。
    第二行输出一个正整数,表示获胜者(或者双方同时)到达终点所耗费的时间(秒数)。
    例如:
    样例输入:
    10 5 5 2 20
    样例输出
    D
    4
a86=0
print("注意:v1,v2< =100;t< =300;s< =10;l< =10000且为v1,v2的公倍数")
while a86 == 0:
    v1,v2,l,t,s = map(int,input("请分别输入兔子的速度v1、乌龟的速度v2、请输入跑道的长度l、请输入兔子的t以及请输入兔子的s,用空格分开:").split())
    print("兔子的速度v1:", v1)
    print("乌龟的速度v2:", v2)
    print("跑道的长度l:", l)
    print("兔子的t:", t)
    print("兔子的s:", s)
    if v1 <= 100 and v2 <= 100 and t <= 300 and s <=10 and l <= 10000 and l % v1 == 0 and l % v2 == 0:
        s1, s2, i = 0, 0, 0
        while s1 < l and s2 < l:
            s1, s2, i = v1 + s1, v2 + s2, i + 1
            if s1 == l or s2 == l:
                break
            elif s1 - s2 >= t:
                s2, i = s2 + v2 * s, i + s
        if s1 > s2:
            print("兔子获胜",'R')
            print("所用时间:",i)
            a86=1
        if s1 == s2:
            print("同时胜利",'D')
            print("所用时间:",i)
            a86=1
        if s1 < s2:
            print("乌龟获胜",'T')
            print("所用时间:",int(l / v2))
            a86=1
    else:
        print("输入不合条件,请重新输入")

https://blog.csdn.net/graysu/article/details/90050562

你可能感兴趣的:(Python之禅,python)