任务:
主线A: 容器的扩展知识
主线B: Python函数
目标:
1: 能够操作字典的遍历, 知道字典遍历的相关函数
2:能够知道函数的作用; [了解] 解决代码重复、提升阅读性
3:能够知道如何定义函数; [重点]
def 函数名(参数列表):
代码
代码
...
4:能够知道如何调用函数; [重点]
函数名(参数列表)
5:能够知道什么是函数的说明文档; [了解]
给函数做多行注释
6:能够知道如何交换两个变量的值。 [了解]
a,b = b,a
容器知识补充
[了解]字典遍历方法:
当要遍历字典的元素内容，即获取字典的键、值。
常用方法:
为便于理解几个方法，可简要理解为：
[掌握]遍历字典元素
keys()方法：
说明：
在Python中，字典（dictionary）的keys()函数返回的是一个字典视图对象（dictionary view object），具体来说是“字典键视图”（dictionary keys view）。这个视图对象是一个动态集合，它展示了字典的键。这个视图对象支持集合操作，如迭代、成员检查等，但它不是列表或元组。
values()方法：
说明：
获取所有值，可以当做列表处理。
items()方法：
| 函数名 | 含义 |
|---|---|
| items() | 返回由键值组成的序列，主要应用于遍历字典。 |
说明 获取所有的键值。
例如，一起来完成：
（1）定义一个字典变量，存放一个学生的信息：姓名、住址、年龄等；
（2）获取字典变量中的所有键，并输出【键 --> 值】形式结果；
（3）获取字典变量中的所有值并输出；
（4）获取字典变量中的所有键、值序列；
（5）执行程序，观察效果。
datas = {"name": "张三丰",
"address": "武当山",
"age": 147}
print('--------1、获取所有的键----------------')
# keys()获取所有的键,得到一个字典视图对象
print(datas.keys()) # 获取的是一个对象，内部包含列表：dict_keys(['name', 'address', 'age'])
print(list(datas.keys())) # 得到列表： ['name', 'address', 'age']
print('--------2、遍历-方式1----------------')
# 遍历-方式1
for key in datas.keys(): #遍历时，不需要将keys()获取的内容进行列表转换，直接遍历即可
print(key+'------'+str(datas.get(key)))
print('--------4、获取所有的键值对项----------------')
print(datas.items()) #dict_items([('name', '张三丰'), ('address', '武当山'), ('age', 147)])
print('--------3、遍历-方式2----------------')
for kv in datas.items(): # kv就是一个元组： ('name', '张三丰')
print(kv[0]+'-----------'+str(kv[1]))
print('--------4、获取所有的值----------------')
#values() 得到一个字典视图对象
print(datas.values()) # dict_values(['张三丰', '武当山', 147])
print(list(datas.values())) # ['张三丰', '武当山', 147]
[掌握]公共运算符:
公共运算符指的是：可以运用于Python容器的一下运算符。
常见公共运算符操作:
例如，一起来完成：
（1）定义字符串变量，并完成+、*的运算操作；
（2）定义列表变量，并完成in、not in的运算操作。
print('---------运算符:+-----------------')
# ------字符串-----
str1 = 'hello'
str2 = 'world'
num = 123
print(str1 + str2) # +两端只能跟字符串
print(str1 + str(num)) # +两端只能跟字符串,否则需要进行类型强转
# -----列表-----
list1 = [1,2,3]
list2 = [3,4,5,6]
list3 = list1 + list2
print(list1) # list1不变
print(list2) # list2不变
print(list3) # list3为list1和list2合并后的结果
# 以下方式也可以将list1和list2进行合并
list1.extend(list2)
print(list1)
# -----元组-----
tuple1 = (1,2,3)
tuple2 = (3,4,5,6)
tuple3 = tuple1 + tuple2
print(tuple1)
print(tuple2)
print(tuple3) # tuple3为tuple1和tuple2合并后的结果
print('---------运算符:* -----------------')
str1 = 'itcast'
print(str1 * 10) # 让str1重复10次
list1 = [1,2,3]
print(list1 * 10) # 列表的内容被复制10倍
tuple1 = (1,2,3)
print(tuple1 * 10)
print('---------运算符: in和not in -----------------')
# -----字符串
str1 = 'I love itcast'
if 'v' in str1:
print('字符v在字符串中')
else:
print('字符v不在字符串中')
# -----列表
list1 = ['刘备','关羽','张飞']
if '关羽' in list1:
print('关羽在列表中')
else:
print('关羽不在列表中')
# -----字典
dict1 = {'name':'刘备','age':18}
if 'age' not in dict1:
print('age这个键在字典中')
else:
print('age这个键不在字典中')[了解]公共方法:
公共方法指的是：能适用于Python容器的一些通用方法。
常见公共方法：
| 描述 | |
|---|---|
| len(s) | 计算容器中的元素总个数 |
| del | 删除 |
| max() | 返回容器中元素最大值 |
| min() | 返回容器中元素最小值 |
例如，一起来完成：
（1）定义一个列表变量，内容为：10、300、20、200、30、100、0；
（2）获取列表变量的总长度；
（3）获取列表的最大值和最小值；
（4）思考：为何有些方法可直接使用，比如：max()、len()，而大多数方法都需要使用【变量名.函数(xx)】形式调用？
# 1.定义变量
list1 = [10,300,20,200,30,100,0]
# 2.长度
print(len(list1))
# 3.最大最小值
print(max(list1))
print(min(list1))
# 4.删除元素
del list1[1]
print(list1)
# 5、查看Python所有的内置函数
print(dir(__builtins__))函数介绍
[了解]函数的概念
==目标：==了解函数中的几个概念。
在Python函数中，有几个重要概念：
（1）函数名
（2）参数
（3）返回值
为了更好的理解函数的几个概念。通过【我给钱让儿子帮我买包烟】为例说明
整个过程：我给钱给我儿子，然后儿子帮我去买烟，最后他成功把烟拿给了我。
比如，买烟可以比作为一个函数名，那么给的钱就看作是参数，最终儿子拿给我的烟可以比作是返回值。
买烟(钱):
...[买烟过程]
返回: 烟
函数语法：
def 函数名(参数, ..): 代码1 代码2 ... [return 具体的值]
[了解]引入函数:
据说，项目开发前运行【佛祖镇楼】案例，可以减少项目Bug，一起看看。
比如，某个程序在不同的条件下，要输出【佛祖镇楼】，那么，程序可以使用if语句判断处理：
if 条件1: 输出"佛祖镇楼" …… elif 条件2: 输出"佛祖镇楼" …… elif 条件3: 输出"佛祖镇楼" …… ……(省略)
仔细观察，我们会发现：需要输出多次的【佛祖镇楼】。
此时，就可以使用函数解决重复编写代码的问题。
例如，一起来完成：
（1）当从键盘上输入数值1-6之间的某个自然数时，则输出【佛祖镇楼】；
（2）使用函数形式改进程序；
（3）对比两个程序代码并执行，观察效果。
# # 1.定义变量
# number = int(input("请输入数字:"))
# # 2.判断
# if number == 1:
# # 3.输出
# print(" _ooOoo_ ")
# print(" o8888888o ")
# print(" 88 . 88 ")
# print(" (| -_- |) ")
# print(" O\\ = /O ")
# print(" ____/`---'\\____ ")
# print(" . ' \\| |// `. ")
# print(" / \\||| : |||// \\ ")
# print(" / _||||| -:- |||||_ \ ")
# print(" | | \\\\\\ - /// | | ")
# print(" | \\_| ''\\---/'' | | ")
# print(" \\ ..\__ `-` ___/-. / ")
# print(" ___`. .' /--.-.\ `. . __ ")
# print(" ."" '< `.___\\_<|>_/___.' >'"". ")
# print(" | | : `- \\`.;`\\ _ /`;.`/ - ` : | | ")
# print(" \\ \\ `-. \\_ __\\ /__ _/ .-` / / ")
# print(" ======`-.____`-.___\\_____/___.-`____.-'====== ")
# print(" `=---=' ")
# print(" ")
# print(" ............................................. ")
# print(" .........佛祖镇楼...................bug辟易...")
# print(" 佛曰: ")
# print(" 写字楼里写字间，写字间里程序员； ")
# print(" 程序人员写程序，又拿程序换酒钱。 ")
# print(" 酒醒只在网上坐，酒醉还来网下眠； ")
# print(" 酒醉酒醒日复日，网上网下年复年。 ")
# print(" 但愿老死电脑间，不愿鞠躬老板前； ")
# print(" 奔驰宝马贵者趣，公交自行程序员。 ")
# print(" 别人笑我太疯癫，我笑自己命太贱； ")
# print(" 不见满街漂亮妹，哪个归得程序员？")
# elif number == 2:
# print(" _ooOoo_ ")
# print(" o8888888o ")
# print(" 88 . 88 ")
# print(" (| -_- |) ")
# print(" O\\ = /O ")
# print(" ____/`---'\\____ ")
# print(" . ' \\| |// `. ")
# print(" / \\||| : |||// \\ ")
# print(" / _||||| -:- |||||_ \ ")
# print(" | | \\\\\\ - /// | | ")
# print(" | \\_| ''\\---/'' | | ")
# print(" \\ ..\__ `-` ___/-. / ")
# print(" ___`. .' /--.-.\ `. . __ ")
# print(" ."" '< `.___\\_<|>_/___.' >'"". ")
# print(" | | : `- \\`.;`\\ _ /`;.`/ - ` : | | ")
# print(" \\ \\ `-. \\_ __\\ /__ _/ .-` / / ")
# print(" ======`-.____`-.___\\_____/___.-`____.-'====== ")
# print(" `=---=' ")
# print(" ")
# print(" ............................................. ")
# print(" .........佛祖镇楼...................bug辟易...")
# print(" 佛曰: ")
# print(" 写字楼里写字间，写字间里程序员； ")
# print(" 程序人员写程序，又拿程序换酒钱。 ")
# print(" 酒醒只在网上坐，酒醉还来网下眠； ")
# print(" 酒醉酒醒日复日，网上网下年复年。 ")
# print(" 但愿老死电脑间，不愿鞠躬老板前； ")
# print(" 奔驰宝马贵者趣，公交自行程序员。 ")
# print(" 别人笑我太疯癫，我笑自己命太贱； ")
# print(" 不见满街漂亮妹，哪个归得程序员？")
# elif number == 3:
# print(" _ooOoo_ ")
# print(" o8888888o ")
# print(" 88 . 88 ")
# print(" (| -_- |) ")
# print(" O\\ = /O ")
# print(" ____/`---'\\____ ")
# print(" . ' \\| |// `. ")
# print(" / \\||| : |||// \\ ")
# print(" / _||||| -:- |||||_ \ ")
# print(" | | \\\\\\ - /// | | ")
# print(" | \\_| ''\\---/'' | | ")
# print(" \\ ..\__ `-` ___/-. / ")
# print(" ___`. .' /--.-.\ `. . __ ")
# print(" ."" '< `.___\\_<|>_/___.' >'"". ")
# print(" | | : `- \\`.;`\\ _ /`;.`/ - ` : | | ")
# print(" \\ \\ `-. \\_ __\\ /__ _/ .-` / / ")
# print(" ======`-.____`-.___\\_____/___.-`____.-'====== ")
# print(" `=---=' ")
# print(" ")
# print(" ............................................. ")
# print(" .........佛祖镇楼...................bug辟易...")
# print(" 佛曰: ")
# print(" 写字楼里写字间，写字间里程序员； ")
# print(" 程序人员写程序，又拿程序换酒钱。 ")
# print(" 酒醒只在网上坐，酒醉还来网下眠； ")
# print(" 酒醉酒醒日复日，网上网下年复年。 ")
# print(" 但愿老死电脑间，不愿鞠躬老板前； ")
# print(" 奔驰宝马贵者趣，公交自行程序员。 ")
# print(" 别人笑我太疯癫，我笑自己命太贱； ")
# print(" 不见满街漂亮妹，哪个归得程序员？")
# elif number == 4:
# print(" _ooOoo_ ")
# print(" o8888888o ")
# print(" 88 . 88 ")
# print(" (| -_- |) ")
# print(" O\\ = /O ")
# print(" ____/`---'\\____ ")
# print(" . ' \\| |// `. ")
# print(" / \\||| : |||// \\ ")
# print(" / _||||| -:- |||||_ \ ")
# print(" | | \\\\\\ - /// | | ")
# print(" | \\_| ''\\---/'' | | ")
# print(" \\ ..\__ `-` ___/-. / ")
# print(" ___`. .' /--.-.\ `. . __ ")
# print(" ."" '< `.___\\_<|>_/___.' >'"". ")
# print(" | | : `- \\`.;`\\ _ /`;.`/ - ` : | | ")
# print(" \\ \\ `-. \\_ __\\ /__ _/ .-` / / ")
# print(" ======`-.____`-.___\\/___.-`____.-'====== ")
# print(" `=---=' ")
# print(" ")
# print(" ............................................. ")
# print(" .........佛祖镇楼...................bug辟易...")
# print(" 佛曰: ")
# print(" 写字楼里写字间，写字间里程序员； ")
# print(" 程序人员写程序，又拿程序换酒钱。 ")
# print(" 酒醒只在网上坐，酒醉还来网下眠； ")
# print(" 酒醉酒醒日复日，网上网下年复年。 ")
# print(" 但愿老死电脑间，不愿鞠躬老板前； ")
# print(" 奔驰宝马贵者趣，公交自行程序员。 ")
# print(" 别人笑我太疯癫，我笑自己命太贱； ")
# print(" 不见满街漂亮妹，哪个归得程序员？")
# 代码很多重复? -->不好维护
def show_no_bug():
# 3.输出
print(" _ooOoo_ ")
print(" o8888888o ")
print(" 88 . 88 ")
print(" (| -_- |) ")
print(" O\\ = /O ")
print(" ____/`---'\\____ ")
print(" . ' \\| |// `. ")
print(" / \\||| : |||// \\ ")
print(" / _||||| -:- |||||_ \ ")
print(" | | \\\\\\ - /// | | ")
print(" | \\_| ''\\---/'' | | ")
print(" \\ ..\__ `-` ___/-. / ")
print(" ___`. .' /--.-.\ `. . __ ")
print(" ."" '< `.___\\_<|>_/___.' >'"". ")
print(" | | : `- \\`.;`\\ _ /`;.`/ - ` : | | ")
print(" \\ \\ `-. \\_ __\\ /__ _/ .-` / / ")
print(" ======`-.____`-.___\\_____/___.-`____.-'====== ")
print(" `=---=' ")
print(" ")
print(" ............................................. ")
print(" .........佛祖镇楼...................bug辟易...")
print(" 佛曰: ")
print(" 写字楼里写字间，写字间里程序员； ")
print(" 程序人员写程序，又拿程序换酒钱。 ")
print(" 酒醒只在网上坐，酒醉还来网下眠； ")
print(" 酒醉酒醒日复日，网上网下年复年。 ")
print(" 但愿老死电脑间，不愿鞠躬老板前； ")
print(" 奔驰宝马贵者趣，公交自行程序员。 ")
print(" 别人笑我太疯癫，我笑自己命太贱； ")
print(" 不见满街漂亮妹，哪个归得程序员？")
# 1.定义变量
number = int(input("请输入数字:"))
# 2.判断
if number == 1:
show_no_bug()
elif number == 2:
show_no_bug()
elif number == 3:
show_no_bug()
elif number == 4:
show_no_bug()
# 解决了代码重复问题;
# 提升了代码阅读能力[掌握]函数定义与调用
Python函数需要使用def关键字来定义。使用方式有两步：
（1）先定义
（2）后调用
当然了，函数在使用时，特点：
（1）先定义，后调用； （2）不调用，不执行； （3）调用一次，执行一次。
接着，来一起看看函数的语法。
定义函数：
def 函数名(): 代码1 代码2 ...调用函数：
函数名()
例如，一起来完成：
（1）编写一个show()函数，并在函数中输出：bug虐我千百遍, 我待bug如初恋。
（2）调用函数，观察执行结果。
# 1.定义
# def show():
# print("bug虐我千百遍, 我待bug如初恋.")
# 2.调用
# show() # 1.写对函数名; 2.()
# show()
# show()
# 扩展
def show():
# 代码
pass[掌握]函数的参数
当在定义函数时，设定了参数，则可称该函数为：有参函数。反之，没有参数的函数，称为：无参函数。
定义有参数的函数，语法：
def 函数名(参数1,参数2,...): # 形参
代码1
代码2
...
调用函数，语法：
函数名(参数值1,参数值2,...) # 实参
说明：
（1）形参是指形式参数，表示在定义函数时的参数；
（2）实参是指实际参数，表示在调用函数时传递的参数值，具有实际意义。
例如，一起来完成：
（1）定义一个函数，用于求解两个数之和；
（2）接着，调用函数并执行程序，观察效果。
# 1.定义函数
def get_sum(a,b):
ret = a + b
print(f"两个数之和为:{ret}")
# 2.调用函数
get_sum(10,20)
# get_sum(90) # 报错[掌握]函数的返回值
==目标：==掌握函数返回值的使用。
函数的返回值指的是：当函数完成一件事情后，最后要返回给函数的结果。
返回值语法：
def 函数名([参数1, 参数2, ...]): 代码1 代码2 ... return 值
说明：
（1）若要给函数返回结果，需要使用return关键字；
（2）return关键字的作用：把结果返回给函数；结束函数；
（3）当函数没有返回值时，默认返回None。
print('-----------无参，无返回值-------------')
# 1、定义函数-无参，无返回值
def show():
print('这是一个函数，无参，无返回值')
# 2、调用函数
show()
show()
print('-----------有参，有返回值-------------')
# 1、定义函数:有参，有返回值 --->求两个数的和
# 该函数没有限定参数类型，理论上可以传入任何类型，但是可能会报错
def get_sum(num1, num2): # 形参
return num1 + num2
# 该函数限定参数类型必须是int，返回值也是int，一般封装系统级函数时，可以使用
def get_sum2(num1: int, num2: int) -> int: # 形参
return num1 + num2
# 2、调用函数
# 方式1
result1 = get_sum(10, 20) # 实参
print(result1)
# 方式2
print(get_sum(10, 20)) # 实参
print(get_sum('hello', 'world'))
# print(get_sum2('hello', 'world')) # 报错，类型不一致
print('-----------有参， 无返回值-------------')
# 如果一个函数没有指定返回值，默认会在函数尾部加：return None
# 1、定义函数
def func1(num):
for i in range(num):
print('********************')
# 2、调用函数
func1(5)
print('-----------无参， 有返回值-------------')
# 1、定义函数
import random
def get_random_number_between_1_and_100():
return random.randint(1, 100)
# 2、调用函数
print(get_random_number_between_1_and_100())
函数返回多个值
# 需求：定义一个函数，传入一个数字列表，返回列表的最大值，最小值，平均值
# 1、定义函数
def get_list_result(list_name):
max_value = max(list_name)
min_value = min(list_name)
avg_value = sum(list_name) / len(list_name)
return max_value, min_value, avg_value # 返回的时元组
# 2、调用函数
list1 = [1, 2, 3, 4, 5, 30, 50]
result = get_list_result(list1)
print(type(result)) # <class 'tuple'>
print(f'最大值：{result[0]}') # 使用索引来访问元组中的元素
print(f'最小值：{result[1]}') # 使用索引来访问元组中的元素
print(f'平均值：{result[2]}') # 使用索引来访问元组中的元素
[掌握]说明文档
说明文档指的是：在定义函数的第一行，加上多行注释。这样的操作，可以让函数更加规范化。
当添加了说明文档后，在调用函数时，就能查看到函数的作用提示。
说明：查看下print()函数
接着，一起来看看在自定义函数时，如何给函数添加说明文档？
添加说明文档的语法：
def 函数名():
""" 说明文档的位置 """
代码
...
当需要看函数的说明文档的具体内容时，语法：
help(函数名)
# 1、定义函数时，给函数加说明书
def get_list_result(list_name):
"""
这是一个获取列表信息的函数
:param 列表名
:return: 最大值、最小值、平均值
"""
max_value = max(list_name)
min_value = min(list_name)
avg_value = sum(list_name) / len(list_name)
return max_value, min_value, avg_value # 返回的时元组
# 使用方式1：调用函数时，将光标放在函数名字上，就会有说明信息
get_list_result()
# 使用方式2：调用help函数，打印函数说明书
help(get_list_result)函数的嵌套调用
[了解]嵌套调用及执行流程
函数的嵌套调用指的是：在一个函数中，调用了另一个函数。
嵌套调用语法：
def 函数1():
代码
...def 函数2():
代码
# 调用函数1
函数1()
...
说明：
在函数2中，调用了函数1。
例如，一起来完成：
（1）先定义一个test()函数和func()函数；
（2）接着，在函数test()中，嵌套调用func()函数，并在外部调用test()函数；
（3）执行程序，观察效果；
（4）思考：嵌套调用的执行流程是怎样的呢？
# 1.定义func()
def func():
print("==========AA===============")
print("==========Nfunc()============")
print("==========BB===============")
# 2.定义test()、调用func()
def test():
print("*************11****************")
func()
print("**********M调用了test方法**************")
print("*************22****************")
# 3.调用test()
test() # 1ANBM2
# 说明流程# 定义函数test1()
def test1():
print('这个是test1函数')
# 嵌套调用
def test2():
test1()
print('这个是test2函数')
# 调用函数test2
test2()
print('------------------------------------------')
def 数据采集():
print('数据采集中！')
def 数据预处理():
print('数据预处理中！')
def 数据分析():
print('数据分析中！')
def 数据导出():
print('数据导出中！')
def shufen():
数据采集()
数据预处理()
数据分析()
数据导出()
# 调用函数
shufen()==总结：==
（1）嵌套调用指的是：一个函数中，调用了另一个函数；
（2）注意：函数的嵌套调用执行流程较为复杂，需要多观察执行结果。
[了解]嵌套调用的应用
==目标：==了解函数嵌套调用的应用。
使用函数的嵌套调用，我们可以把复杂问题分解成：多个简单问题，这样便于解决问题。
比如，要求多个数的平均值。此时，我们就可以拆分为两个函数：
（a）函数A：用于求解多个数之和；
（b）函数B：调用函数A，获取多个数之和，接着，再使用和除以总个数，就能求解出平均值。
例如，一起来完成：
（1）要完成一个输出任意条横线的需求；
（2）定义函数1：用于输出一条横线；
（3）定义函数2：先循环N次，再调用函数1，可输出N条横线；
（4）执行程序，观察效果。
# 1.定义一条横线的函数
def print_one_line():
print("-"*40)
# 2.N条横线
def print_lines(n):
for i in range(n):
print_one_line()
print_lines(10)==总结：==
（1）采用函数的嵌套调用，可以让复杂问题简单化。
变量的作用域
[掌握]局部变量
先来了解一下作用域的概念！
作用域指的是：内容生效的具体范围。
接着，当根据作用域的不同，可以给变量分为两类：
（1）局部变量
（2）全局变量 [稍后讲解]
局部变量指的是：定义在函数内部的变量或参数，且只在函数中生效。
局部变量语法：
def 函数名(参数1,参数2,...):
代码
变量名 = 值
...
说明：局部变量只作用在函数中。
（1）定义一个函数1，有局部变量：参数；
（2）定义一个函数2，有局部变量：变量；
（3）调用函数，观察程序执行效果。
print('--------局部变量-方法内部-----------')
# 定义在函数内部的变量称为局部变量，对外不可见
def func(a):
b = 20 # 局部变量
a = a +1 # 局部变量
print('a=',a)
print('b=',b)
# print(a) # 报错
# print(b) # 报错
func(10)
print('--------特殊情况-for内部-----------')
for i in range(10):
print(i)
print('i=',i) # for结束之后，这里的i可以访问，值为9
[掌握]全局变量
全局变量指的是：在函数体内、外都能生效的变量。
通俗地说，与模块中定义的函数，处于同一级别的变量，就是全局变量。
全局变量语法：
变量名 = 值
def 函数名():
代码
...# 变量名 = 值
说明：
（1）全局变量是指与函数处于同一级别的变量；
（2）注意：当函数中的局部变量与全局变量同名时，在函数中使用的是局部变量的值。
需要注意的是，当要修改全局变量的值时，记得提前使用global进行声明。
global关键字语法：
# 声明
global 变量名
# 修改值
变量名 = 修改后的值
例如，一起来完成：
（1）定义一个全局变量1，并在函数内外都使用；
（2）定义一个同名的全局变量2和局部变量，并在函数内使用该同名变量；
（3）执行程序，观察效果。
print('--------全局变量-----------')
# 定义在函数内部的变量称为局部变量，对外不可见
a = 10 # 全局变量
def func():
print(a) # 函数内部访问全局变量
print(a) # 函数外部访问全局变量
func()
print('--------全局变量-----------')
a = 10 # 全局变量
def test1():
a = 20 # 局部变量，是一个新的变量，不是对全局的a进行赋值
print('函数内部：a=', a) # 20
print('函数外部：a=', a) # 10
test1()
print('--------全局变量-global-----------')
a = 10 # 全局变量
# 如果你希望在函数的内部去修改全部变量的值，则需要使用global
def test1():
global a # 告诉解释器，这里的a是全局变量
a = 20 # 我希望这里不是局部变量，而是对全局变量重新赋值
print('函数内部：a=', a) # 20
test1() # 先调用，才会修改全部变量
print('函数外部：a=', a) # 20
函数的多种参数
[掌握]位置参数
位置参数指的是：调用函数时，根据函数定义的参数位置来传递数值。
位置参数语法:
def 函数名(参数1,参数2,...):
代码
...
函数名(值1,值2,...)说明：
当调用函数时，要按照定义函数时的参数位置，进行传递值。
例如，一起来完成：
（1）定义一个使用格式化符号替换数据，且显示姓名、年龄的函数；
（2）调用函数，展示形成【个人名片】的样式。
print('-----------1、位置参数-------------------')
def show_infos(name, age):
print("========================")
print("显示个人信息如下:")
print("姓名:%s" % name)
print("年龄:%d" % age)
print("========================")
# 位置参数，实参会按照先后顺序依次的传递给形参
show_infos('刘备', 18)
[掌握]关键字参数
关键字参数指的是：调用函数时，可以通过【键 = 值】的形式指定参数。
使用关键字参数后，可以让函数更加清晰、容易使用，同时也简化了传递参数的要求，比如不需要关注参数的个数、类型和顺序。
关键字参数语法:
def 函数名(参数1,参数2,...):
代码
...函数名(参数1=值, 参数2=值,...)
说明：调用函数时，参数名必须要与定义函数时的名称保持一致。
（1）定义一个函数，用于显示个人名片的姓名、年龄、性别等信息；
（2）当调用函数时，使用关键字参数的形式传递值。
# import pymysql
#
# pymysql.connect()
# 1.定义显示个人信息的函数
def show_infos(name, age, sex):
print("个人信息如下:")
print(f"姓名:{name}")
print(f"年龄:{age}")
print(f"性别:{sex}")
# 2.调用
show_infos(age=24,name="张三",sex="女")
# show_infos(age=24,name="张三",gender="女") # 报错==总结：==
（1）当传递关键字参数时，可以使用【键 = 值】形式来指定参数；
[掌握]缺省参数
==目标：==掌握缺省参数的使用。
有时候，缺省参数也叫默认参数。
缺省参数是指：在定义函数时，就为参数提供默认值。
与此同时，在调用函数时，就可以不用传递默认参数的值。当然了，如果给缺省参数传递了数值，则以传递的值为准。
缺省参数语法：
def 函数名(参数1,参数2,...,参数n=值):
代码
...函数名(值1,值2,...[值n])
例子:
（1）定义一个显示姓名、年龄、性别的函数，且默认性别为男；
（2）调用函数，观察程序执行结果；
（3）思考1：可以定义多个缺省参数吗？
（4）思考2：能否把缺省参数放在前面呢？
# 1.定义缺省参数
def show_infos(name,age,sex="男"):
print("个人信息如下:")
print(f"姓名:{name}")
print(f"年龄:{age}")
print(f"性别:{sex}")
# 2.调用
show_infos("冯相荣",18,"Male")
show_infos("冯相荣",18)
# 3.可以定义多个缺省参数
# def show_infos(name,age=0,sex="男"):
# print("个人信息如下:")
# print(f"姓名:{name}")
# print(f"年龄:{age}")
# print(f"性别:{sex}")
# 4.能否放在前面?
# def show_infos(sex="男",name,age): # 报错: 默认参数应该放在末尾
# print("个人信息如下:")
# print(f"姓名:{name}")
# print(f"年龄:{age}")
# print(f"性别:{sex}")==总结：==
（1）若给函数定义了缺省参数，则在调用函数时可以省略该参数值的传递；
[掌握]不定长参数
==目标：==掌握不定长参数的使用。
有时候，不定长参数也叫可变参数。
通常情况下，不定长参数用于在不确定调用函数时，要传递多少个参数的场景，当然也可以不传递参数。
而当要调用函数时，可以给*args传递位置参数，给**kwargs传递关键字参数，这样显得更加方便。
不定长参数语法：
def 函数名(参数1,..,*args,**kwargs):
代码
...
函数名(值1, 值2, 值3, ... 参数1=值, 参数2=值,...)
例如，一起来完成：
（1）定义函数1，使用不定长参数*args求多个数之和；
（2）定义函数2，使用不定长参数**kwargs求多个数之和；
（3）综合两个函数，合并在一起完成求多个数之和；
（4）执行程序，观察效果。
# 1.函数1 *args 元组
# def get_sum1(*args):
# # print(args)
# # 和
# sum1 = 0
# # 求和
# for temp in args:
# sum1 += temp
# print(f"多个数之和为:{sum1}")
#
# get_sum1(1,2)
# 2.函数2 **kwargs 字典
# def get_sum2(**kwargs):
# # print(kwargs)
# # 和
# sum2 = 0
# # 求和
# for value in kwargs.values():
# sum2 += value
# print(f"多个数之和为:{sum2}")
#
# get_sum2(a=2,b=24)
# 3.函数3
def get_sum(*args, **kwargs):
result = 0
sum1 = 0
# 求和
for temp in args:
sum1 += temp
sum2 = 0
# 求和
for value in kwargs.values():
sum2 += value
result = sum1 + sum2
print(f"多个数之和为:{result}")
get_sum(10,29,45,67,89,a=10,b=1099834)说明:
当给不定长参数传递数值时，可以理解为：就是综合运用位置参数和关键字参数来传值。
拆包和交换变量值
Python程序中的拆包：把组合形成的元组形式的数据，拆分出单个元素内容。
变量名1,变量名2,... = 结果
例如，一起来完成：
（1）在一个函数中，使用return返回求解两个数的和、差；
（2）使用items()方式遍历处理字典中存储的学生信息各个键与值；
（3）分别使用拆包方式来拆分数据。
# 1.定义函数, 返回多个数据
# def get_sum_sub(a, b):
# sum = a + b
# sub = a - b
# return sum,sub
# result = get_sum_sub(560,89)
# print(result) # (649, 471)
# result[0]
# result[1]
# ret1, ret2 = get_sum_sub(560,89)
# print(f"和为:{ret1}")
# print(f"差为:{ret2}")
# 2.items()处理
student = {"name": "马云", "age": 28, "gender": "男"}
# for item in student.items():
# # print(item) # ('name', '马云')
# key = item[0]
# value = item[1]
# for (key,value) in student.items():
for key,value in student.items():
print(f"{key} --> {value}")==总结：==
（1）当要把一个组合的结果快速获取元素数据时，可以使用拆包来完成；
（2）注意：对列表、元组数据结果，都可以使用拆包方式。
[掌握]交换变量值
使用拆包方式可以用于交换变量的值。
例如，一起来完成：
（1）有变量a、b，请完成变量之间值的交换；
（2）使用引入第三方变量的形式完成数值的交换；
（3）使用拆包方式完成数值交换。
# 1.拆包 -互换两个数位置
a = 10
b = 98
b, a = (a,b)
print(f"变量a={a}, b={b}")
# (a,b) = (b,a)
# 2.求最大最小值
# data = [12,3,14,56,7,0,1,-199]
# data = [12,3,14,56,7,100,1,199]
# # 1.先入为主; 2.简化操作
# # 最大值
# max_value = data[0]
# # 最小值
# min_value = data[0]
# # min_value = 0
# for temp in data:
# if max_value < temp:
# max_value = temp
# if min_value > temp:
# min_value = temp
# print(f"最大值:{max_value}")
# print(f"最小值:{min_value}")==总结：==
（1）交换两个变量的方式较多，但最简单的是：直接使用拆包方式交换值。
扫一扫
625
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
