Python条件与循环

骑猪看日落 2024-04-19 16:36 208阅读 0赞

博文大纲：

  • 一、Python条件判断
  • 二、Python的循环
  • 三、循环的控制
  • 四、Python的循环综合示例

一、Python条件判断

Python中的条件判断语句有if语句，if双分支、if多分支语句，其执行过程与shell中的if语句完全一样，只是语法有些差异，如下（文中所有的if语句执行流程图都是借鉴与shell中的）：

注意：在Python中，关于代码缩进有严格的要求，Python是采用空格缩进的方式表示一组语句，通常用4个空格表示一组语句（默认会有4个空格缩进），使我们在编写代码时减少代码的工作量。

1、单分支if语句：

执行过程：

Python条件与循环

单分支if语句示例：

  1. money = 1000      #首先定义一个变量
  2. if (money > 500):     #测试条件是：如果money变量大于500，则条件成立，输出下面的内容
  3.     print '吃大餐'      #输出的内容为吃大餐，该print语句就是if中的代码块，默认print前面有4个空格

2、双分支if语句：

执行过程：

Python条件与循环

双分支if语句示例：

  1. money = 1000
  2. if (money < 500):
  3.     print '吃大餐'
  4. else:
  5.     print '吃土'

3、多分支if语句：

执行过程：
Python条件与循环

多分支if语句示例：

  1. print '你还有多少钱？'         #输出提示信息
  2. money = input()     #定义一个变量，变量值是接受键盘输入的值。
  3. if (money > 500):    #如果变量值大于500，则输出“吃大餐”
  4.     print '吃大餐'
  5. elif (money > 100):   #如果变量值大于100，则输出“吃盖饭”
  6.     print '吃盖饭'
  7. else:            #如果前面两个条件都不成立，则输出“吃土”
  8.     print '吃土'

4、使用if语句常见的问题：

问题（1）：使用if-elif-else语句时，容易出现逻辑错误，因为条件是从上往下判断的，如果条件成立，那么下面的条件判断就不执行了，拿刚才的举例来说，若将代码写成下面这个样子：

  1. print '你还有多少钱？'         #输出提示信息
  2. money = input()     #定义一个变量，变量值是接受键盘输入的值。
  3. if (money > 100):    #如果变量值大于500，则输出“吃大餐”
  4.     print '吃大餐'
  5. elif (money > 500):   #如果变量值大于100，则输出“吃盖饭”
  6.     print '吃盖饭'
  7. else:            #如果前面两个条件都不成立，则输出“吃土”
  8.     print '吃土'

可以看出来会发生什么问题么？问题就是只要你输入的值大于100，那么它就将输出“吃盖饭”，哪怕你输入的是800，它也不会输出“吃大餐”，因为第一个条件测试成立了，执行完第一段代码块后，程序就直接跳出了这个if-elif-else语句，后面都不执行了。

问题（2）：if语句中语句块没有缩进也是容易犯的错误，如下代码编译器会直接报错：

  1. money = 1000      #首先定义一个变量
  2. if (money > 500):    
  3.  print '吃大餐'    #这一行语句没有代码块，程序必定会报错，不能正常运行

还要保证同级语句缩进空格的绝对一致，即使只有一个空格的差别，它们已经表示不同的语句块了，错误的示范如下：

  1. money = 1000      #首先定义一个变量
  2. if (money > 500):    
  3.     print '吃大餐' 
  4.          print '吃大餐'     #多了一个空格

问题（3）：对于使用其他语言转Python的朋友，由于习惯会经常忘记条件测试后面的冒号（感觉是在说我自己），需要多多注意。

二、Python的循环

编写程序时经常有代码需要重复运行，Python提供了while和for进行循环。

1、while循环

while循环可以根据条件进行判断，决定是否要循环执行语句块，语法如下：

  1. while 循环语句:
  2.     循环操作语句

while语句的执行流程如下：
循环条件后面也要使用冒号，然后缩进写循环操作语句，先判断条件是否成立，如果为True，则执行循环操作语句，如果为False，则跳出循环

  1. i = 1            #定义一个变量
  2. sum = 0      #定义一个变量
  3. while i <= 3:       #测试条件是变量“i”小于或等于3，则执行下面循环体中的语句
  4.     print ('请输入第%d个月的工资：' %i)            #等待键盘输入工资，并赋值给变量“i”
  5.     sum = sum + int(input())       #将上面键盘输入的工资数和变量sum相加，并在赋值给变量sum
  6.     i = i + 1  #执行一次变量“i”的值就+1。
  7. #执行至此，然后返回去再进行判断，变量“i”是否小于或等于3，如果是，则再执行一遍循环语句；
  8. #如果不是，则跳出循环，执行下面的语句
  9. #注意，以下都没有缩进了，已经不属于while循环了
  10. month = i - 1      #当循环条件不成立时，“i”的值都已经为4了，所以这里要减去1，并赋值给变量month
  11. avg = sum / month       #把3个月的工资总和除以月份，就是平均工资
  12. print ('近%d个月的平均工资是%d' %(month,avg))             #输出平均工资信息
  13. #在上面的输出语句中，“%d”表示将后面的%(month,avg）这两个变量的值，依次赋值给语句中的两个“%d”

执行的结果如下：

  1. 请输入第1个月的工资：             #手动依次输入进三个月的工资
  2. 11000
  3. 请输入第2个月的工资：
  4. 12000
  5. 请输入第3个月的工资：
  6. 13000
  7. 近3个月的平均工资是12000      #最后的输出结果，OK！没问题。

字符串的格式化输出介绍

在上面的脚本中，使用了字符串的格式化输出，就是“%d”，字符串的格式化是将若干值插入带有“%”替代符的字符串中，从而可以动态地输出字符串，在上面的Python脚本中，字符串中的“%d”表示插入的是一个整型数据，字符串后面的“%i”表示取的是变量“i”的值。

字符串格式化中可以使用的替代符除了“%d”,还有其他替代符，如下：

Python条件与循环

上面三种替换符的使用情况：
（1）每行字符串中单个替代符的使用：

  1. #脚本如下：
  2. num = 5
  3. numstr = "五"
  4. numF = 5.55
  5. print ("第%d名"%num)
  6. print ("第%s名"%numstr)
  7. print ("第%f名"%numF)
  8. #执行结果如下：
  9. 第5名
  10. 第五名
  11. 第5.550000名

（2）字符串中还可以使用多个替代符，对应的变量使用元组即可，示例如下：

  1. #脚本如下：
  2. first = 1
  3. second = 2
  4. print ("第%d名和第%d名"%(first,second))
  5. #执行结果如下：
  6. 第1名和第2名

使用多个替代符时，注意顺序不要放错，否则可能会出现类型不匹配的问题。

（3）还可以使用字典格式化多个值，如下：

  1. #代码如下：
  2. num = {"first":1,"second":2}             #定义一个字典
  3. print ( "第%(second)d名和第%(first)d名"%num )
  4. #执行结果如下：
  5. 第2名和第1名

在上面代码中，因为字典是无序的，所以使用字典时需要把键指出来，明确哪个位置要用到哪个键值。

while循环的嵌套使用

while循环可以嵌套使用，示例代码如下：

  1. #代码如下：
  2. j = 1
  3. prompt = '请输入员工姓名:'
  4. while j <= 2:
  5.     sum = 0
  6.     i = 1
  7.     name = raw_input(prompt)
  8.     while i <= 3:
  9.         print '请输入第%d月的工资：' %i
  10.         sum = sum +input()
  11.         i = i + 1
  12.     i = i - 1
  13.     avg = sum / i
  14.     print '%s的近%d个月的平均工资是：%d' %(name,i,avg)
  15. #执行结果如下：
  16. 请输入员工姓名:张三
  17. 请输入第1月的工资：
  18. 11000
  19. 请输入第2月的工资：
  20. 12000
  21. 请输入第3月的工资：
  22. 13000
  23. 张三的近3个月的平均工资是：12000
  24. 请输入员工姓名:李四
  25. 请输入第1月的工资：
  26. 7000
  27. 请输入第2月的工资：
  28. 8000
  29. 请输入第3月的工资：
  30. 9000
  31. 李四的近3个月的平均工资是：8000
  32. 员工平均工资计算完成！

在上面的代码中，外层循环（第一个while语句）用于输入员工姓名，用变量j控制循环的次数，共2次；内层循环（第二个while语句）用于输入近三个月的工资，用变量i控制，也就是在外层循环输入一个名字后，需要输入3次月工资，然后输出这个员工的平均工资，一共可以输入两个员工。第四行的代码放在了外层循环，是对sum变量做了清零，是因为每次输入一个人的近三个月的成绩后，sum都需要清零处理，以便计算下一个人的工资。如果不这样，之前的sum值就会保存，程序就无法达到预期的目的。

2、for循环

for循环是另一种用于控制循环的方式，while是使用条件判断执行循环，而for是使用遍历元素的方式进行循环。

（1）for循环的几种方式

for的语法结构如下：

  1. for  变量 in 集合:
  2.     语句块

常用的有以下几种使用方式：

1）for循环可以对字符串进行遍历，逐个获得字符串的每个字符，示例如下：

  1. #代码如下：
  2. for letter in 'Python':
  3.     print 'Current letter:%s' %letter
  4. #执行结果如下：
  5. Current letter:P
  6. Current letter:y
  7. Current letter:t
  8. Current letter:h
  9. Current letter:o
  10. Current letter:n

上面的代码中“for letter in ‘Python’ :”的作用是对“Python”字符串的字符逐个遍历，把字符赋值给变量letter，然后执行for对应的语句块，直到字符串取值完毕。看执行结果就知道怎么回事咯，这里就不啰嗦了。

2）for循环可以对列表和元组进行遍历，如下：

  1. #代码如下：
  2. Python = ['西瓜','苹果','香蕉']
  3. for letter in Python:
  4.     print letter
  5. #执行结果如下：
  6. 西瓜
  7. 苹果
  8. 香蕉

语句“for letter in Python:”的作用就是遍历列表中的元素，把元素赋值给letter，输出语句每次输出一个水果。

3）需要循环操作的内容相同时，可以用for循环结合range（）函数使用，如下：

  1. #代码如下：
  2. for i in range(0,5):
  3.     print '每天进步一点点。'
  4. #执行结果如下：
  5. 每天进步一点点。
  6. 每天进步一点点。
  7. 每天进步一点点。
  8. 每天进步一点点。
  9. 每天进步一点点。

range（0,5）输出的是一个列表，由第一个参数0开始，默认每次加1，当大于或等于第二个参数时结束，所以列表中不包括第二个参数值。range（）函数中还可以写入第三个参数，如：range（0,5,2），意思是每次加2，最后的列表值是“[0,2,4]”，所以range（）函数的作用是创建一个数字列表，取值范围是从起始数字开始到结束数字之前的内容。for循环可以对列表进行遍历，所以可以针对range（）函数的结果进行遍历。

4）for循环示例：

  1. #代码如下：
  2. subjects = ('python','mysql','linux')
  3. sum = 0
  4. for i in subjects:
  5.     print '请输入%s的测试成绩：' %i
  6.     score = input()
  7.     sum +=score                  # 与sum = sum+score效果一样
  8. avg = sum / len(subjects)
  9. print '张三的平均测试成绩为%d' %avg
  10. #执行结果如下：
  11. 请输入python的测试成绩：
  12. 80
  13. 请输入mysql的测试成绩：
  14. 90
  15. 请输入linux的测试成绩：
  16. 100
  17. 张三的平均测试成绩为90

上面代码的作用是接收3门课程的成绩，计算输出平均成绩，使用for循环遍历测试列表subjects，接受测试成绩后使用sum累加，最后输出平均成绩。

5）for循环嵌套举例

  1. #代码如下：
  2. staffs = ['张三','李四']
  3. months = ['1','3','5']
  4. for staff in staffs:
  5.     sum = 0
  6.     for month in months:
  7.         print '请输入%s的第%s个月的工资：' %(staff,month)
  8.         sum = sum + input()
  9.     avg = sum / len(months)
  10.     print '%s的平均工资是%d' %(staff,avg)
  11. #执行结果如下：
  12. 请输入张三的第1个月的工资：
  13. 11000
  14. 请输入张三的第3个月的工资：
  15. 12000
  16. 请输入张三的第5个月的工资：
  17. 13000
  18. 张三的平均工资是12000
  19. 请输入李四的第1个月的工资：
  20. 21000
  21. 请输入李四的第3个月的工资：
  22. 22000
  23. 请输入李四的第5个月的工资：
  24. 23000
  25. 李四的平均工资是22000

上面代码中，第一次循环对员工姓名进行了遍历，第二层循环对所指定的月份进行了遍历。

6）任何语言中都有逻辑表达式，它是用逻辑运算符和变量连接起来的表达式，逻辑运算符如下所示：

Python条件与循环

逻辑运算符的使用举例：

举例1：

  1. >>> print (not True)
  2. False
  3. >>> print (True and False)
  4. False
  5. >>> print (True or False)
  6. True

举例2：

  1. >>> score = 180
  2. >>> if (score < 0 or score > 100):   #如果score小于0或大于100，那么就为真
  3.     print '成绩错误，不能小于0或大于100'
  5. 成绩错误，不能小于0或大于100
  6. >>> if (not (score > 0 and score < 100)):     #如果score不大于0并且不小于100，那么就为真。
  7.     print '成绩错误，不能小于0或大于100'
  9. 成绩错误，不能小于0或大于100

三、循环的控制

当使用while和for做循环操作时，有时候需要改变循环的正常执行顺序，这时就需要用到循环控制语句实现，循环控制语句有break和continue。

1、break（中断）

当循环的语句块中有break语句时，可以跳出整个循环，相当于shell中的exit。示例如下：

  1. #代码如下：
  2. staffs = ['张三','李四']
  3. months = ['1','3','5']
  4. for staff in staffs:
  5.     sum = 0
  6.     for month in months:
  7.         print '请输入%s的第%s个月的工资：' %(staff,month)
  8.         score = input()
  9.         if (score < 0 or score > 50000):   
  10.             print '输入的工资要大于0或者小于50000，循环退出'
  11.             break;     # break语句，跳出这个循环
  12.         sum += score
  13.     avg = sum / len(months)
  14.     print '%s的平均工资是%d' %(staff,avg)
  15. #执行结果如下：
  16. 请输入张三的第1个月的工资：
  17. 50001             #输入了一个比50000大的数字
  18. 输入的工资要大于0或者小于50000，循环退出
  19. 张三的平均工资是0
  20. 请输入李四的第1个月的工资：

2、continue（继续）

continue和break的区别在于：continue它不是结束整个循环，而是跳过当前一轮的循环体剩余语句，重置测试循环状态，准备进入下一轮循环，如下：

  1. #代码如下：
  2. staffs = ['张三','李四']
  3. months = ['1','3','5']
  4. for staff in staffs:
  5.     sum = 0
  6.     i = 0
  7.     while (i < len(months)):
  8.         print '请输入%s的第%s个月的工资：' %(staff,months[i])
  9.         score = input()
  10.         if (score < 0 or score > 50000):
  11.             print '输入的工资要大于0或者小于50000，请重新输入。'
  12.             continue;
  13.         sum += score
  14.         i += 1
  15.     avg = sum / len(months)
  16.     print '%s的平均工资是%d' %(staff,avg)
  17. #执行结果如下：
  18. 请输入张三的第1个月的工资：
  19. 50001
  20. 输入的工资要大于0或者小于50000，请重新输入。
  21. 请输入张三的第1个月的工资：
  22. 30000
  23. 请输入张三的第3个月的工资：
  24. 25000
  25. 请输入张三的第5个月的工资：
  26. 60000
  27. 输入的工资要大于0或者小于50000，请重新输入。
  28. 请输入张三的第5个月的工资：
  29. 20000
  30. 张三的平均工资是25000
  31. 请输入李四的第1个月的工资：

在上面代码中，第一层循环使用for循环遍历员工，第二层使用while循环遍历月份，使用continue是跳到离它最近的循环的下一轮，也就是第二层的while循环，如果while中的if条件测试不成立，那么将执行continue后，代码中的“ i+=1 ”，并没有执行，就又重新执行while循环，所以再次调用时同样的月份，以便重新输入。这种方式在比较人性化。

四、Python的循环综合示例

示例需求如下：

  • 显示操作的菜单，有3个选项，分别用字母N、E、Q表示；
  • N表示输入新的用户名和密码；
  • E表示使用用户名和密码登录；
  • Q表示退出程序。

1、完整脚本如下所示：

  1. #代码如下：
  2. kgc = {}
  3. prompt = '''
  4.     (N) ew user login
  5.     (E) ntering user login
  6.     (Q)uit
  7. Enter choice:'''
  8. while True:
  9.     choice = raw_input(prompt).strip()[0].lower()
  10.     print '\n--You picked : [%s]' %choice
  11.     if choice not in 'neq':
  12.         print '--invalid option,try again--'
  13.     else:
  14.         if choice=='n':
  15.             prompt1 = 'login desired:'
  16.             while True:
  17.                 name = raw_input(prompt1)
  18.                 if(kgc.has_key(name)):
  19.                     prompt1 = '--name taken,try another:'
  20.                     continue
  21.                 else:
  22.                     pwd = raw_input('password:')
  23.                     kgc[name] = pwd
  24.                     break
  25.         elif choice =='e':
  26.             name = raw_input('login:')
  27.             pwd = raw_input('password:')
  28.             password = kgc.get(name)
  29.             if password == pwd:
  30.                 print '--welcome back--',name
  31.             else:
  32.                 print '--login incorrect--'
  33.         else:
  34.             print 'quit'
  35.             break
  36. #执行结果如下：
  38.     (N) ew user login
  39.     (E) ntering user login
  40.     (Q)uit
  41. Enter choice:N
  43. --You picked : [n]
  44. login desired:张三
  45. password:123
  47.     (N) ew user login
  48.     (E) ntering user login
  49.     (Q)uit
  50. Enter choice:e
  52. --You picked : [e]
  53. login:张三
  54. password:123
  55. --welcome back-- 张三
  57.     (N) ew user login
  58.     (E) ntering user login
  59.     (Q)uit
  60. Enter choice:q
  62. --You picked : [q]
  63. quit
  64. >>>

2、解释代码的作用及含义：

  1. kgc = {}             #首先定义一个空字典，用于存放新建的用户及密码
  2. prompt = '''                #这是一段提示信息，三引号表示若需要输入多行内容时使用。
  3.     (N) ew user login
  4.     (E) ntering user login
  5.     (Q)uit
  6. Enter choice:'''
  7. while True:                  #条件是永远为真
  8.     choice = raw_input(prompt).strip()[0].lower()  
  9. #上面一段是等待键盘输入的字符串（n、q、e），strip()函数去掉字符串前后的空格，然后取第一个字符。
  10. #函数lower（）的作用是将字符变成小写字母，为后面的条件判断做准备
  11.     print '\n--You picked : [%s]' %choice    #换行输出提示信息，提示你刚刚输入的是什么。
  12.     if choice not in 'neq':       #如果输入的不是neq这三个字符其中之一
  13.         print '--invalid option,try again--'           #那么输出一段错误提示信息
  14.     else:     #否则执行下面的内容
  15.         if choice=='n':        #如果输入的是“n”
  16.             prompt1 = 'login desired:'     #定义一个提示信息的变量
  17.             while True:                  #进行while循环
  18.                 name = raw_input(prompt1)  #等待键盘输入用户名，提示信息就是上面定义的prompt1变量
  19.                 if(kgc.has_key(name)):   #如果输入的用户名已存在字典中，
  20.                     prompt1 = '--name taken,try another:'     #重新定义一下提示信息的变量内容       
  21.                     continue     #然后执行continue语句，重新进行循环
  22.                 else:          #反之
  23.                     pwd = raw_input('password:')      #继续输入用户的密码
  24.                     kgc[name] = pwd        #然后将用户名和密码写入字典中
  25.                     break       #while循环结束
  26.         elif choice =='e':               #如果输入的“e”
  27.             name = raw_input('login:')     #那么等待键盘输入用户名，提示信息为“login”
  28.             pwd = raw_input('password:')  #等待键盘输入密码，raw_input（）括号中的内容时提示信息
  29.             password = kgc.get(name)    #查询字典中的用户名对应的密码和输入的密码是否一致
  30.             if password == pwd:     #如果一致
  31.                 print '--welcome back--',name      #则输出欢迎信息
  32.             else:     #反之
  33.                 print '--login incorrect--'       #输出错误
  34.         else:     #如果输入的不是n也不是e，又在neq三个字符中，那么输出的肯定是q了
  35.             print 'quit'    #所以就退出咯
  36.             break         #所以就退出咯

———————— 本文至此结束，感谢阅读 ————————

发表评论

表情：
评论列表 （有 0 条评论，208人围观）

还没有评论，来说两句吧...

相关阅读