作者：dfface
5. 判断（分支）
5.1 if 语句语法
1、if 判断语句基本语法：
if 要判断的条件: 条件成立时，要做的事情 ……
注意：代码的缩进为一个 tab 键，或者 4 个空格 —— 建议使用空格
- 在 Python 开发中，Tab 和空格不要混用！
2、如果需要在 不满足条件的时候，做某些事情，该如何做呢？
if 要判断的条件: 条件成立时，要做的事情 …… else: 条件不成立时，要做的事情 ……
- 在程序开发中，通常 在判断条件时，会需要同时判断多个条件，只有多个条件都满足，才能够执行后续代码，这个时候需要使用到 逻辑运算符。
- Python 中的 逻辑运算符 包括：与 and／或 or／非 not 三种
条件1 and 条件2 ：两个条件同时满足，返回 True 条件1 or 条件2：两个条件只要有一个满足，返回 True not 条件：非，不是
3、如果希望 再增加一些条件，条件不同，需要执行的代码也不同 时，就可以使用 elif ：
if 条件1: 条件1满足执行的代码 …… elif 条件2: 条件2满足时，执行的代码 …… elif 条件3: 条件3满足时，执行的代码 …… else: 以上条件都不满足时，执行的代码 ……
注意
- elif 和 else 都必须和 if 联合使用，而不能单独使用
- 可以将 if、elif 和 else 以及各自缩进的代码，看成一个 完整的代码块
4、在开发中，使用 if 进行条件判断，如果希望 在条件成立的执行语句中 再 增加条件判断，就可以使用 if 的嵌套：
if 条件 1: 条件 1 满足执行的代码 …… if 条件 1 基础上的条件 2: 条件 2 满足时，执行的代码 …… # 条件 2 不满足的处理 else: 条件 2 不满足时，执行的代码 # 条件 1 不满足的处理 else: 条件1 不满足时，执行的代码 ……
5.2 if语句的应用
5.2.1 随机数的处理
- 在 Python 中，要使用随机数，首先需要导入 随机数 的 模块 —— “工具包”
import random
- 导入模块后，可以直接在 模块名称 后面敲一个 . 然后按 Tab 键，会提示该模块中包含的所有函数
- random.randint(a, b) ，返回 [a, b] 之间的整数，包含 a 和 b
- 例如：
random.randint(12, 20) # 生成的随机数n: 12 <= n <= 20 random.randint(20, 20) # 结果永远是 20 random.randint(20, 10) # 该语句是错误的，下限必须小于上限
5.2.2 石头剪刀布
# 导入随机工具包
# 注意：在导入工具包的时候，应该将导入的语句，放在文件的顶部
# 因为，这样可以方便下方的代码，在任何需要的时候，使用工具包中的工具
import random
# 从控制台输入要出的拳 —— 石头（1）／剪刀（2）／布（3）
player = int(input("请输入您要出的拳 石头（1）／剪刀（2）／布（3）："))
# 电脑 随机 出拳 —— 先假定电脑只会出石头，完成整体代码功能
computer = random.randint(1, 3)
print("玩家选择的拳头是 %d - 电脑出的拳是 %d" % (player, computer))
# 比较胜负
# 1 石头 胜 剪刀
# 2 剪刀 胜 布
# 3 布 胜 石头
# if (()
# or ()
# or ()):
if ((player == 1 and computer == 2)
or (player == 2 and computer == 3)
or (player == 3 and computer == 1)):
print("欧耶，电脑弱爆了！")
# 平局
elif player == computer:
print("真是心有灵犀啊，再来一盘")
# 其他的情况就是电脑获胜
else:
print("不服气，我们决战到天明！")
6. 循环
6.1 程序执行的三大流程
在程序开发中，一共有三种流程方式：
- 顺序 —— 从上向下，顺序执行代码
- 分支 —— 根据条件判断，决定执行代码的 分支
- 循环 —— 让 特定代码 重复 执行
程序执行的三大流程
6.2 while 循环基本使用
while 语句基本语法：
初始条件设置 —— 通常是重复执行的 计数器 while 条件(判断 计数器 是否达到 目标次数): 条件满足时，做的事情1 条件满足时，做的事情2 条件满足时，做的事情3 ...(省略)... 处理条件(计数器 + 1)
由于程序员的原因，忘记 在循环内部 修改循环的判断条件，导致循环持续执行，程序将陷入死循环而无法终止！
计数器 +1 ：可以通过赋值运算符简化代码的编写。
常见的计数方法有两种，可以分别称为：
- 自然计数法（从 1 开始）—— 更符合人类的习惯
- 程序计数法（从 0 开始）—— 几乎所有的程序语言都选择从 0 开始计数
因此，大家在编写程序时，应该尽量养成习惯：除非需求的特殊要求，否则 循环 的计数都从 0 开始
6.3 break 和 continue
break 和 continue 是专门在循环中使用的关键字
- break ：某一条件满足时，退出循环，不再执行后续的代码
- continue ：某一条件满足时，不执行后续的代码直接进入下一次循环
- break 和 continue 只针对 当前所在循环 有效
6.4 while 循环嵌套
- while 嵌套就是：while 里面还有 while，每一次循环中还要做完一个循环。
while 条件 1: 条件满足时，做的事情1 条件满足时，做的事情2 条件满足时，做的事情3 ...(省略)... while 条件 2: 条件满足时，做的事情1 条件满足时，做的事情2 条件满足时，做的事情3 ...(省略)... 处理条件 2 处理条件 1
示例：
"""
打印 9 行小星星：
*
**
***
****
*****
******
*******
********
*********
"""
# 定义起始行
row = 1
# 最大打印 9 行
while row <= 9:
# 定义起始列
col = 1
# 最大打印 row 列
while col <= row:
# end = ""，表示输出结束后，不换行
# "\t" 可以在控制台输出一个制表符，协助在输出文本时对齐
print("%d * %d = %d" % (col, row, row * col), end="\t")
# 列数 + 1
col += 1
# 一行打印完成的换行
print("")
# 行数 + 1
row += 1
<补>字符串中的转义字符
- \t 在控制台输出一个 制表符，协助在输出文本时 垂直方向 保持对齐
- \n 在控制台输出一个 换行符
制表符 的功能是在不使用表格的情况下在 垂直方向 按列对齐文本
转义字符 描述 \\ 反斜杠符号 \' 单引号 \" 双引号 \n 换行 \t 横向制表符 \r 回车 7. 函数
7.1 函数的基本使用
所谓函数，就是把 具有独立功能的代码块 组织为一个小模块，在需要的时候 调用。在开发程序时，使用函数可以提高编写的效率以及代码的 重用，函数的使用包含两个步骤：
1. 定义函数 —— 封装 独立的功能
2. 调用函数 —— 享受 封装 的成果
- 定义函数：
def 函数名(): 函数封装的代码 ……
- 函数调用：通过 函数名() 即可完成对函数的调用。
PyCharm 的调试工具：
- F8 Step Over 可以单步执行代码，会把函数调用看作是一行代码直接执行
- F7 Step Into 可以单步执行代码，如果是函数，会进入函数内部
- 函数的文档注释
- 在开发中，如果希望给函数添加注释，应该在 定义函数 的下方，使用 连续的三对引号，在 连续的三对引号 之间编写对函数的说明文字，在 函数调用 位置，使用快捷键 CTRL + Q 可以查看函数的说明信息。
注意：因为 函数体相对比较独立，函数定义的上方，应该和其他代码（包括注释）保留 两个空行
7.2 函数的参数
7.2.1 形参和实参
- 在函数名的后面的小括号内部填写 参数，多个参数之间使用逗号 , 分隔。
- 函数的参数，增加函数的 通用性，针对 相同的数据处理逻辑，能够 适应更多的数据**：
- 形参：定义 函数时，小括号中的参数，是用来接收参数用的，在函数内部 作为变量使用。
- 实参：调用 函数时，小括号中的参数，是用来把数据传递到 函数内部 用的。
def sum_2_num(num1, num2):
result = num1 + num2
print("%d + %d = %d" % (num1, num2, result))
sum_2_num(50, 20)
7.2.2 可变和不可变参数
问题 1：在函数内部，针对参数使用 赋值语句，会不会影响调用函数时传递的 实参变量？ —— 不会！
- 无论传递的参数是 可变 还是 不可变只要 针对参数 使用 赋值语句，会在 函数内部 修改 局部变量的引用，不会影响到 外部变量的引用
问题 2：如果传递的参数是 可变类型，在函数内部，使用 方法 修改了数据的内容，同样会影响到外部的数据，例如列表变量调用 += 本质上是在执行列表变量的 extend 方法。
7.2.2 缺省参数
定义函数时，可以给 某个参数 指定一个默认值，具有默认值的参数就叫做 缺省参数，* 调用函数时，如果没有传入 缺省参数 的值，则在函数内部使用定义函数时指定的 参数默认值，将常见的值设置为参数的缺省值，从而 简化函数的调用。例如：对列表排序的方法：
gl_num_list = [6, 3, 9] # 默认就是升序排序，因为这种应用需求更多 gl_num_list.sort() print(gl_num_list) # 只有当需要降序排序时，才需要传递 `reverse` 参数 gl_num_list.sort(reverse=True) print(gl_num_list)
- 在参数后使用赋值语句，可以指定参数的缺省值
def print_info(name, gender=True):
gender_text = "男生"
if not gender:
gender_text = "女生"
print("%s 是 %s" % (name, gender_text))
提示
- 缺省参数，需要使用 最常见的值 作为默认值！
- 如果一个参数的值 不能确定，则不应该设置默认值，具体的数值在调用函数时，由外界传递！
注意
- 必须保证 带有默认值的缺省参数 在参数列表末尾
- 在 调用函数时，如果有 多个参数，需要指定参数名，这样解释器才能够知道参数的对应关系！
7.2.3 多值参数
有时可能需要 一个函数 能够处理的参数 个数 是不确定的，这个时候，就可以使用 多值参数。
- python 中有 两种 多值参数：
- 参数名前增加 一个 * 可以接收 元组
- 参数名前增加 两个 ** 可以接收 字典
- 一般在给多值参数命名时，习惯使用以下两个名字
- *args —— 存放 元组 参数，前面有一个 *
- **kwargs —— 存放 字典 参数，前面有两个 **
def demo(num, *args, **kwargs):
print(num)
print(args)
print(kwargs)
demo(1, 2, 3, 4, 5, name="小明", age=18, gender=True)
print("-"*20)
demo(1,(2,3,4,5),{"name":"小明", "age":18, "gender":True})
print("-"*20)
demo(1,(2,3,4,5), name="小明", age=18, gender=True)
结果
<补> 元组和字典的拆包
- 在调用带有多值参数的函数时，如果希望：
- 将一个 元组变量，直接传递给 args
- 将一个 字典变量，直接传递给 kwargs
- 就可以使用 拆包，简化参数的传递，拆包 的方式是：
- 在 元组变量前，增加 一个 *
- 在 字典变量前，增加 两个 *
def demo(*args, **kwargs):
print(args)
print(kwargs)
# 需要将一个元组变量/字典变量传递给函数对应的参数
gl_nums = (1, 2, 3)
gl_xiaoming = {"name": "小明", "age": 18}
# 会把 num_tuple 和 xiaoming 作为元组传递个 args
# demo(gl_nums, gl_xiaoming)
demo(*gl_nums, **gl_xiaoming)
7.3 函数的返回值
- 在函数中使用 return 关键字可以返回结果，调用函数一方，可以 使用变量 来 接收 函数的返回结果。
注意：return 表示返回，后续的代码都不会被执行
def sum_2_num(num1, num2):
"""对两个数字的求和"""
return num1 + num2
# 调用函数，并使用 result 变量接收计算结果
result = sum_2_num(10, 20)
print("计算结果是 %d" % result)
函数参数和返回值
技巧
- 在 Python 中，可以 将一个元组 使用 赋值语句 同时赋值给 多个变量
- 注意：变量的数量需要和元组中的元素数量保持一致
# Python 专有，利用元组交换两个变量的值 a, b = b, a
7.4 函数的嵌套调用
- 一个函数里面 又调用 了 另外一个函数，这就是 函数嵌套调用。
def test1():
print("*" * 50)
print("test 1")
print("*" * 50)
def test2():
print("-" * 50)
print("test 2")
test1()
print("-" * 50)
test2()
提示：工作中针对需求的变化，应该冷静思考，不要轻易修改之前已经完成的，能够正常执行的函数！
7.5 函数的递归
函数调用自身的 编程技巧 称为递归
特点：一个函数 内部 调用自己
代码特点：
- 函数内部的 代码 是相同的，只是针对 参数 不同，处理的结果不同
- 当 参数满足一个条件 时，函数不再执行，通常被称为递归的出口，否则 会出现死循环！
案例 —— 计算数字累加：
需求：
- 定义一个函数 sum_numbers
- 能够接收一个 num 的整数参数
- 计算 1 + 2 + ... num 的结果
def sum_numbers(num): if num == 1: return 1 # 假设 sum_numbers 能够完成 num - 1 的累加 temp = sum_numbers(num - 1) # 函数内部的核心算法就是 两个数字的相加 return num + temp print(sum_numbers(2))
7.6 在模块中定义函数
模块是 Python 程序架构的一个核心概念
模块 就好比是 工具包，要想使用这个工具包中的工具，就需要 导入 import 这个模块， 每一个以扩展名 py 结尾的 Python 源代码文件都是一个 模块，在模块中定义的 全局变量 、 函数 都是模块能够提供给外界直接使用的工具。
- 可以 在一个 Python 文件 中 定义 变量 或者 函数
- 然后在 另外一个文件中 使用 import 导入这个模块
- 导入之后，就可以使用 模块名.变量 / 模块名.函数 的方式，使用这个模块中定义的变量或者函数
模块可以让 曾经编写过的代码 方便的被 复用！
模块名也是一个标识符，如果在给 Python 文件起名时，以数字开头 是无法在 PyCharm 中通过导入这个模块的。
<补> Pyc 文件
C 是 compiled 编译过 的意思。
- 浏览程序目录会发现一个 __pycache__ 的目录。
- 目录下会有一个 hm_10_分隔线模块.cpython-35.pyc 文件，cpython-35 表示 Python 解释器的版本。
- 这个 pyc 文件是由 Python 解释器将 模块的源码 转换为 字节码。
Python 这样保存 字节码 是作为一种启动 速度的优化。
- 什么是字节码？
- Python 在解释源程序时是分成两个步骤的：
- 首先处理源代码，编译 生成一个二进制 字节码。
- 再对 字节码 进行处理，才会生成 CPU 能够识别的 机器码。
- 有了模块的字节码文件之后，下一次运行程序时，如果在 上次保存字节码之后 没有修改过源代码，Python 将会加载 .pyc 文件并跳过编译这个步骤。
- 当 Python 重编译时，它会自动检查源文件和字节码文件的时间戳。
- 如果你又修改了源代码，下次程序运行时，字节码将自动重新创建。
(未完，待续）
