if 条件判断

情景描述 :

  • 我们在日常生活中，往往需要对某件事情进行情形的判断，并且在符合某种条件的情形下，做出不同的反应；比如，如果身体不舒服，就去医院看病（唯一的一种情形）；
  • 又比如，如果喜欢苹果产品，就买iPhone手机；否则，买Android手机（二选一的情形）；
  • 再比如，如果有面条，就吃面条；否则，如果有馒头，就吃馒头；否则，有什么吃什么（多种选择并具有优先级的情形）；

if…elif…else知识点 :

  • 区间判断： python可以使用连续的区间判断，例如：score >=0 and score < 60；
  • 隐私转换： if后面需要的是一个bool类型的值，如果不是布尔类型，系统会自动转换成为布尔类型；
  • 冒号后缩进；
  • 语句是按顺序执行的；
  • if语句, elif语句, else语句, 这三者无论在什么情况下（包括嵌套），都是平级，互斥的关系；
  • elif和else都必须有个if平级的前提条件，但else的前提条件不一定是条件判断；
  • elif后面可以不用else去判断其他条件；

2，判断与循环（done） - 图1

使用布尔值

知识点：if后面可以单独放一个变量; 如果是空字符串(‘空’, 0, None), 则代表为False

  1. # if与elif是不同的
  2. a = True
  3. b = True
  4. if a:                       
  5.     print('代码块1')
  6. if b:   
  7.     print('代码块2')       # 代码块1和代码块2都会同时被输出
  1. a = True
  2. b = True
  3. if a:   
  4.    print('代码块1')
  5. elif b:                 # 只会输出代码块1，而不会输出代码块2了，elif翻译过来大概是 ”否则的话如果
  6.    print('代码块2')

单向判断【if】

  • (如果)我开门，你(就)打开客厅的灯,这个如果…就…的逻辑, 就是与计算机沟通的逻辑——条件判断, 作用就是明确地让计算机知道：在什么条件下，该去做什么;
  • 知识点：只需要满足条件时，就执行某个过程;

2，判断与循环（done） - 图2 

  1. a = 6
  3. if a >= 6:
  4.     print('如果结果能显示出来，那么a的数字肯定大于6')
  1. # 在一行中使用if语句
  2. var = 100
  4. if ( var  == 100 ) : print ("Value of expression is 100")   
  5. print("Good bye!" )

双向判断【if…else】

  • if…else…属于双向判断语句：如果if条件不满足时，就执行else下的命令;
  • if和else两个条件判断是平级关系;
  • if和else所代表的条件是互斥关系;
  • 想让else正确运行，有两个关键点：
    • 1, 一定有一个和else平级的前提条件，这个前提条件可以是if判断，也可以是其他命令，比如：循环；
    • 2, else平级的前提条件只需要具有“再处理”性质的命令即可，如：if、for等;
  • 知识点： 当满足条件时，执行某个过程，条件不满足时，则执行另一个过程；

三元表达式【if…else的简写】

  1. a = int(input('输入第1个数：'))
  2. b = int(input('输入第2个数：')) 
  3. if a > b:
  4.     x = a
  5. else:
  6.     x = b  
  8. #上面的语句可以简写成：
  9. x = a if a > b else b
  10. print('两个数里的较大数是：',x)

平级与不平级

  1. # if和else平级
  2. baoshi = int(input('请输入宝石的数量：'))
  4. if baoshi >= 6:
  5.     print('你拥有毁灭宇宙的力量')
  6. else:
  7.     print('带着卡魔拉去奥弥尔星去寻找灵魂宝石')
  1. # if和else不平级（Python犯懵：你到底想让我干嘛？算了，就报个错吧……）
  2. baoshi = int(input('请输入宝石的数量：'))
  4. if baoshi >= 6:
  5.     print('你拥有毁灭宇宙的力量')
  6.     else:                                           # 条件：当赋值不满足if条件时，执行else下的命令
  7.         print('带着卡魔拉去奥弥尔星去寻找灵魂宝石')
  1. s = input('是否喜欢苹果公司的产品？请回答：')
  3. if s == '是':                           # 符合条件的情形
  4.     print ('请购买iPhone手机！')
  5. else:                                   # 不符合上述条件的情形
  6.     print ('请购买Android手机！')

break练习

  1. for i in range(10):
  2.     if i == 11:
  3.         print('找到结果')
  4.         break
  5. else:
  6.     print('未找到结果')
  1. for i in range(10):
  2.     if i == 9:
  3.         print('找到结果')
  4.         break
  5. else:
  6.     print('未找到结果')
  7. #  for循环完毕相当于if false的情况；反之相当于if true的情况.

if 条件判断练习

输入一个整数，判断是否是偶数

  1. # if语句参考条件：num01 % 2 == 0 就说明这个数为偶数 
  2. num01 = int(input("请输入一个整数："))
  3. if num01 % 2 == 0 :
  4.     print(num01,"->这个数是偶数")
  5. else :
  6.     print(num01,'->这个数是奇数')

输入两(三)个数，输出较大的值

  1. # 参考条件：如果num01>num02,就输出“最大值为:num01”,否则输出“最大值为:num02”
  3. # 首先：从控制台输入两个数：
  4. num01 = int(input())
  5. num02 = int(input()) 
  7. # 比较三个数参考条件
  8. # 首先，从控制台输入三个数：
  9. num01 = int(input())
  10. num02 = int(input())
  11. num03 = int(input())
  13. max = num01             # 先定义一个最大数等于num01,然后用这个num01分别和其他两数比较
  15. if num02 > max:
  16.     max = num02
  17. if num03 > max:
  18.     max = num03
  19. print('max=',max)

输出水仙花数

输入三位数，如果是水仙花数(153=13+53+3^3)就打印“是水仙花数”，否则打印“不是水仙花数”

  1. # 命令行：
  2. import math
  3. num01 = int(input("请输入一个三位数："))
  4. a = num01 // 100                         # 三位数除以100，取整，得到百位数
  5. b = num01 // 10 % 10                     # 三位数先除以10，取整，再除以10，取余数，得十位数
  6. c = num01 % 10                           # 三位数直接除以10，取余数，得个位数字
  8. if num01 == math.pow(a,3) + b ** 3 + c ** 3:    #if语句条件
  9.     print("这个数是水仙花数：",num01)
  10. else:
  11.     print("这个不是水仙花数：",num01)

输出回文数

输入五位数，如果是回文数(11111 12321 12221)就打印“是回文数”，否则打印“不是回文数”

  1. # 命令行：
  2. num01 = int(input("请输入一个五位数："))
  3. a = num01 // 10000
  4. b = num01 // 1000 % 10
  5. d = num01 // 10 % 10
  6. e = num01 % 10
  8. if a == e and b == d:                # 区间判断
  9.     print('这个数是回文数：',num01)
  10. else:
  11.     print('这个数不是回文数：',num01)

多项判断【if…elif…else】

  • if…elif…else…属于多向判断（3个或3个以上的条件）命令：如果不满足if条件，就判断是否满足elif下的命令，满足执行，不满足就执行else的命令；
  • 判断的条件超过3个时，中间的多个条件都可以使用elif；
  • if, elif, eles三者所代表的条件都是互斥的关系；
  • elif的运行本质上和else一样，都需要一个和elif平级的前提，这个前提条件必须是if；
  • elif已经带有其他条件的意思，所以elif后也可以不接else；
  • 知识点：当满足某个条件时，执行某个过程；否则，当满足另外某个条件时，执行某个过程；最后，当所有条件都不满足时，执行某个过程；image.png ```python baoshi = int(input(‘请输入宝石的数量：’))

if baoshi >= 6: print(‘你拥有毁灭宇宙的力量’) elif 3< baoshi <=5: print(‘红女巫需要亲手毁掉幻视额头上的宝石’) else: # 条件：但赋值不满足if和elif条件时，就执行else下的命令.
print(‘带着卡魔拉去奥弥尔星去寻找灵魂宝石’)

  1. <a name="f0bc8972"></a>
  2. ### 嵌套【if...if...else...if】
  3. elif也是可以放进嵌套里的，就是在上述结构的基础上，多加一个带头大哥elif条件，以及底下跟着的elif条件的小弟就好。  <br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/25763572/1646352835835-ea627a04-c873-4230-9d25-06389765ebc2.png#clientId=uc8067219-bccc-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=1514&id=ud597fa86&margin=%5Bobject%20Object%5D&name=image.png&originHeight=1514&originWidth=1760&originalType=binary&ratio=1&rotation=0&showTitle=false&size=204238&status=done&style=none&taskId=ua39d1e5a-c87f-4ca8-a7e7-db6e1f653f0&title=&width=1760)
  4. ```python
  5. chengji = 85
  7. if chengji >= 60:                    #1, 执行第一个条件判断，满足
  8.     print('及格')
  9.     if chengji >= 80:
  10.         print('你很优秀')
  11.     else:
  12.         print('你只是一般般')
  13. else:                                #2, 跳过if的内部块，执行else条件判断，满足
  14.     print('不及格')                  #3, 满足条件，先打印”不及格”
  15.     if chengji < 30:                #4, 进入到else内部块，再次执行if条件判断，满足
  16.         print('学渣')                   #5, 满足，打印“学渣”
  17.     else:                            #6, 如果上面已经满足条件了，那么就跳过这个else判断
  18.         print('努力一下还有救')               
  19. print('程序结束')                      #7, 最后是固定打印到屏幕的“程序结束”

猜拳游戏

  1. # input是用来接收用户输入的数据
  2. # 电脑应该随机的出一个数字，需要使用一个随机数模块【random】
  3. import random
  4. computer = random.randint(0,2)               # random.randint(a,b)  ==> 能够生成[a,b]的随机数 0~2区间的所以数
  5. print('电脑出的是：',computer)
  7. player = int(input('请输入 （0）剪刀 （1）石头 （2）布:'))
  8. print('用户输入的是：',player)
  10. if (player == 0 and computer == 2) or (player==1 and computer == 0) or (player == 2 and computer == 1):
  11.     print('你赢了!!!')
  12. elif player == computer:
  13.     print('平局')
  14. else:
  15.     print('你输了~~~')

输入姓名判断是否正确

  1. name1 = input("请输入你的第一个名字：")
  2. name2 = input("请输入你的第二个名字：")
  3. if name1 == 'terence':
  4.     if name2 == 'tao':
  5.         print('这是第一个完整的英文名称：',name1.title(),name2.title())
  6.     elif name2 != 'tao' :
  7.         print('对不起，你输入的名称有误!')
  8. elif name1 == 'xellga':
  9.     if name2 == 'tao':
  10.         print('这是第二个完整的英文名称：',name1.title(),name2.title())
  11.     elif name1 != 'xellga' :
  12.         print('对不起，你输入的名称有误!')
  13. else:
  14.     print('输入错误，请确认第一个姓名是否输入正确？')

for…in 循环

  • or循环：in后面必须是一个可迭代对象，可迭代对象的元素数量，决定循环的次数；
  • 可迭代对象有：字符串，列表，元组，字典，集合，range( )；
    • 每一次迭代，都会从可迭代对象中读取元素，然后写入in前方的变量中，但是，这个变量并不一定会被使用；
    • 每一次迭代，都会执行for语句下方向右缩进的语句块；

      使用range( )

      使用print( )依次打印

      1. for s in['小楼','是','一个','帅哥']:
      2. print(s)                                             # 向右缩进的语句
      大家能够看到，列表中每一个元素都被读取出来并显示，不过，我们能不能让显示输出的结果在同一行显示呢？由于print方法中的参数end默认值为换行符，所以上面代码的运行结果会分多行显示，如果需要在同一行显示，我们只需要将参数end设置为空即可：
      1. for s in['小楼','是','一个','帅哥']:
      2. print(s,end='')

      使用range( )重复输出

      ```python range(start,stop,step)函数：它能够获取一个连续增加的不可变的整数序列；

start -> 表示序列的起始数值；
stop -> 表示序列的终止数值； step -> 表示步长，默认值为1；

  1. ```python
  2. for i in range(5):
  3.     print('小楼好帅！')

在上方代码中变量i并没有什么作用，而range(5)才是关键，range(5)能够获取一个0~4的整数序列，该序列包含了5个元素，for循环在进行迭代时，就能够迭代5次，就会将上方缩进的语句块执行5次；

  1. # 示例：取奇数/偶数序列
  2. print(list(range(0,10,2)))        #获取0~9中的偶数，显示输出结果为：[0,2,4,6,8]
  4. print(list(range(1,10,2)))        #获取0~9中的奇数，显示输出结果为：[1,3,5,7,9]
  1. # 打印1~100之和
  2. z = 0
  3. for i in range(1,101):
  4.     z += i
  5. print(z)
  1. # 统计个数: 100以内，个位数是2，并且能够被3整除的个数
  2. count = 0
  3. for i in range(1,101):
  4.     if (i % 10 == 2) and (i % 3 == 0):
  5.         count += 1
  6.         print(i)
  7. print('总共的个数有：',count,'个')
  1. # 打印所有的水仙花数
  2. for i in range(100,1000):
  3.     ge = i % 10
  4.     shi = i // 10 % 10
  5.     bai = i // 100
  6.     if ge ** 3 + shi ** 3 + bai ** 3 == i:
  7.         print(i)

continue 和 break

计算列表中所有奇数和偶数之和

  1. l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
  2. count1 = 0  # 创建变量，用于奇数求和
  3. count2 = 0  # 创建变量，用于偶数求和
  4. for i in l:  # 循环遍历列表中全部元素，也就是说，从1开始往后一个一个的选择，然后去执行下面条件表达式的语句块
  5.     if i % 2 == 0:  # 判断变量i中存储的为偶数
  6.         count2 += i  # 进行偶数求和运算
  7.         continue       #continue的中文含义是“继续”，写在循环的代码中，表示结束当前循环，继续下一次循环
  8.     count1 += i  # 进行奇数求和运算
  9. print (count1)  # 显示输出结果为：25
  10. print (count2)  # 显示输出结果为：20

说明:
在上方代码中，条件表达式为：i % 2 == 0，这里的“%”为取余运算符，即能够获取i除以2时的余数，例如：11除以2商5余1，那么11%2等于1；
在上方代码中，当i为偶数时，会进行偶数求和运算，然后跳过当前的循环，不会进行奇数求和运算，而当为奇数时，才会进行奇数求和运算。

找到小数点出现的位置

  1. f = input('请输入一个小数：')
  2. count = 1  # 创建变量，用于计数
  3. for i in f:  # 循环遍历输入的内容
  4.     if i == '.':       # 判断变量i中存储的字符是否为小数点
  5.         break        # 当发现小数点时，跳出循环，break的中文含义是“突破”，写在循环的代码中，表示跳出并停止循环
  6.     else:  # 不符合上述判断条件时
  7.         count += 1  # 进行计数
  8. print ('小数点出现在第%s位' % count)

说明:
在上方代码中，当i为小数点时，将停止循环，输出结果，而在跳出循环之前，则会进行计数运算。

while 循环

if判断和while判断比较

image.png

while的注意点

image.png
重点:

  • While后面执行的语句必须为布尔条件语句, 其内容可以理解为: 只要满足循环的条件，就能持续循环，否则，退出循环；
  • 死循环的形成:
    • 1, 变量的值固定了, 没有发生改变, 最终死循环;
    • 2, while True:

思路:

  • 程序执行到while语句，首先计算“表达式”的值为真还是为假：
    • 若为真, 则执行循环体中的语句，执行完语句再去计算“表达式”的值：
    • 若还是为真，则继续执行循环体中的语句，执行完“语句”再去计算“表达式”的值：
    • 若为假，那么结束整个while循环；
    • 如此循环，直到表达式的值为假才停止；

循环训练

循环输出内容5次

  1. n=0                                    # 创建变量，用于计数, 通过自增操作,当达到while条件为false是,结束循环,用于避免死循环
  2. while n<5:                             # 当条件为计数数量小于重复次数时,循环输出字符串内容
  3.     print('hello world')             
  4.     n+=1                               # 计数数量自增1, 为了突破while循环一直为True的情况下进入死循环

循环输出列表内容

  1. l=['A','B','C','D']  
  3. n=0                                   # 创建变量，用于计数
  4. while n<len(l):                       # 循环，条件为计数数量小于列表元素数量
  5.     print(l[n],end='')                # 符合条件时，将计数数量作为列表索引，获取元素显示输出
  6.     n+=1                              # 计数数量自增1

获取0~9之间的奇偶数

  1. l=[]                                   # 创建空列表
  3. n=0                                    # 创建变量，用于获取偶数，获取奇数时变量初始值为1
  4. while n<10:                            # 循环，条件为计数数量小于重复次数
  5.     l.append(n)                        # 符合条件时，将偶数添加到列表
  6.     n+=2                               # 计数数量自增2
  7. print(l)

求1~10的所有整数之和

  1. i = 1
  2. sum = 0
  3. while i <= 5:
  4.     sum += i                              # sum += i  => sum = sum + i  => 每次累加的和存在sum中, sum+i中的sum永远是拿上一步的计算结果,参与到本次计算中
  5.     i += 1
  6. print('1~10的整数之和为：',sum_a)
  1. i = 0
  2. x = 0
  3. while i <= 100:
  4.     i += 1
  5.     if i % 2 == 0:
  6.         x += i
  7. print('1~100的偶数之和为：',x)
  1. i = 24
  2. x = 0
  3. while i <= 500:
  4.     i += 1
  5.     x +=i
  6. print('25~500的整数之和为：',x)

求任意一个正整数是几位数

  1. num = int(input('请输入一个正整数：'))
  2. count = 0
  4. while True:
  5.     count += 1
  6.     num //= 10
  7.     if num == 0:
  8.         break
  9. print('您输入的数字为：',count,'位数')

嵌套循环

打印三角形星星（1个循环）

  1. ceng = 0
  2. while ceng < 5:
  3.     ceng += 1  
  4.     print(ceng * '*')

打印5层5列的星星（2个循环）

视频链接

  1. ceng = 0
  2. while ceng < 5:     # 外循环，用来控制输出多少层
  3.     ceng += 1  
  5.     lie = 0                
  6.     while lie < 5:    # 内循环，用来控制输出多少列  
  7.         lie += 1
  8.         print('*',end=' ')     # 打印一个星星，不换行（end='' 表示把默认换行改成空格）
  9.     print()                    # 用于换行

打印三角形的星星 (嵌套循环)

  • 明确需要打印的层数?
  • 明确每层需要的星星个数?

  • 用什么表示层(ceng), 用什么表示星星的个数(lie)? ```python ceng = 0 while ceng < 5:
    ceng += 1 # 此时 ceng = 1

    lie = 0 # 此时 lie = 0，注意：每一次循环，lie都会被重置为0 （这步很重要）
    while lie < ceng: # 注意: 这里的ceng每次循环都是拿当前赋的值, 此时的ceng = 1 

    1.   lie += 1  
    2.   print('*',end=' ')

    print()

分析：

第6行：根据lie < ceng，即0 < 1，条件满足，则执行星星打印，不换行，且该打印在内循环体内，继续执行下一次内循环，此时条件变成1 < 1，条件不满足，于是直接跳到第9行，换行；

继续执行第2行循环，ceng = 1，条件满足，执行第3行，ceng = 2；

到了第5行，lie被重置为0，0<2,条件满足，执行第6行，lie = 1，接着打印一个星星，不换行，然后又跳回第6步，此时，lie = 1，ceng = 2，条件也满足，继续执行一次星星打印，不换行；

以此类推

  1. <a name="8e383165"></a>
  2. #### 打印九九乘法表
  3. ```python
  4. i = 0
  5. while i < 9:   
  6.     i += 1
  8.     j = 0       
  9.     while j < i:  
  10.         j += 1  
  11.         print(j,'*',i,'=',(i*j),sep='',end='\t') # sep用于去掉字符之间的空格
  12.     print()

冒泡排序

  1. # 目标：让一个数字和它相邻的下一个数字比较运算，如果前一个数字大于后一个数字，交换两个数据的位置
  3. nums = [6,5,3,1,8,7,2,4]    # 最终是一个有序的列表
  5. i = 0
  6. while i < len(nums) - 1:       # 这个循环用于确定需要比较多少趟
  7.     i += 1
  8.     n = 0                       # 这里的n用于取元素的值
  9.     while n < len(nums) - 1:             # 这个循环用于在每一趟中，从列表中取一个数字和它相邻的数字进行比较
  10.         if nums[n] > nums[n + 1]:      
  11.             nums[n],nums[n+1] = nums[n+1],nums[n]       # 如果前一个数字大于后一个数字，则交换它们的位置
  12.         n += 1
  14.     print(nums)

关键字

pass

  • 如果定义一个函数为空，或是写好一个判断后，还没想好满足条件的情况下需要执行什么任务时，由于函数或判断里为空，程序运行就会报错，所以就可以使用pass进行填坑；
  • 作用: 空语句, 用于占位, 保证程序正常运行; ```python

    在python中有时候能看到定义一个def函数，函数内容部分填写为pass；

    def demo(name): pass # 这里的pass主要作用就是占据位置，让代码整体完整

a = ‘pythyon’ i = ‘*’ for element in a: if element == ‘y’: pass # 当element == ‘y’时候，pass不做任何操作 i = 5 else: print(element + str(i))

  1. ```python
  2. def func1():
  3.     for i in range(1,5):
  4.         if i % 2 == 0:
  5.             pass      #当没有想好满足if条件要做什么，就先用pass占位，使得if语句不会报错
  6.         print(i)
  7. func1()
  1. def func1():
  2.     for i in range(1,5):
  3.         if i % 2 == 0:
  4.             #pass         # 注释掉, 此时没有pass语句来占位置的话，就会出现下面的情况：程序报错！
  5.         print(i)
  6. func1()

continue

  • continue 跳出当前本次循环，下方代码不会执行, 然后继续执行下一次循环；

  • continue 只能用于for 或 while 循环中；

    1. def func( ):
    2.   for i in range(1,5):
    3.       if i % 2 == 0:
    4.           continue            # 当i=2时，条件满足，往后执行，遇上了continue，则continue后面语句将不再执行，既print(i)不会打印2；
    5.       print(i)
    6. func( )

  • 当i=1时，条件不满足，向下执行，print(i)打印 1；

  • 当i=2时，条件满足，往后执行，遇上了continue，则continue后面语句将就不再执行，既print(i)不会打印2；
  • 以此类推； ```python for j in range(10): if j ==3:
    1.   print('lalalalalalala')
    2.   continue
    print(j)

print(‘end’)

  1. <a name="break"></a>
  2. ### break
  4. - **break：强制结束整个循环, 下方代码不会执行;**
  5. - break 只能用于for 或 while 循环中；
  6. ```python
  7. for i in [1, 2]:
  8.     print(i)
  10.     for j in [4, 5]:
  11.         if j == 5:
  12.              break   #注意：break跳出的是本次for循环，而不是跳出if代码块
  13.         print(j)
  1. # 不断询问用户，“我爱你，你爱我吗？” 只要答案不是“爱”，就一直询问，直到答案是“爱”为止。
  2. while True:
  3.     anser = input('我爱你，你爱我吗？')
  4.     if anser == '爱':
  5.         break
  6. print('程序结束')
  1. # 不断的让用户输入用户名和密码，只要用户名和密码不是“root”，密码不是“123”，则就一直询问下去，直到输入正确为止。
  2. while True:
  3.     username = input('请输入用户名：')
  4.     password = input('请输入密码：')
  5.     if username =='root' and password=='123':
  6.         break
  7. print('程序结束')

pass,break,continue和return

# pass
def func1():
    for i in range(1,10):
        if i % 2 == 0:
            pass            # pass不做任何操作，做一个占位符，所以这里打印的结果就相当于没有if语句的存在.
        print(i)
func1()

# break
def func2():
    for i in range(1,11):
        if i % 2 == 0:
            break        # 当遍历到i = 2 时,条件满足, 结束整个循环，即使后面还在继续遍历,也都不会再打印输出.
        print(i)
func2()

# continue
def func3():
    for i in range(1,10):
        if i % 2 == 0:
            continue      # 当遍历到i = 2,4,6,8时, 条件满足，则会跳过continue后面的语句，继续执行下一次循环, 既最终输出的都是基数.
        print(i)
func3()

# return
def func4():
    for i in range(1,10):
        if i % 2 == 0:
            return i         # 输出满足第一个条件的结果后，终止循环.
func4()