2022年 11月 9日

python入门（循环判断）

一、流控制简介

程序一般的执行流程：自上而下，依次执行

  1. print("1")
  2. print("2")
  3. print("3")
  4. print("4")
  5. print("5")

在特定情况下，需要有选择的执行部分的代码

  • 情况1：仅仅执行部分代码、不执行另外一部分代码，例如仅仅执行输出3 和 4，不让输出其他

  • 情况2：需要重复的执行部分的代码，例如将第3、4执行10000次

第一种情况

  • 表示的含义，就是需要设置一个前置条件，当条件满足的时候执行一部分代码，当条件不满足的时候，取执行另外的一部分代码

  • 这种情况就是判断语句

第二种情况

  • 表示的含义，也是有个前置条件，当条件满足的时候，可以重复的执行一部分代码；当条件不满足的时候，才会继续执行后面的代码

  • 这种情况就是循环语句

所谓的流控制：

  • 通过判断和循环，可以控制程序的执行流程，而不是简单的自上而下依次执行

流控制关键点有两个

  • 判断

  • 循环

二、运算符

2.1 简介

  • 在做判断的时候，就一定会涉及到内容或者是数字的比较，这个时候就一定会用到比较运算符

算数运算符

  1. +
  2. -
  3. *
  4. /
  5. %

赋值运算符

  1. +=
  2. -=
  3. *=
  4. /=
  5. %=

2.2 比较运算符

  1. >      大于
  2. <      小于
  3. >=     大于等于
  4. <=     小于等于
  5. !=     不等于
  6. <>     不等于
  7. ==     等于</span></span>

2.3 逻辑运算符

条件有两种

  • 条件成立，可以说这个条件为真

  • 条件不成立，可以说这个条件为假

举例：说明条件成立与否

条件：num1 > num2

  • 当 num1 = 7 num2 = 5 的时候，这个条件是成立的

  • 当 num1 = 3 num2 = 5 的时候，这个条件是不成立的

组合多个条件的组合方法

  1. and【且】  例子： 条件1  and   条件2  
  2. or【或】   例子： 条件1  or   条件2  
  3. not【非】  例子： not  条件1</span></span>

and：多个条件必须都成立，多个条件的组合结果才是成立

or：多个条件只要有一个成立，那么就是多个条件的组合结果才是成立

   not：对条件进行取反

举例：判断条件的时候，可能会同时判断多个条件

条件：num1 > num2 and num3 <= num4

解释：判断条件有多个的是时候，就需要分别判断三种情况

  • 情况1：多个条件都不成立

  • 情况2：多个条件都成立

  • 情况3：多个条件中部分条件成立

当 num1 = 7 num2 = 5 num3 = 4 num4= 6 最终条件是 条件为真

当 num1 = 3 num2 = 5 num3 = 4 num4= 6 最终条件是 条件为假

当 num1 = 7 num2 = 5 num3 = 8 num4= 6 最终条件是 条件为假

当 num1 = 3 num2 = 5 num3 = 8 num4= 6 最终条件是 条件为假

条件：num1 > num2 or num3 <= num4

当 num1 = 7 num2 = 5 num3 = 4 num4= 6 最终条件是 条件成立

当 num1 = 3 num2 = 5 num3 = 4 num4= 6 最终条件是 条件成立

当 num1 = 7 num2 = 5 num3 = 8 num4= 6 最终条件是 条件成立

当 num1 = 3 num2 = 5 num3 = 8 num4= 6 最终条件是 条件不成立

条件：not num1 > num2

当 num1 = 7 num2 = 5 最终条件是 条件不成立

当 num1 = 3 num2 = 5 最终条件是 条件成立

2.4 bool类型

复习

数据类型

  • 字符串

  • 整数

  • 浮点数

  • 布尔类型

  • 列表

  • 字典

  • 元组

类型转换

  • int() 将数据类型转换为整型

  • str() 将数据类型转换为字符串

  • float() 将数据类型转换为浮点数

检查数据类型的方法

  • type()

input方法

  • 这个方法可以实现用户交换

  • 将用户输入的内容保存到一个变量中，而且默认接收进来的数据类型都是字符串类型

布尔类型

  • 这种类型的值只有两种可能，也就是他的值只有真和假两种【真和假就是条件成立/不成立】

  • 所有的判断，都是得依靠布尔类型才能实现

python中的真有几种表示方式【条件成立】

  • True：表示判断结果为真，也就是条件成立

  • 1：表示判断结果为真，也就是条件成立

python中的假有几种表示方式

  • False：表示判断结果为假，也就是条件不成立

  • 0：表示判断结果为假，也就是条件不成立

  • ”“：这是空字符串，这也表示判断结果为假，也就是条件不成立

  • ()：空元组

  • []：空列表

  • {}：空字典

三、if条件判断

3.1 if语法格式

  • python中进行判断的关键字是if

判断的语法格式有三种：

  • 单分支格式：

    • 仅仅判断一个条件，条件条件成立的时候，执行部分代码

    • 例如：当num1 的值大于 num2 的值，输出一个ok

  • 双分支格式：

    • 仅仅判断一个条件，条件条件成立的时候，执行一部分代码；当条件不成立的时候，执行另一部分代码

    • 例如：当num1 的值大于 num2 的值，输出一个ok；当num1不大于num2的时候，输出error

  • 多分支格式：

    • 用于判断多个条件，当某个条件满足的时候，执行特定的代码

    • 例如：学生的成绩大于90，输出A；当学生的成绩80-90的时候，输出B，当学生的成绩再70-80，输出C

3.2 单分支结构

  1. # ==============================格式1：单分===========================
  2. # 仅仅判断一个条件，而且仅仅指定了当条件成立的时候要执行的代码
  3. if 判断条件:     
  4.     代码           # 这里的代码，只有当判断条件成立的时候，才会执行
  5.     代码           # 这里的代码，只有当判断条件成立的时候，才会执行
  6.     代码           # 这里的代码，只有当判断条件成立的时候，才会执行  

案例1：判断num1中的值是否大于num2，如果num1的值大的话，就输出ok

 思考：over什么时候会执行

  • 不管条件是否成立，over都是被执行

分析程序的执行流程【重要】

正常情况下，没有循环和判断的时候，程序就是从上向下依次执行

  • 有判断的时候，需要根据判断条件的结果，来判断是否应该执行

  • 有循环的时候，需要根据叛徒条件的结果，来判断是否应该循环

分析这个程序的执行流程

  1. 首先执行第一行，# coding=utf-8

  2. 然后执行第三行，定义一个变量num1

  3. 然后执行第四行，定义变量num2

  4. 然后执行第六行，判断num1是否大于num2，判断结果是条件成立，，因为条件成立，所有要执行判断中的语句，也就是会去执行第七行

  5. 然后执行第七行，输出ok；此时判断中的语句只有一个，将这个语句执行完成以后，会退出if，然后继续执行后面的代码

  6. 然后执行第九行，输出over

案例2：让用户输入一个数字，判断这个数字是否大于10，如果用户输入的数字大于10的话，就输出ok

3.3 双分支结构

  1. # ==============================格式1：双分支：===========================   
  2. # 仅仅判断一个条件，但不仅指定了当条件成立的时候要执行的代码，也指定了条件不成立执行的代码
  3. if 判断条件:
  4.     代码1 
  5.     代码1
  6. else:
  7.     代码2
  8.     代码2
  9. ​
  10. # 解释：当条件成立，执行代码1；当条件不成立，执行代码2

案例：判断num1中的值是否大于num2，如果num1的值大的话，就输出ok，如果num2大的数，输入error

  1. #coding=utf-8</span>
  2. ​
  3. num1 = 2
  4. num2 = 3
  5. ​
  6. if num1 > num2:
  7.     print("ok")
  8. else:
  9.     print("error")
  10. ​
  11. print("over")

案例：让用户输入两个数字，然后打印输出大的数字

  1. #coding=utf-8
  2. ​
  3. # 案例：让用户输入两个数字，然后打印输出大的数字
  4. num1 = int(input("please enter a number: "))
  5. num2< = int(input("please enter a number: "))
  6. ​
  7. if num1 > num2:
  8.     print(num1)
  9. else:
  10.     print(num2)  

3.4 多分支结构

  1. # 格式3：多分支：可以判断多个条件，满足不同的条件，执行不同的代码
  2. if 判断条件1:
  3.     代码1     # 当条件1 成立，执行这里的代码
  4.     代码1  
  5. elif 判断条件2:
  6.     代码2     # 当条件2 成立，执行这里的代码
  7.     代码2</span>
  8. elif 判断条件3:
  9.     代码3     # 当条件3 成立，执行这里的代码
  10.     代码3
  11. ...
  12. else:
  13.     代码n     # 当以上所有的条件都不成立，执行这里的代码
  14.     代码n 
  15.     
  16. # 解释
  17. 1）先判断条件1是否满足，如果满足条件1，则执行代码1，代码1执行完成，直接结束程序
  18. 2）当条件1是不否满足时候，则判断条件2是否成立
  19. 3）如果条件2满足，则执行代码2，代码2执行完成，直接结束程序
  20. 4）如果条件2不满足，则判断条件3
  21. ...
  22. 如果所有的条件都不满足，则执行代码n

案例：让用户输入一个100以内的数字，判断这个数字再那个范围

  • 1-30 范围 输出结果是 范围1到30

  • 31-60 范围 输出结果是 范围31到60

  • 61-90 范围 输出结果是 范围61到90

  • 91-100 范围 输出结果是 范围91到100

第一种写法

  1. #coding=utf-8
  2.  
  3. num = int(input("请输入一个数字："))
  4. if num>100:
  5.     print("你输入的数字超出了范围")
  6. elif num>=91:
  7.     print("范围91到100")
  8. elif num>=61:
  9.     print("范围61到90")
  10. elif num>=31:
  11.     print("范围31到60")
  12. elif num>=1:
  13.     print("范围1到30")
  14. else:
  15.     print("你输入的数字超出了范围")

第二种写法

  1. #coding=utf-8
  2.  
  3. num = int(input("请输入一个数字："))
  4. if num<=0:
  5.     print("你输入的数字超出了范围")
  6. elif num<=30:
  7.     print("范围1到30")
  8. elif num<=60:
  9.     print("范围31到60")
  10. elif num<=90:
  11.     print("范围61到90")
  12. elif num<=100:
  13.     print("范围91到100")
  14. else:
  15.     print("你输入的数字超出了范围")

错误的答案

  1. #coding=utf-8
  2.  
  3. num = int(input("请输入一个数字："))
  4. if num<=0:
  5.     print("你输入的数字超出了范围")
  6. elif num<=100:
  7.     print("范围91到100")
  8. elif num<=30:
  9.     print("范围1到30")
  10. elif num<=60:
  11.     print("范围31到60")
  12. elif num<=90:
  13.     print("范围61到90")
  14. else:
  15.     print("你输入的数字超出了范围")

第三种写法

  1. #coding=utf-8
  2.  
  3. num = int(input("请输入一个数字："))
  4. if num>=61 and num<=90:
  5.     print("范围61到90")
  6. elif num>=1 and num<=30:
  7.     print("范围1到30")
  8. elif num>=91 and num<=100:
  9.     print("范围91到100")
  10. elif num>=31 and num<=60:
  11.     print("范围31到60")
  12. else:
  13.     print("超出范围")

练习题：

案例1. 让用户输入一个数字，判断数字是否大于10，如果大于10，输出ok，在输出over
案例2. 让用户输入一个数字，判断数字是否大于10，而且小于20，输出ok，在输出over
案例3. 让用户输入一个数字num = input(“请输入一个数字：”)# 将用户的数字转换为数字类型num = int(num)if num > 10 or num < 5:    print(“ok”)    print(“over”)
案例4. 让用户输入一个数字，判断数字是否为3，如果是3，就是输出ok，否则输出error
案例5. 让用户输入一个成绩，判断成绩是否大于60，如果大于等于60，就显示及格【单分支】
案例6. 让用户输入一个成绩，判断成绩是否大于60
– 如果大于等于60，就显示及格
– 如果小于60，就显示不及格
案例7. 让用户输入一个成绩
– 如果成绩小于60，输出：等级E
– 如果成绩60~70，输出：等级D
– 如果成绩70~80，输出：等级C
– 如果成绩80~90，输出：等级B
– 如果成绩90~100，输出：等级A

案例1：让用户输入一个数字，判断数字是否大于10，如果大于10，输出ok，在输出over

  1. num = int(input("请输入一个数字："))
  2. if num > 10:
  3.     print("ok")
  4. print("error")

案例2：让用户输入一个数字，判断数字是否大于10，而且小于20，输出ok，在输出over

  1. # 让用户输入一个数字
  2. num = input("请输入一个数字：")
  3. # 将用户的数字转换为数字类型
  4. num = int(num)
  5.  
  6. if num > 10 and num < 20:
  7.     print("ok")
  8.     print("over")

案例3：让用户输入一个数字num = input(“请输入一个数字：”)# 将用户的数字转换为数字类型num = int(num)if num > 10 or num < 5: print(“ok”) print(“over”)

  1. # 让用户输入一个数字
  2. num = input("请输入一个数字：")
  3. # 将用户的数字转换为数字类型
  4. num = int(num)
  5.  
  6. if num > 10 or num < 5:
  7.     print("ok")
  8.     print("over")

案例4：让用户输入一个数字，判断数字是否为3，如果是3，就是输出ok，否则输出error

  1. # 让用户输入一个数字
  2. num = input("请输入一个数字：")
  3. # 将用户的数字转换为数字类型
  4. num = int(num)
  5.  
  6. if num == 3:
  7.     print("ok")
  8. else:
  9.     print("over")

案例5：让用户输入一个成绩，判断成绩是否大于60，如果大于等于60，就显示及格【单分支】

  1. #让用户输入一个成绩
  2. score = input("请输入成绩：")
  3. score = int(score)
  4.  
  5. #判断成绩是否大于60
  6. if score >= 60:
  7.     #如果大于等于60，就显示及格
  8.     print("及格")

案例6：让用户输入一个成绩，判断成绩是否大于60

  • 如果大于等于60，就显示及格

  • 如果小于60，就显示不及格

  1. #让用户输入一个成绩
  2. score = int(input("请输入一个成绩： "))
  3. #判断成绩是否大于等于60
  4. if score >= 60:
  5.     #如果大于等于60，就显示及格
  6.     print("及格")
  7. else:
  8.     #如果小于60，就显示不及格
  9.     print("不及格")

案例7：让用户输入一个成绩

  • 如果成绩小于60，输出：等级E

  • 如果成绩60~70，输出：等级D

  • 如果成绩70~80，输出：等级C

  • 如果成绩80~90，输出：等级B

  • 如果成绩90~100，输出：等级A

答案1：

  1. #让用户输入一个成绩
  2. score = int(input("请输入成绩："))
  3.  
  4. #判断成绩是否小于60
  5. if score < 60:
  6.     print("等级E")
  7. #判断是否大于等于60，小于70
  8. elif score >= 60 and score < 70:
  9.     print("等级D")
  10. elif score >= 70 and score < 80:
  11.     print("等级C")
  12. elif score >= 80 and score < 90:
  13.     print("等级B")
  14. elif score >= 90 and score < 100:
  15.     print("等级A")
  16. else:
  17.     print("输入错误")

答案2：

  1. #让用户输入一个成绩
  2. score = int(input("请输入成绩："))
  3.  
  4. if score >= 90:
  5.     print("等级A")
  6. elif score >= 80:
  7.     print("等级B")
  8. elif score >= 70:
  9.     print("等级C")
  10. elif score >= 60:
  11.     print("等级D")
  12. else:
  13.     print("等级E")

错误答案

  1. #让用户输入一个成绩
  2. score = int(input("请输入成绩："))
  3.  
  4. if score < 60:
  5.     print("等级E")
  6. elif score >=60:
  7.     print("等级D")
  8. elif score >=70:
  9.     print("等级C")
  10. elif score >=80:
  11.     print("等级B")
  12. elif score >=90:
  13.     print("等级A")
  14. else:
  15.     print("error")

3.5 判断进阶

判断对象

  • 数字：可以用 > >= < <= == !=

  • 字符：可以用== !=

案例：询问用户，是否继续执行

  • 如果用户选择继续执行，就提示继续

  • 如果用户选择退出，就提示退出

  • 如果用户选择错误，就报错

  1. userInput = input("是否继续执行[Y|N]：")
  2.  
  3. if userInput == 'Y' or userInput == 'y':
  4.     print("好的，我们继续...")
  5. elif userInput == 'N' or userInput == 'n':
  6.     print("好的，我们退出...")
  7. else:
  8.     print("抱歉，你输入错误了")

3.6 三元表达式

  • 对于一些简单的判断，往往不需要写完整的if，就可以达到目的

代码1   if   判断条件   else   代码2

  • 如果条件成立，执行代码1

  • 如果条件不成立，执行代码2

案例：让用户输入两个数字，输出大的数

常规格式

  1. num1 = int(input("请输入第一个数字："))
  2. num2 = int(input("请输入第二个数字："))
  3.  
  4. if num1 > num2:
  5.     print(num1)
  6. else:
  7.     print(num2)

三元表达式格式

  1. num1 = int(input("请输入第一个数字："))
  2. num2 = int(input("请输入第二个数字："))
  3. print(num1) if num1 > num2 else print(num2)

3.7 random模块

  • 通过random模块可以生成随机数

案例：生成一个1-100的随机数

  1. #coding=utf-8
  2.  
  3. # 导入模块
  4. import random
  5.  
  6. # 生成一个0-100的随机数
  7. num = random.randint(0,100)
  8.  
  9. # 显示所生成的随机数【每次执行程序，都会随机生成同一个数字】
  10. print(num)

案例：猜拳游戏

  1. #coding=utf-8
  2.  
  3. # 提前定义好规则
  4. # 用0 表示 剪刀
  5. # 用1 表示 石头
  6. # 用2 表示 布
  7.  
  8. # 导入模块
  9. import random
  10.  
  11. # 生成一个0-2的随机数
  12. # 一共有3个数字：0  1   2
  13. num = random.randint(0,2)
  14.  
  15. # 让用户选择一个
  16. userInput = int(input("请选择：0：剪刀  1：石头  2：布 :  "))
  17.  
  18. # 判断用户选择的是那个
  19. if userInput == 0:
  20.     print("用户出的是 剪刀")
  21. elif userInput == 1:
  22.     print("用户出的是 石头")
  23. else:
  24.     print("用户出的是 布")
  25.  
  26. # 判断系统生成的是哪个
  27. if num == 0:
  28.     print("系统出的是 剪刀")
  29. elif num == 1:
  30.     print("系统出的是 石头")
  31. else:
  32.     print("系统出的是 布")
  33.  
  34. # 判断谁输谁赢
  35. if userInput == num:
  36.     print("平手")
  37. elif (userInput == 0 and num == 2) or (userInput == 1 and num == 0) or (userInput == 2 and num == 1):
  38.     print("你赢了")
  39. else:
  40.     print("你输了")

三、while循环

  • 通过使用while语句，可以实现重复的执行一段python程序

  • 这个重复执行的过程，就叫做循环

while循环的语法格式有两种

  • 格式1：while后面跟上一个条件，当条件满足的时候，执行循环；当条件不满足的时候，跳出循环

  • 格式2：while后面跟上一个条件，还要跟上一个else语句，当条件满足的时候，执行循环；当条件不满足的时候，取执行else中的python语句，在else中的语句执行完成以后，跳出循环

格式1

  1. while 判断条件:
  2. 	代码1
  3. 	代码1
  4. 	代码1
  5. 	代码1
  6. 代码2
  7. 代码2
  8. 代码2

执行流程

  1. 当程序执行到while这行的时候，会取检查这个条件是否成立

  2. 如果条件是成立的时，会取执行while中的语句，也就是会取执行所有的代码1

  3. 当代码1执行完成以后，会回去再次判断while后面的条件是否成立，如果成立，再次执行代码1，代码1执行以后，会再次判断条件是否成立，成立以后，会再次执行代码1….

  4. 当判断条件不成立的时候，就会跳出循环，跳出循环以后，就会去执行while后面的语句，也就是会去执行代码2

格式2：

  1. while 判断条件:
  2. 	代码1
  3. 	代码1
  4. 	代码1 
  5. else:            # else中的代码当while循环中的代码执行完成以后，才会执行
  6. 	代码2
  7. 	代码2
  8. 	代码2
  9. 代码3
  10. 代码3
  11. 代码3

执行流程

  • 首先会判断while中的条件是否成立，如果成立，会执行代码1，代码1执行完成以后，会再回去判断条件是否成立，如果成立，就再次执行代码1，然后再次判断条件………

  • 当判断条件不成立的时候，就会去执行代码2，当代码2执行完成以后，会跳出循环，也就是会去执行代码3

案例1：让用户输入一个数字，判断数字是否大于5

  • 如果大于5，则输出这个数字，并让数字减去1，然后重复进行判断，并进行减法操作，直至数字小于等于5

  1. # coding=utf-8
  2.  
  3. # 让用户输入一个数字
  4. num = int(input("please enter a number: "))
  5.  
  6. # 判断num中的数字是否大于5
  7. while num>5:
  8.     # 输入num中的数字
  9.     print(num)
  10.     # 让num中的数字减1
  11.     num = num - 1
  12.  
  13. print("程序执行结束")

  • 思考：”程序执行结束” 会输出几次？

案例2：计算1+2+3…100

典型问题，可以将处理这一类的问题都按照这种方法做

梳理执行流程 

  • 首先执行第1行，设置字符集，防止出现中文乱码

  • 然后执行第7行和第10行，定义两个变量

  • 然后执行第13行，判断是否满足条件进行循环

    • 此时 num是1，因此满足条件，所以会去执行 while的两个语句

  • 然后执行第15行，也就是执行 sum = sum + num，此时sum是0，num是1，因此结果是sum = 0 + 1

  • 然后执行第17行，也就是让num = num + 1，此时num 是1，因此计算结果是num = 2，到这里，循环代码执行完成，接下来，需要回去再次判断是否满足条件

  • 然后执行第13行，判断是否满足条件进行循环

    • 此时 num是2，因此满足条件，所以会去执行 while的两个语句

  • 然后执行第15行，也就是执行 sum = sum + num，此时sum是0+1，num是2，因此结果是sum = 0 + 1 +2

  • 然后执行第17行，也就是让num = num + 1，此时num 是2，因此计算结果是num = 3，到这里，循环代码执行完成，接下来，需要回去再次判断是否满足条件

通过这种周而复始的过程，就可以最终得到sum = 0 + 1 + 2 +3….100

案例3：让用户输入一个数字，判断这个数字是奇数还是偶数

  1. # coding=utf-8
  2. num = int(input("请输入数字："))
  3.  
  4. if num%2 == 0:
  5.     print("%d 是偶数" %(num))
  6. else:
  7.     print("%d 是奇数" %(num))

补充，分析下面的程序的执行结果和执行流程

# 执行第1行，设置字符集
# 执行第4行，定义变量
# 执行第7行，判断条件，现在条件成立
# 执行第8行，判断是否对2取余是0。现在n是1，1对2取余是1，那么条件成立，因此第9 和第10行不执行
# 执行第7行，判断条件，现在条件成立
# 执行第8行，判断是否对2取余是0。现在n是1，1对2取余是1，那么条件成立，因此第9 和第10行不执行
# 执行第7行，判断条件，现在条件成立
# 执行第8行，判断是否对2取余是0。现在n是1，1对2取余是1，那么条件成立，因此第9 和第10行不执行
…

补充：分析这个程序的执行结果

分析执行流程

执行第1行，定义字符集

执行第4行，定义变量，初始值是1

执行第7行，判断n的值是否小于等于100，此时n的值是1，因此条件成立

执行第8行，n的值自加1，结果是n的值变为2

执行第9行，判断n对2取余是否为0，此时n是2，取余结果是0，因此条件成立

执行第10行，输出n的值，n是2，所以输出2

执行第7行，判断n的值是否小于等于100，此时n的值是2，因此条件成立

执行第8行，n的值自加1，结果是n的值变为3

执行第9行，判断n对2取余是否为0，此时n是3，取余结果是1，因此条件不成立

执行第7行，判断n的值是否小于等于100，此时n的值是3，因此条件成立

执行第8行，n的值自加1，结果是n的值变为4

执行第9行，判断n对2取余是否为0，此时n是4，取余结果是0，因此条件成立

执行第10行，输出4

……….

案例4：输出1-100的所有的偶数

  1. # coding=utf-8
  2.  
  3. # 定义变量，保存起始值
  4. n = 1
  5.  
  6. # 循环判断
  7. while n<=100:
  8.     if n%2 ==0:
  9.         print(n)
  10.     n += 1

案例5：计算1-100的偶数和

  1. # coding=utf-8
  2.  
  3. # 定义变量，保存起始值
  4. n = 1
  5.  
  6. # 定义变量保存最终的求和的值
  7. sum = 0
  8.  
  9. # 循环判断
  10. while n<=100:
  11.     # 判断数字是否为偶数
  12.     if n%2 == 0:
  13.         # 求偶数和
  14.         sum += n
  15.     # 让n的值自加1
  16.     n += 1
  17.     
  18. # 输出最终结果
  19. print(sum)

案例6：输出100-1之间的数字

  1. # coding=utf-8
  2. n = 100
  3. while n>0:
  4.     print(n)
  5.     n -= 1

案例7：输出1-100的数字，要求输出结果是 1 2 3 4 5 .. 100【结果在一行】

本质：输出一个结果后，不换行

实现不换行的原理：

  • 每次输出的时候，系统会自动在输出的结尾添加换行符，换行符是 \n

  • 如果将系统添加的换行符替换成其他的字符，那么就可以实现输出时候不换行

通过end关键字可以修改输出结果中的换行符

  • 格式：end = “符号”

  • 含义：在输出的结果后面，用这个符号替换掉 \n，也就实现了不换行

  1. # coding=utf-8
  2.  
  3. # 定义变量，起始值是1
  4. n = 1
  5.  
  6. # 判断是否满足循环条件
  7. while n<=100:
  8.     # 输出n的值
  9.     # 将换行符替换成空格
  10.     print(n,end=" ")
  11.     # 让n的值自加1
  12.     n += 1

案例8：在案例7的基础上，实现当输出了28以后，换一次行

第一种写法

  1. # coding=utf-8
  2.  
  3. # 定义变量，定义初始值是1
  4. n = 1
  5.  
  6. # 判断是否满足循环条件
  7. while n<=100:
  8.     # 小于28的时候
  9.     if n<28:
  10.         # 输出不换行
  11.         print(n,end=" ")
  12.     # 当n的值是28的
  13.     elif n == 28:
  14.         # 输出28
  15.         # 这个28是和1-27是在同一行的，但是输出了28以后，自动添加了换行符
  16.         print(n)
  17.     # else中的数字就是剩余的数字，也就是大于28的数字
  18.     else:
  19.         # 输出数字，并不换行
  20.         print(n,end=" ")
  21.     n += 1

第二种写法

  1. # coding=utf-8
  2.  
  3. # 定义起始值
  4. n = 1
  5.  
  6. # 判断是否满足循环条件
  7. while n<=100:
  8.     # 输出n的值，不换行
  9.     print(n, end=" ")
  10.     
  11.     # 当n的值是28的时候，单独输出一个空内容，目的是自动让系统添加一个换行符
  12.     if n == 28:
  13.         print()
  14.     
  15.     # n的值自加1
  16.     n += 1

补充：pyhton终止程序的方法 sys.exit ()

第一步：导入sys模块

import sys

第二步：用sys模块的中的exit方法

sys.exit()

案例9：让用户输入一个姓名，判断这个姓名是否为tom

  • 如果用户输入的是tom，直接显示欢迎tom，并终止程序

  • 如果用户输入的不是tom，则要求用户重复输入

  • 如果用户连续输入错误3次，就提示输出错误次数过多

  1. # coding=utf-8
  2.  
  3. # 导入sys模块
  4. import sys
  5.  
  6. # 定义变量，这个变量表示输入的次数
  7. num = 1
  8.  
  9. # 判断是否满足循环条件
  10. while num<=3:
  11.     # 让用户输入姓名
  12.     name = input("请输入姓名: ")
  13.     # 判断输入的是否为tom
  14.     if name == "tom":
  15.         # 如果是tom，就输出
  16.         print("欢迎tom")
  17.         # 终止程序
  18.         sys.exit()
  19.     else:
  20.         print("输入错误")
  21.         
  22.     # 让num的值自加1
  23.     num += 1
  24. # 当while的条件不满足的时候，执行else中的内容
  25. else:
  26.     print("你输入的错误次数太多了")

四、 for循环

for也是有两种格式

  • 格式1：for后面跟上一个条件，当条件满足的时候，执行循环；当条件不满足的时候，跳出循环

  • 格式2：for后面跟上一个条件，还要跟上一个else语句，当条件满足的时候，执行循环；当条件不满足的时候，取执行else中的python语句，在else中的语句执行完成以后，跳出循环

格式1：

  1. for  变量  in  列表:
  2. 	代码1
  3. 	代码1

分析执行流程

第一次循环，会从列表中，取一个值，赋值给变量，然后执行for中的语句

第二次循环，再次从列表中，去一个值，赋值给变量，然后再次执行for中的语句

……

当列表中的元素被用完了，就就结束循环

格式2：

  1. for  变量  in  列表:
  2.     代码1
  3.     代码1
  4. else:          # 当for循环结束的时候，才会去执行else中的代码2
  5.     代码2
  6.     代码2

分析执行流程

第一次循环，会从列表中，取一个值，赋值给变量，然后执行for中的代码1

第二次循环，再次从列表中，去一个值，赋值给变量，然后再次执行for中的代码1

……

当列表中的元素被用完了，就会取执行else中的语句 代码2

当代码2执行完成以后，就跳出循环

for循环的中的列表，多种类型

  • 数字列表

  • 字符串列表

  • 字典

  • 元组

  • …

range方法：

  • 这种方法可以快速的生成一个数字列表

  • range方法的返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表

  • 格式：

写法1：range(stop)

  • 只写一个数，那么这个数字就是最大值加1

写法2：range(start, stop)

  • 写两个数，那么前面的是数字是起始值，后面的这个数字就是最大值加1

写法3：range(start, stop, step)

  • start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;

  • stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5

  • step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

例子：

  1. # 案例1：得到0-100之间的数字
  2. range(101)         101表示的是能得到的最大值加1，也就是说能得到的最大是100
  3.  
  4. # 案例2：得到5-100之间的数字
  5. range(5, 101)     5表示的是最小值，101表示的是最大值加1
  6.  
  7. # 案例3：得到5  8  11   14  17  20  23  26... 100 的数字
  8. range(5, 101, 3)     5表示的是最小值，101表示的是最大值加1

案例1：输出1-100的数字

  1. #===================方法1：用while实现====================
  2. n=1
  3. while n<=100:
  4.     print(n)
  5.     n+=1
  6.     
  7. #===================方法2：用for实现=======================
  8. # coding=utf-8
  9. for n in range(1,101):
  10.     print(n)

案例2：输出1-100中的3的倍数【用3种方法】

  1. #===============================方法1：while==========================
  2. # coding=utf-8
  3.  
  4. # 定义初始值n=1
  5. n = 1
  6.  
  7. # 判断是否满足循环条件
  8. while n<=100:
  9.     # 判断这个数字是否为3的倍数
  10.     if n%3 == 0:
  11.         print(n)
  12.     # 让n的值自加1
  13.     n += 1
  14.  
  15.  
  16. #==============================方法2：for=============================
  17. # coding=utf-8
  18.  
  19. # 用range生成1-100的数字
  20. for num in range(1,101):
  21.     # 判断数字是否为3的倍数
  22.     if num%3 == 0:
  23.         # 输出结果
  24.         print(num)
  25.   
  26. #===============================方法3：===============================   
  27. # coding=utf-8
  28.  
  29. # 用range生成3的倍数
  30. for num in range(3,101,3):
  31.     print(num)

案例3：计算100以内3的倍数有多少个？【典型问题】

  1. # coding=utf-8
  2.  
  3. # 定义一个变量作为计数器
  4. n = 0
  5.  
  6. # 遍历1-100所有的数字
  7. for num in range(1,101):
  8.     # 判断数字是否为3的倍数
  9.     if num%3 == 0:
  10.         n += 1
  11.         
  12. # 输出n的值，也就是3的整数倍有多少个
  13. print(n)

案例4：让用户随意输入点内容，然后逐个输出每个字符

例如用户输入了 hello ,输出结果是

第1个字符是 h

第2个字符是e

第3个字符是l

第4个字符是l

第5个字符是o

最后要显示以下，一共有几个字符（包括空格）

  1. # coding=utf-8
  2.  
  3. # 定义一个变量作为计数器
  4. n = 0
  5.  
  6. #让用户输入字符
  7. userInput = input("随便输入一点东西: ")
  8.  
  9. # 遍历用户输入的内容
  10. for c in userInput:
  11.     print(c)
  12.     # 让计数器的内容加1
  13.     n += 1
  14. else:
  15.     print("遍历结束了")
  16.  
  17. print(n)

作业5：打印99乘法表

1*1 = 1
1*2 = 2  2*2 =4 
1*3 = 3  2*3 =6  3*3 = 9

                                               9*9 = 81

for循环写法

  1. # coding=utf-8
  2.  
  3. for n in range(1,10):
  4.     for m in range(1,n+1):
  5.         print("%d * %d = %d" %(m,n,m*n) , end=" ")
  6.     print("")

for和while循环的使用区别

  • while循环适合用在死循环或者循环次数不确定的情况

  • for循环适合用在循环次数明确的情况

五、循环控制

  • break：当循环中，执行到break，循环立刻停止

  • continue：当循环中，执行到continue，终止当前这次循环，直接开始下一次循环

注意区分：break 和 sys.exit()

sys.exit() 将整个程序都停止运行

break 仅仅是跳出循环【在循环中不再执行break后面的代码】

案例1：输出20以内，非3的倍数的数字【用两种方法实现】

  1. # 写法1：
  2. for num in range(1,21):
  3.     if num%3 == 0:
  4.         continue
  5.     print(num)
  6.  
  7. # 写法2
  8. for num in range(1,21):
  9.     if num%3 != 0:
  10.         print(num)

案例2：让用户输入数字，当用户输入100的时候，停止输入；如果不是100，就要求重新输入

  1. # coding=utf-8
  2.  
  3. while True:
  4.     num = int(input("请输入："))
  5.     if num == 100:
  6.         break

案例3：让用户判断是否继续执行

  • 如果用户输入y，就提示继续执行

  • 如果用户输入N，就提示停止执行

  • 如果用户输入错误，要求用户重新输入，但是最多重试3次

  1. n = 0
  2. while n<3:
  3.     n += 1
  4.     userInput = input("是否继续输入[Y|N]：")
  5.     if userInput == 'Y' or userInput == 'y':
  6.         print("继续执行")
  7.         break
  8.     elif userInput == 'N' or userInput == 'n':
  9.         print("停止执行")
  10.         break
  11.     else:
  12.         print("输入错误，请重拾")