input函数，读取键盘输入

将读取键盘输入这一篇内容安排在教程的这个阶段，是有着这样的考虑： 初学者缺乏不是知识，而是实际的编码锻炼。
为了更好的贴近实战，后面的教程，尽可能多的增加人机交互的练习题，让初学者习惯在实践中思考问题，而不是学术化的练习算法。
想要让自己写的程序与用户交互，可以通过键盘，也可以通过文件。内置函数input可以从标准输入中读取一行文本数据，默认的标准输入就是键盘，下面是一个非常简单的示例

  1. value = input("请输入一个整数:")
  2. print(value, type(value))

input接受一个字符串参数，在终端会输出这个字符串参数作为人机交互的提示语
条件控制 - 图1
虽然提示语要求用户输入一个整数，我在终端输入的也看似整数，但是input的功能是从标准输入中读取一行文本数据，因此，input函数返回的永远是字符串，这一点，可以通过print输出的内容来证明。

python如何画流程图

学习python过程中，画流程图可以有效的帮助你梳理程序的逻辑。程序流程图简称流程图，是一种传统的算法表示法，流程图用统一规定的标准符号描述程序运行具体步骤，毫不夸张的讲，画流程图已经是程序员必须掌握的一个技能。

1. 为什么要画程序流程图

学编程还需要画流程图？不要质疑，确实需要，尤其对于初学者来说，更是不可或缺。
你们不是关心怎么能学的快，学的好么，画程序流程图绝对是一个非常有效的学习手段，它的好处有以下几点

  1. 让思路更加清晰，逻辑更清楚
  2. 避免功能，逻辑有遗漏
  3. 有助于建立严谨的思维

初学者最常见的问题是一看就会，一写就错，心里好像很明白，可是脑子里一片混乱，手放在键盘上，都不知道该干什么。
一看就会，只能说明你对知识理解了，但是一写就错，脑子里一片混乱，除了知识运用不熟练这个因素外，更重要的原因是你组织代码的能力还很差，而程序流程图则可以有效的帮助你梳理程序的逻辑，流程图画的熟练，组织代码的能力也会渐渐随之提高。

2. 流程图的符号

其实，流程图的符号很少，也很好理解,初学阶段，只需要掌握以下符号，就可以画出程序流程图
条件控制 - 图2

3. 流程图示例

先来看题目要求
使用input函数接收用户的输入数据，如果用户输入python，则输出90， 如果用户输入java,输出95，如果用户输入php，输出85，其他输入，程序输出0
根据这段题目要求，咱们画出程序的流程图
条件控制 - 图3
我们还没有去写代码，但是已经对程序的控制流程了如指掌，程序的输入输出，条件判断，所有这些都以图像的形式展示出来，现在，还觉得大脑里一片混乱么
最后，写出代码

  1. value = input("请输入一个整数:")
  2. if value == 'python':
  3.     print(90)
  4. elif value == 'java':
  5.     print(95)
  6. elif value == 'php':
  7.     print(85)
  8. else:
  9.     print(0)

python 条件控制 if语句

python编程中 if语句用于控制程序的执行， if分支使用布尔表达式或布尔值作为分支条件来进行分支控制， if关键字后面的表达式如果为真,则进入到if语句块执行代码， 程序通过if语句中对条件表达式的判断进入到不同的逻辑分支中。

1. if 语句

最简单的if条件语句结构如下

  1. if condition:
  2.     block
  • condition 是一个表达式
  • 如果condition等价于True,则进入block代码块执行代码
  • block代码块相比于if语句缩进4个空格

接下来，通过一个实际例子来体会一下if语句的作用。你需要编写一段代码，通过input函数接收用户输入的正整数，如果用户输入的整数是偶数，则使用print函数输出如下格式的字符串： 你输入的整数是:xxx, 它是偶数。
这里我直接给出示例代码：

  1. value = input("请输入一个整整数:")
  2. i_value = int(value)
  3. if i_value % 2 == 0:
  4.     print("你输入的整数是:{value}, 它是偶数".format(value=value))
  1. input接收用户输入，返回的是字符串
  2. 将用户输入数据转成int类型数据
  3. 使用if语句，如果数据是偶数，则输出它是偶数的结论

上面这段代码，你应该掌握以下的知识点

  1. input函数
  2. int函数
  3. if条件语句
  4. % 取模运算
  5. 字符串格式化

2. 对程序要有绝对掌握权

对于程序，你要有绝对的掌握权，下面通过一个应用题目来解释什么是绝对的掌握权。

2.1 题目要求

使用input函数接收用户输入，用户输入2个正整数，中间用逗号分隔，如果他们的和是奇数，则输出”xxx与xx的和是奇数”

2.2 示例代码

  1. value = input("输入两个正整数,中间用逗号隔开:")
  2. value_lst = value.split(",")
  3. value_1, value_2 = int(value_lst[0]), int(value_lst[1])
  4. if (value_1 + value_2) % 2 == 1:
  5.     print("{var1} 和 {var2} 的和是奇数".format(var1=value_1, var2=value_2))

2.3 程序分析，绝对的掌握权

假设输入的内容为 12，13

  1. input函数返回的数据是字符串
  2. 使用字符串的split方法，可以用分割符对字符串进行分割。split方法返回的是列表，那么value_lst就是一个列表，它的值是 [‘12’, ‘13’]
  3. 两个字符串不能进行数字的加法操作，因此将他们转换成int类型数据，并赋值给两个新变量
  4. value_1与value_2的和是25，对2取模的结果是1，表达式 1==1 的结果是True,if 条件成立
  5. 按照指定格式输出

对于这样简单的代码，当输入数据确定时，即便不执行程序，你也能够像我上面所分析的那样，清楚的知道程序的每一个环节，知道每一个变量的数据类型，知道每一个变量的值是什么。

else

1. else

当紧跟在if 关键字后面的表达式成立时，程序进入if 关键字下面的代码快中执行，如果表达式不成立呢？这时，需要使用else关键字。
使用input函数接收用户输入，当输入数据是偶数时，输出 “你输入的整数是:xxx, 它是偶数”， 如果是奇数则输出“你输入的整数是:xxx, 它是奇数”，我直接给出示例代码

  1. value = input("请输入一个正整数:")
  2. i_value = int(value)
  3. if i_value % 2 == 0:
  4.     print("你输入的整数是:{value}, 它是偶数".format(value=value))
  5. else:
  6.     print("你输入的整数是:{value}, 它是奇数".format(value=value))

这段代码里，有两个逻辑分支，下图是程序的逻辑控制流程
条件控制 - 图4

elif

1. elif

前面已经学习了if 和 else， 聪明的孩子已经发现了问题，if 和 else加在一起也只能处理两种条件，可现实中的问题，往往有很多种条件，比如红绿灯，就有3个条件，当有更多条件无法只用if 和 else控制时，就需要使用elif。
使用input函数接收用户的输入，用户输入一种颜色，如果是红色，程序输出“红灯停”,如果是绿色，则输出“绿灯行”,如果是黄色，则输出“等一等”，如果是其他颜色，则输出“无法识别”
老规矩，我直接给出示例代码供你学习

  1. value = input("输入一种颜色:")
  2. if value == '红色':
  3.     print("红灯停")
  4. elif value == '绿色':
  5.     print("绿灯行")
  6. elif value == '黄色':
  7.     print("等一等")
  8. else:
  9.     print("无法识别")

在这段代码里，有4个逻辑分支，在代码执行过程中，会从上到下依次进行判断，如果表达式成立则进入相应的代码块执行，如果if 和 elif后面的表达式都不成立，则程序最终进入到else下面的代码块中执行，下面是程序流程图
条件控制 - 图5

if嵌套

1. if嵌套

最简单的if条件语句结构如下

  1. if condition:
  2.     block

当表达式condition成立时，程序进入到if 下面的代码块block执行，在block中，还可以写if条件语句么?答案是肯定的，这样就形成了一个if嵌套，在某个条件下，继续针对不同的条件进行控制，嵌套的层次不受限制，只要你自己能理清思路就行。
使用input函数接收用户的输入，用户输入一个正整数num，对num进行判断，如果num小于50 ，那么则继续判断它能否被3整除，如果能，输出“可以被3整除”，否则输出“不能被3整除”， 如果numd大于等于50，则继续判断能否被5整除，如果能，输出“可以被5整除”，否则输出“不能被5整除”
直接给出示例代码

  1. num = int(input("输入一个数字："))
  2. if num < 50:
  3.     if num % 3 == 0:
  4.         print('可以被3整除')
  5.     else:
  6.         print('不能被3整除')
  7. else:
  8.     if num % 5 == 0:
  9.         print("可以被5整除")
  10.     else:
  11.         print("不能被5整除")

条件控制 - 图6

为什么python没有switch/case

不同于其他编程语言，python中是没有switch/case 这种语法的，如果你是从其他语言转到python的，期初，对于没有switch/case 是很不适应的，不过这并不影响你编程，因为if … elif … else 完全可以替代switch/case， 尽管写起来不那么舒服

1. if 条件语句替代 switch/case

  1. def get_score_by_course(course):
  2.     """
  3.     根据课程获取考试分数
  4.     :param course:
  5.     :return:
  6.     """
  7.     if course == 'mathematical':
  8.         return 90
  9.     elif course == 'english':
  10.         return 95
  11.     elif course == 'history':
  12.         return 98
  13.     else:
  14.         return 0
  15. print(get_score_by_course('english'))

2. 字典替代

除了使用if 条件语句，字典同样可以实现switch/case 的功能

  1. course_dict = {
  2.     'mathematical': 90,
  3.     'english': 95,
  4.     'history': 98
  5. }
  6. def get_score_by_course(course):
  7.     """
  8.     根据课程获取考试分数
  9.     :param course:
  10.     :return:
  11.     """
  12.     return course_dict.get(course, 0)
  13. print(get_score_by_course('english'))

使用字典，在课程和分数之间建立起映射关系，获取分数的函数一行代码就实现了if条件语句8行代码的功能，更加的简洁。
使用字典时，还可以用函数做value，使其扩展性更好。

  1. def get_mathematical_score():
  2.     return 90
  3. def get_english_score():
  4.     return 95
  5. def get_history_score():
  6.     return 98
  7. course_dict = {
  8.     'mathematical': get_mathematical_score,
  9.     'english': get_english_score,
  10.     'history': get_history_score
  11. }
  12. def get_score_by_course(course):
  13.     """
  14.     根据课程获取考试分数
  15.     :param course:
  16.     :return:
  17.     """
  18.     func = course_dict.get(course, lambda : 0)
  19.     return func()
  20. print(get_score_by_course('english'))

3. 通过关键字寻找对应函数

这样的设计，当增加一个课程时，必须修改course_dict，否则将无法获得对应的获取分数的函数，面对这种业务场景，有一种可以免去字典映射的方法，通过globals()函数获得全局变量，然后通过函数名称找到对应的函数

  1. def get_mathematical_score():
  2.     return 90
  3. def get_english_score():
  4.     return 95
  5. def get_history_score():
  6.     return 98
  7. def get_score_by_course(course):
  8.     """
  9.     根据课程获取考试分数
  10.     :param course:
  11.     :return:
  12.     """
  13.     global_dict = globals()
  14.     func_name = 'get_{course}_score'.format(course=course)
  15.     func = global_dict.get(func_name, lambda : 0)
  16.     return func()
  17. print(get_score_by_course('history'))

4. 更加直观的映射关系

上面的方法虽然免去了字典映射，看上去简化了代码，但是却带来了新的问题，get_score_by_course函数里的代码总给人一种云里雾里的印象，if条件语句替换switch/case的方法虽然写起来繁琐，但course和处理方法之间的映射关系非常明确，使用字典时，同样可以表达这种明确的映射关系。
而通过关键字直接查找对应的函数这种方式下，course与处理函数之间的映射关系变得隐晦起来，除非你仔细分析代码，否则，很难找到这种映射关系。
我们需要一种无需维护字典，无需繁琐的if 条件语句，同时又能表达清晰简明的映射关系的方法

  1. def func_dispatch(func):
  2.     registry = {}
  3.     def dispatch(key_word):
  4.         return registry.get(key_word, registry[object])
  5.     def register(key_word, func=None):
  6.         if func is None:
  7.             return lambda f: register(key_word, f)
  8.         registry[key_word] = func
  9.         return func
  10.     def wrapper(*args, **kw):
  11.         return dispatch(args[0])(*args, **kw)
  12.     registry[object] = func
  13.     wrapper.register = register
  14.     return wrapper
  15. @func_dispatch
  16. def score_dispath(course):
  17.     return 0
  18. @score_dispath.register('mathematical')
  19. def get_mathematical_score(course):
  20.     return 90
  21. @score_dispath.register('english')
  22. def get_english_score(course):
  23.     return 95
  24. @score_dispath.register('history')
  25. def get_history_score(course):
  26.     return 98
  27. def get_score_by_course(course):
  28.     """
  29.     根据课程获取考试分数
  30.     :param course:
  31.     :return:
  32.     """
  33.     return score_dispath(course)
  34. print(get_score_by_course('mathematical'))

func_dispatch 是一个装饰器，先用这个装饰器去装饰score_dispath，score_dispath就变成了可以分发函数的路由器，由它再去装饰实际处理业务的函数，注册的过程建立起关键字和函数之间的映射关系，这样，既没有if条件语句的繁琐，也没有维护字典的琐碎，却保留了映射关系的明确，至于这个func_dispatch装饰器，你实在理解不了也没有关系，只要会使用就可以了，使用时要注意，那些被注册的业务函数的参数必须和score_dispath保持一致，此外，你不需要再处理额外的事情。