02 条件语句和循环语句

最新推荐文章于 2024-08-12 14:30:00 发布

玛卡巴卡的手推车

最新推荐文章于 2024-08-12 14:30:00 发布

阅读量273

点赞数 1

分类专栏： Python之禅文章标签： python

本文链接：https://blog.csdn.net/leileixiang/article/details/107533311

版权

Python之禅专栏收录该内容

15 篇文章 0 订阅

订阅专栏

1. 条件语句

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

条件测试（最简单的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的内容，关于is和is 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分别是: <class 'int'> <class 'int'> <class 'int'>
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分别是: <class 'str'> <class 'str'> <class 'str'>
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分别是: <class 'list'> <class 'list'> <class 'list'>

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

if 2 > 1 and not 2 > 3:
    print('2 > 1 and not 2 > 3 is True')
# 2 > 1 and not 2 > 3 is True

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. 循环语句

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

while 布尔表达式:
    代码块

while循环的代码块会一直循环执行，直到布尔表达式的值为布尔假。
在这里插入图片描述

注意：
（1）如果布尔表达式不带有<、>、==、！=、in、not in等运算符，仅仅给出数值之类的条件，也是可以的。
（2）当while后写入一个非零整数时，视为真值，执行循环体；写入0时，视为假值，不执行循环体。
（3）可以写入str、list或任何序列，长度非零则视为真值，执行循环体；否则视为假值，不执行循环体。

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): <class 'list'>
# 现在a43中有: ['panda', 'cat', 'rabbit']
# rabbit
# 准备删除: rabbit
# 现在a43中还剩下: ['panda', 'cat']
# cat
# 准备删除: cat
# 现在a43中还剩下: ['panda']
# panda
# 准备删除: panda
# 现在a43中还剩下: []

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

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)
# 一号
# 二号
# 三号
# 四号
# 五号

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 是一个质数

range()函数

range([start,] stop[, step=1])

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

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')]

break语句
break语句可以跳出当前所在层的循环。
可以参考前面。
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

pass语句
pass 语句的意思是“不做任何事”，如果你在需要有语句的地方不写任何语句，那么解释器会提示出错，而 pass 语句就是用来解决这些问题的。

def a_func():
    pass

推导式
（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]

又或者是两个元素i和j

a65= [(i, j) for i in range(0, 3) for j in range(0, 3)]
print("type(a65)",type(a65))
print(a65)
# type(a65) <class 'list'>
# [(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) <class 'list'>
# [[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. 练习题

编写一个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]

话说这个世界上有各种各样的兔子和乌龟，但是研究发现，所有的兔子和乌龟都有一个共同的特点——喜欢赛跑。于是世界上各个角落都不断在发生着乌龟和兔子的比赛，小华对此很感兴趣，于是决定研究不同兔子和乌龟的赛跑。他发现，兔子虽然跑比乌龟快，但它们有众所周知的毛病——骄傲且懒惰，于是在与乌龟的比赛中，一旦任一秒结束后兔子发现自己领先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

玛卡巴卡的手推车

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
02 条件语句和循环语句

1. 条件语句条件语句有很多种，需要哪种取决于测试的条件数。分为最简单if语句、if-else语句、if-elif-else语句。条件测试（最简单的if语句）每条if语句的核心都是一个值为True或False的表达式 expression ，根据 expression的值来决定是否执行if语句缩进的代码expr_true_suite。如果为True就执行紧跟在if语句后面的代码expr_true_suite，如果为False，就忽略这些代码expr_true_suite。if expressi
复制链接

扫一扫

专栏目录