Python 基础学习笔记 03

Python基础系列
Python 基础学习笔记 01
Python 基础学习笔记 02
Python 基础学习笔记 03
Python 基础学习笔记 04
Python 基础学习笔记 05

文章目录

4.1. 判断语句
4.2. 逻辑运算
- 4.2.1. and
- 4.2.2. or
- 4.2.3. not
4.3. if语句进阶
- 4.3.1. elif
- 4.3.2. if 的嵌套
4.4. 运算符
- 4.4.1. 算数运算符
- 4.4.2. 关系运算符
- 4.4.3. 逻辑运算符
- 4.4.4. 赋值运算符
- 4.4.5. 运算符的优先级
4.5. 循环
4.6. 转义字符
4.7. 函数
4.8. 调试工具
4.9.函数的文档注释
4.10. 函数的参数
4.11. 形参和实参
4.12. 函数的返回值
4.13. 使用模块中的函数
4.14. Pyc文件
4.15. 非数字型变量的特点
4.16. 列表
- 4.16.1. 列表的定义
- 4.16.2. 列表的常用操作
- 4.16.3. 循环遍历
- 4.16.4. 应用场景
4.17. 元组
- 4.17.1. 元组的定义
- 4.17.2. 元组的创建
- 4.17.3. 元组的常用操作
- 4.17.4. 循环遍历
- 4.17.5. 应用场景
- 4.17.6. 元素和列表之间的转换
4.18. 字典
- 4.18.1. 字典的定义
- 4.18.2. 字典常用操作
- 4.18.3. 循环遍历
- 4.18.4. 应用场景
4.19. 字符串
- 4.19.1. 字符串的定义
- 4.19.2. 字符串的常用操作
- 4.19.3. 字符串的切片
4.20. 公共方法
4.21. 变量进阶
- 4.21.1. 变量的引用
- 4.21.2. 可变和不可变类型
- 4.21.3. 局部变量和全局变量
4.22. 函数进阶
- 4.22.1. 函数参数和返回值的作用
- 4.22.2. 函数的返回值进阶
- 4.22.3. 函数的参数进阶
- 4.22.4. 递归函数

4.1. 判断语句

语法格式：

if 要判断的条件:条件成立时,要做的事情
else条件不成立时，要做的事情

4.2. 逻辑运算

在程序开发中，通常在判断条件时，会需要同时判断多个条件
只有多个条件都满足，才能够执行后续代码，这时需要使用到逻辑运算符
逻辑运算符可以把多个条件按照逻辑进行连接，变成再复杂的条件
Python中的逻辑运算符包括：与and/或or/非not三种

4.2.1. and

格式：
```
条件1 and 条件2
```
真假表

4.2.2. or

格式：
```
条件1 or 条件2
```
真假表

4.2.3. not

格式：
```
not 条件
```
真假表

4.3. if语句进阶

4.3.1. elif

在开发中，使用if可以判断条件，使用else可以处理条件不成立的情况，但是，如果希望再增加一些条件，条件不同，需要执行的代码也不同时，就可以使用elif

语法格式：

if 条件1：条件1满足执行的代码
elif 条件2：条件2满足时，执行的代码
elif 条件3：条件3满足时，执行的代码
else:以上条件都不满足时，执行的代码

注意：
1. elif和else都必须和if联合使用，而不能单独使用
2. 可以将if、elif和else以及各自缩进的代码，看成一个完整的代码块

4.3.2. if 的嵌套

在开发时，使用if进行条件判断，如果希望再条件成立执行语句中再增加条件判断，就可以使用if的嵌套。if嵌套使用的场景就是：在之前条件满足的前提下，再增加额外的判断，注意缩进

语法格式：

if 条件1：
# 条件1满足执行的代码if 条件1基础上的条件2：条件2满足时，执行的代码# 条件2不满足的处理else:条件2不满足时，执行的代码
# 条件1不满足的处理
else:条件1不满足时，执行的代码

4.4. 运算符

4.4.1. 算数运算符

是完成基本的算术运算使用的符号，用来处理四则运算

4.4.2. 关系运算符

4.4.3. 逻辑运算符

4.4.4. 赋值运算符

4.4.5. 运算符的优先级

4.5. 循环

语法：

初始条件设置--通常是重复执行的计数器while条件（判断 计数器 是否达到 目标次数）：条件满足时，做的事情1条件满足时，做的事情2条件满足时，做的事情3..(省略).处理条件（计数器+1）

break和continue
- break：某一条件满足时，退出循环，不再执行后续重复的代码
- continue：某一条件满足时，不执行后续重复的代码
- break和continue只针对当前所在循环有效

循环嵌套

语法：

while 条件 1：条件满足时，做的事情1条件满足时，做的事情2条件满足时，做的事情3while 条件 2：条件满足时，做的事情1条件满足时，做的事情2条件满足时，做的事情3..(省略).处理条件2处理条件1

4.6. 转义字符

4.7. 函数

函数：把具有独立功能的代码块组织成一个小模块，在需要的时候调用
步骤：
1. 定义函数封装独立的功能
2. 调用函数享受封装的结果
作用：在程序开发时，使用函数可以提高编写的效率以及代码的重用
语法：
```
def 函数名():函数封装的代码
```
函数名称应该能够表达函数封装代码的功能，方便后续的调用
函数名称的命名应该符合表示符的命名规则

4.8. 调试工具

F8 Step Over可以单步执行代码，会把函数调用看作是一行代码直接执行
F7 Step Into可以单步执行代码，如果是函数，会进入函数内部

4.9.函数的文档注释

在开发中，如果希望给函数添加注释，应该在定义函数的下方，使用连续的三对引号
在连续的三对引号之间编写对函数的说明文字
在函数调用位置，使用快捷键CTRL+Q可以查看函数的说明信息

4.10. 函数的参数

函数的参数，增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据
在函数内部，把参数当做变量使用，进行需要的数据处理
函数调用时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过参数传递

4.11. 形参和实参

形参：定义函数时，小括号中的参数，是用来接收参数用的，在函数内部作为变量使用
实参：调用函数时，小括号中的参数，是用来把数据传递到函数内部用的

4.12. 函数的返回值

在程序开发中，有时候会希望一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理
返回值是函数完成工作后，最后给调用者的一个结果
在函数中使用return关键字可以返回结果
调用函数的一方，可以使用变量来接收函数的返回结果

4.13. 使用模块中的函数

模块：模块就好比工具包，要想使用这个工具包中的工具，就需要导入import这个模块。每一个以拓展名py结尾的python源代码文件都是一个模块。在模块中定义的全局变量、函数都是模块能够提供给外界直接使用的工具。

4.14. Pyc文件

操作步骤
1. 浏览程序目录会发现__pycache__的目录
2. 目录下会有一个hm_10_分隔线模块.cpython-39.pyc文件，cpython-39表示python解释器的版本
3. 这个pyc文件是由python解释器将模块的源码转换为字节码
  - python这样保存字节码是作为一种启动速度的优化
字节码
- python在解释源程序时是分成两个步骤的
  1. 首先处理源代码，编译生成一个二进制字节码
  2. 再对字节码进行处理，才会生成CPU能够识别的机器码
- 有了模块的字节码以后，下次运行程序时，如果在上次保存字节码之后没有修改过源代码，python将加载.pyc文件并跳过编译这个步骤
- 当python重编译时，它会自动检查源文件和字节码文件的时间戳
- 如果你又修改了源代码，下次程序运行时，字节码将自动重新创建

4.15. 非数字型变量的特点

特点：
1. 都是一个序列，也可以理解为容器
2. 取值[]
3. 遍历 for in
4. 计算长度、最大/最小值、比较、删除
5. 链接+和重复*
6. 切片

4.16. 列表

4.16.1. 列表的定义

定义：List(列表)是python中使用最频繁的数据类型，专门用于存储一串信息。列表用[]定义，数据之间使用,隔开。列表的索引从0开始，索引就是数据在列表中的位置编号，索引又可以称为下标。从列表中取值时，如果超出索引范围，程序会报错。

4.16.2. 列表的常用操作

具体代码：

namelist = ["zhangsan","wangwu","lisi","wangwu"]# 1.取值或取索引
print(namelist[2])
# 求取列表内容所在的位置  (ValueError: 'wangwu321' is not in list)
print(namelist.index("wangwu"))# 2.修改   (IndexError: list assignment index out of range)
print(namelist)
namelist[1] = "李四"
print(namelist)# 3.增加
# append可以向列表的末尾追加数据
namelist.append("王小二")
print(namelist)
#insert可以向列表的指定位置插入数据
namelist.insert(1,"小美眉")
print(namelist)
# extend可以把其他列表的完整内容，追加到当前列表的末尾
temp_list = ["孙悟空","猪二哥","沙师弟"]
namelist.extend(temp_list)
print(namelist)# 4.统计
print(len(namelist))# 5.排序
print(namelist)
namelist.sort()
print(namelist)
namelist.sort(reverse=True)
print(namelist)
namelist.reverse()
print(namelist)# 6.删除
# remove可以从列表中删除指定的数据
namelist.remove("wangwu")
print(namelist)
# pop可以删除列表最后的数据
namelist.pop()
print(namelist)
namelist.pop(3)
print(namelist)
# clear可以清空整个列表
namelist.clear()
print(namelist)

del关键字
- 使用del关键字同样可以删除列表中元素
- del关键字本质上是用来将一个变量从内存中删除的
- 如果使用del关键字将变量从内存中删除，后续的代码就不能再使用这个变量
```
del name_list[1]
```
在日常开发中，要从列表删除数据，建议使用列表提供的方法

4.16.3. 循环遍历

遍历就是从头到尾依次从列表中获取数据，在循环体内部针对每一个元素，执行相同的操作
在python中为了提高列表的遍历效率，专门提供了迭代iteration遍历

使用for就能够实现迭代遍历

# for 循环内部使用的变量 in 列表
for name in name_list:循环内部针对列表元素进行操作print(name)

具体代码：

name_list = ["张三","李四","王五","王小二"]for my_name in name_list:print("我的名字叫 %S" % my_name)

4.16.4. 应用场景

场景：
1. 列表存储相同类型的数据
2. 通过迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作

4.17. 元组

4.17.1. 元组的定义

Tuple(元组)与列表类似，不同之处在于元组的元素不能修改
- 元组表示多个元素组成的序列
- 元组在python开发中，有特定的应用场景
用于存储一串信息，数据之间使用,分隔
元组用()定义
元组的索引从0开始，索引就是数据在元组中的位置编号

4.17.2. 元组的创建

info_tuple = ()

元组中只包含一个元素时，需要在元素后面添加逗号

info_tuple = (50,)

4.17.3. 元组的常用操作

具体代码：

# 1.从列表中取值
info_tuple = ("zhangsan",18,1.75,"zhangsan")
print(info_tuple[2])# 2.取索引(第一次)，已知数据的内容，希望知道该数据在元组中的索引
print(info_tuple.index("zhangsan"))# 3.统计元组中包含元素的个数
print(len(info_tuple))# 4.统计计数
print(info_tuple.count("zhangsan"))

4.17.4. 循环遍历

取值就是从元组中获取存储在指定位置的数据
遍历就是从头到尾依次从元组中获取数据
注意：
- 在python中，可以使用for循环遍历所有非数字型的变量：列表、元组、字典以及字符串

具体代码：

info_tuple = ("zhangsan",18,1.75)for my_info in info_tuple:print(my_info)

4.17.5. 应用场景

函数的参数和返回值，一个函数可以接收任意多个参数，或者一次返回多个数据

格式字符串，格式化字符串后面的()本质上就是一个元组

info_tuple = ("zhangsan",18,1.75)print("%s 的年龄是 %d ,身高是 %.2f" % info_tuple)

让列表不可以被修改，以保护数据安全

4.17.6. 元素和列表之间的转换

使用list函数可以把元组转换成列表

# 定义元组
num_tuple = (1,2,3,4)# 使用list函数可以把元组转换成列表
num_list = list(num_tuple)
print(type(num_list))

使用tuple函数可以把列表转换成元组

# 定义列表
num_list = [1,2,3,4]# 使用tuple函数可以把列表转换成元组
num_tuple = tuple(num_list)
print(type(num_tuple))

4.18. 字典

4.18.1. 字典的定义

字典同样可以存储多个数据，通常用于存储描述一个物体的相关信息
和列表的区别
- 列表是有序的对象集合
- 字典是无序的对象集合
字典使用{}定义
字典使用键值对存储数据，键值对之间使用,分隔
- 键key是索引，必须是唯一的
- 值value是数据，可以取任何数据类型，但键只能使用字符串、数字和元组
- 键和值之间使用:分隔

4.18.2. 字典常用操作

具体代码

# 1.字典的定义
xiaoming_dict = {"name":"xiaoming","age":18,"gender":True,"height":1.75,"weight":75}
print(xiaoming)# 2.取值 (KeyError: 'name123')
print(xiaoming_dict["name"])
print(xiaoming_dict.get("age"))# 3.增加或修改数据
# key不存在，增加数据
xiaoming_dict["age"] = 17
# key存在，修改数据
xiaoming_dict["name"] = "小小明"
# key存在，不修改数据
xiaoming_dict.setdefault("name","大明")
# key不存在，增加数据
xiaoming_dict.setdefault("hobby","篮球")# 4.删除数据
# 删除指定键值对
xiaoming_dict.pop("name")
#随机删除一个键值对(??最后一个，不随机??)
xiaoming_dict.popitem()
# 清空字典
xiaoming_dict.clear()# 5.统计键值对数量
print(len(xiaoming_dict))# 6.合并字典
# 如果被合并的字典中包含已经存在的键值对，会覆盖原有的键值对
temp_dict = {"height":1.75,"age":20}
xiaoming_dict.update(temp_dict)# 7.获取所有key列表
keys = xiaoming_dict.keys()
print(keys)# 8.获取所有value列表
xiaoming_dict.values()

4.18.3. 循环遍历

遍历：依次获取所有键值对
```
# for 循环内部使用的 key的变量 in 字典
for k in xiaoming_dict:print("%s: %s" % (k,xiaoming_dict[k]))
```
注意：在实际开发中，由于字典中的每一个键值对保存数据的类型是不同的，所以针对字典的循环遍历需求不是很多

4.18.4. 应用场景

使用多个键值对，存储描述一个物体的相关信息–描述更复杂的数据信息

将多个字典放在一个列表中，再进行遍历，在循环体内部针对每一个字典进行相同的处理

card_list = [{"name":"张三","qq":"12345","phone":"110"},{"name": "李四","qq": "54321","phone": "10086"}
]for card_info in card_list:print(card_info)

4.19. 字符串

4.19.1. 字符串的定义

字符串就是一串字符，是编程语言中表示文本的数据类型
在python中可以使用一对双引号"或者一对单引号'定义一个字符串
如果字符串内部需要使用"，可以使用'定义字符串
如果字符串内部需要使用'，可以使用"定义字符串
可以使用索引获取一个字符串中指定位置的字符，索引计数从0开始
也可以使用for循环遍历字符串中每一个字符

定义与遍历

str1 = "hello python"
str2 = "我的外号是'大西瓜'"for char in str2:print(char)

4.19.2. 字符串的常用操作

判断类型 - 9

# 1.判断空白字符
space_str = "    \r\t\n"
print(space_str.isspace())# 2.判断字符串中是否只包含数字
num_str = "12\u00b2"# 只能判断单纯数字
print(num_str.isdecimal())
# 可以判断数字和unicode编码
print(num_str.isdigit())
# 可以判断字母、unicode、中文数字
print(num_str.isnumeric())

查找和替换 - 7

hello_str = "hello world"# 1.判断是否以指定字符串开始
print(hello_str.startswith("hello"))# 2.判断是否以指定的字符串结束
print(hello_str.endswith("world"))# 3.查找指定字符串
# index同样可以查找指定的字符串在大字符串中的索引
print(hello_str.find("llo"))
# index如果指定的字符串不存在，会报错
# find如果指定的字符串不存在，会返回-1
print(hello_str.find("abc"))# 4.替换字符串
# replace方法执行完成以后，会返回一个新的字符串
# 注意：不会修改原有字符串的内容
print(hello_str.replace("world","python"))
print(hello_str)

大小写转换 - 5

hello_str = "hello world"# 把字符串中的第一个字符大写
print(hello_str.capitalize())
# 把字符串中的每个单词首字母大写
print(hello_str.title())
# 转换hello_str的小写字母为大写字母
print(hello_str.upper())

文本对齐 - 3

# 要求：顺序并居中对齐输出以下内容
poem = ["登鹳雀楼\n\t","王之涣","白日依山尽","\t黄河入海流","欲穷千里目","更上一层楼"]for poem_str in poem:# 先使用strip方法去除字符串中的空白字符# 再使用center方法居中显示文本print("|%s|" % poem_str.strip().center(20," "))

去除空白字符 - 3

拆分和连接 - 5

# 以anhui为基础进行分割，分割成三个元组
# 把数据转换成元组，使用循环输出结果
helllo_str = "helloanhuiaust"
hello_tuple = helllo_str.partition("anhui")for mytuple in hello_tuple:print(mytuple,len(mytuple))

# 1.将字符串中的空白字符全部去掉
# 2.再使用" "作为分隔符，拼接成一个整齐的字符串poem_str = "登鹳雀楼\n\t王之涣\n白日依山尽\t黄河入海流\t\n欲穷千里目\t\n更上一层楼"
print(poem_str)# 1.拆分字符串 split函数的返回值是字符串列表
poem_list = poem_str.split()
print(poem_list)# 2.合并字符串
result = " ".join(poem_list)
print(result)

4.19.3. 字符串的切片

切片方法适用于字符串、列表、元组
- 切片使用索引值来限定范围，从一个大的字符串中切出小的字符串
- 列表和元组都是有序的集合，都能够通过索引值获取到对应的数据
- 字典是一个无序的集合，是使用键值对保存数据

操作：

字符串[开始索引:结束索引:步长]

注意：
1. 指定的区间属于左闭右开型[开始索引，结束索引)，从起始位置开始，到结束位置的前一位结束
2. 从头开始，开始索引数字可以省略，冒号不能省略
3. 到末尾结束，结束索引数字可以省略，冒号不能省略
4. 步长默认为1，如果连续切片，数字和冒号都可以省略
索引的顺序和倒序
- 倒序索引时，最右边的索引值是-1，依次递减

具体代码：

num_str = "0123456789"# 1.截取2-5位置的字符串(左闭右开)
print(num_str[2:6])# 2.截取2-末尾位置的字符串(末尾可以省略)
print(num_str[2:])# 3.截取从开始-5的字符串(开始可以省略)
print(num_str[:6])# 4.截取完整的字符串(开始和结束都省略)
print(num_str[:])# 5.从开始位置开始，每隔一个字符截取一个字符
print(num_str[::2])# 6.从索引1开始，每隔一个字符取一个字符
print(num_str[1::2])# 7.倒序切片 -1表示倒数第一个字符
print(num_str[-1])# 8.截取从2-末尾-1的字符串
print(num_str[2:-1])# 9.截取字符串末尾的两个字符
print(num_str[-2:])# 10.字符串的逆序
print(num_str[::-1])

4.20. 公共方法

Python内置函数
切片
- 切片使用索引值来限定范围，从一个大的字符串中切出小的字符串
- 列表和元组都是有序的集合，都能够通过索引值获取到对应的数据
- 字典是一个无序的集合，是使用键值对保存数据

运算符

具体代码：

# 合并 +
list1 = [1,2,3]
list2 = [4,5,6]
print(list1+list2)# 重复 *
str1 = ["Hi"]
print(str1 * 4)# 元素是否存在与不存在
tuple1 = (1,2,3,4)
print(2 in tuple1)
print(5 not in tuple1)# 元素比较
print((4,5,6) < (2,))

完整的for循环语法

语法：

for 变量 in 集合:循环体代码
else:没有通过 break 退出循环，循环结束后，会执行的代码

具体实现代码：

# 在学员列表中搜索指定的姓名
find_name = "张三"students = [{"name":"阿土","age":20,"gender":True,"height":1.7,"weight":75.0},{"name":"小美","age":19,"gender":False,"height":1.6,"weight":45.0},]for stu_dict in students:print(stu_dict)if stu_dict["name"] == find_name:print("找到了 %s" % find_name)# 如果找到直接退出循环，后续不在遍历break
else:# 如果希望在搜索列表时，所有的字典检查之后，都没有需要搜索的目标print("没有找到 %s " % find_name)print("循环结束")

4.21. 变量进阶

4.21.1. 变量的引用

引用：变量和数据是分开存储的，数据保存在内存中的一个位置，变量中保存着数据在内存中的地址，变量中记录数据的地址，就叫做引用，使用id()函数可以查看变量中保存数据素在的内存地址。
函数的参数和返回值的传递：通过引用来传递

4.21.2. 可变和不可变类型

不可变类型，内存中的数据不允许被修改：
- 数字类型 int,bool,float,complex,long(2.x)
- 字符串str
- 元组tuple
可变类型，内存中的数据可以被修改：
- 列表list
- 字典dict

4.21.3. 局部变量和全局变量

局部变量是在函数内部定义的变量，只能在函数的内部使用
全局变量是在函数外部定义的变量，所有函数内部都可以使用这个变量
局部变量
- 局部变量是在函数内部定义的变量，只能在函数内部使用
- 函数执行结束后，函数内部的局部变量，会被系统回收
- 不同的函数，可以定义相同的名字的局部变量，而且彼此之间不会产生影响
- 作用：
  - 在函数内部使用，临时保存函数内部需要使用的数据
- 生命周期：
  - 所谓生命周期就是从变量被创建到被系统回收的过程
  - 局部变量在函数执行时才会被创建
  - 函数执行结束后局部变量被系统回收
  - 局部变量在生命周期内，可以用来存储函数内部临时使用的数据
- 代码实现：
```
def demo1():# 局部变量num = 10print("在demo1内部的变量是%d" % num)demo1()
```
全局变量
- 全局变量是在函数外部定义的变量，所有函数内部都可以使用这个变量
- 函数执行时，需要处理变量时：
  1. 首先查找函数内部是否存在指定名称的局部变量，如果有，直接使用
  2. 如果没有，查找函数外部是否存在指定名称的全局变量，如果有，直接使用
  3. 如果还没有，程序报错
- 代码实现：
```
# 全局变量
num = 10def demo1():print("demo1 ==> %d" % num)def demo2():print("demo2 ==> %d" % num)demo1()
demo2()
```
- 函数不能直接修改全局变量的引用
```
num = 10def demo1():# 希望修改全局变量的值# 在python中，是不允许直接修改全局变量的值，如果使用赋值语句，会在函数内部定义           一个局部变量num = 99print("demo1 ==> %d" % num)def demo2():print("demo2 ==> %d" % num)demo1()
demo2()
print(num)
```
- 在函数内部修改全局变量的值
  - 在函数中需要修改全局变量的值，需要使用global进行声明
```
num = 10def demo1():# global声明全局变量的值global numnum = 99print("demo1 ==> %d" % num)def demo2():print("demo2 ==> %d" % num)demo1()
demo2()
print(num)
```
- 全局变量定义的位置
  - 为了保证所有函数都能正确使用全局变量，应该将全局变量定义在其他函数的上方
```
# 全局变量的位置
num = 10
title = "黑马程序员"
name = "小明"def demo():print("%d" % num)print("%s" % title)print("%s" % name)def demo2():print("%s" % name)demo()
demo2()
```
  - 代码结构示意图
- 全局变量命名的建议
  - 为了避免局部变量和全局变量出现混淆，在定义全局变量时，有些公司会有一些开发要求，比如在全局变量名前增加g_或者gl_的前缀

4.22. 函数进阶

4.22.1. 函数参数和返回值的作用

无参数，无返回值
- 应用场景：
  1. 只是单纯的做一件事，例如显示菜单
  2. 在函数内部针对全局变量进行操作，例如：新建名片，最终结果记录在全局变量中
- 注意：
  - 如果全局变量的数据类型是一个可变类型，在函数内部可以使用方法修改全局变量的内容，变量的引用不会改变
  - 在函数内部，使用赋值语句才会修改变量的引用
无参数，有返回值
- 应用场景：
  - 采集数据，例如温度计，返回结果就是当前的温度，而不需要传递任何的参数
有参数，无返回值
- 应用场景：
  - 函数内部代码保持不变，针对不同的参数处理不同的数据
有参数，有返回值
- 应用场景：
  - 函数内部的代码保持不变，针对不同的参数处理不同的数据，并且返回期望的处理结果

4.22.2. 函数的返回值进阶

函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理
返回值是函数完成工作后，最后给调用者的一个结果
在函数中使用return关键字可以返回结果
调用哈数一方，可以使用变量来接收函数的返回结果

返回多个结果：

def mesure():temp = 39wetness = 50# 如果函数返回的类型是元组，小括号可以省略return temp,wetness# result为元组类型
result = mesure()
print(result)# 可以将一个元组使用赋值语句同时赋值给多个变量
# 变量的数量需要和元组中的元素数量保持一致
result = temp,wetness = measure()

交换两个数据
```
a=6
b=100a,b = b,a
print(a,b)
```

4.22.3. 函数的参数进阶

不可变和可变的参数

无论传递的参数是可变还是不可变，只要针对参数使用赋值语句，会在函数内部修改局部变量的引用，不会影响到外部变量的引用

代码实例：(使用赋值语句)

def demo(num,num_list):print("函数内部的代码")# 在函数内部，针对参数使用赋值语句num = 100num_list=[1,2,3]print(num)print(num_list)print("函数执行完成")gl_num = 99
gl_list = [4,5,6]
demo(gl_num,gl_list)
print(gl_num,gl_list)

代码实例：（使用方法）

def demo(num_list):num_list.append(9)print(num_list)gl_list = [1,2,3]
demo(gl_list)
print(gl_list)

代码实例：（列表变量调用+-，本质上是执行extend方法）

def demo(num,num_list):print("函数开始")num += num# 对于列表变量，在使用+=时，本质上是在执行列表变量的extend方法，不会修改变量的          引用num_list += num_listprint(num)print(num_list)print("函数结束")gl_num = 9
gl_list = [1,2,3]
demo(gl_num,gl_list)
print(gl_num)
print(gl_list)

缺省参数
- 定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫做缺省参数
- 调用函数时，如果没有传入缺省参数的值，则在函数内部使用定义函数时指定的参数默认值
- 函数的缺省参数，将常见的值设置为参数的缺省值，从而简化函数的调用
- 代码实例：
```
gl_num_list = [6,3,9]gl_num_list.sort()
print(gl_num_list)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))
```
- 注意：
  - 缺省参数的定义位置
    - 必须保证带有默认值的缺省参数在参数列表末尾
  - 调用带有多个缺省参数的函数
  - 在调用函数时，如果有多个缺省参数，需要指定参数名，这样解释器才知道参数的对应关系
  - 代码实例：
```
def print_info(name,title="同学",gender=True):gender_text = "男生"if not gender:gender_text = "女生"print("[%s] %s 是 %s" % (title,name,gender_text))print_info("小明")
print_info("老王",title="班长")
print_info("小美",gender=False)
```

多值参数

一个函数接收的参数不确定时，使用多值参数
两种多值参数
- 参数名前增加一个*可以接收元组
- 参数名前增加一个**可以接收字典

代码实例：（多值参数）

def demo(num, *nums, **person):print(num)print(nums)print(person)demo("name",2,3,4,5,name="小明",age=18,gender=True)

代码实例：（多值参数）

def sum_numbers(*args):num = 0print(args)for n in args:num += nreturn numresult = sum_numbers(1,2,3,8,89)
print(result)

代码实例：（元组和字典的拆包，元组加一个*，字典加两个*）

def demo(*args, **kwargs):print(args)print(kwargs)gl_nums = (1,2,3)
gl_dict = {"name":"小明","age":18}# 在元组前面加一个*，在字典前面加上两个*
demo(*gl_nums,**gl_dict)

4.22.4. 递归函数

特点：一个函数内部调用自己
代码特点：
1. 函数内部的代码是相同的，只是针对参数不同，处理的结果不同
2. 当参数满足一个条件时，函数不再执行，称为函数的出口

代码实例：

def sum_number(num):print(num)if num == 1:returnsum_number(num-1)sum_number(3)

代码实例：（求和）

def sum_numbers(num):# 1.出口if num == 1:return 1temp = sum_numbers(num-1)return num + tempresult = sum_numbers(100)
print(result)