5 函数 function

5.1 pycharm快捷键

Ctrl + P 参数信息（在方法中调用参数）
Ctrl + Q 快速查看文档

5.2 定义

(1) 用于封装一个特定的功能，表示一个功能或者行为。
(2) 函数是可以重复执行的语句块, 可以重复调用。

5.3 作用

提高代码的可重用性和可维护性（代码层次结构更清晰）。

5.4 基础语法

5.4.1 定义函数

(1) 语法：
def 函数名(形式参数):
函数体

---

(2) 说明：
def 关键字：全称是define，意为”定义”。
函数名：对函数体中语句的描述，规则与变量名相同。
形式参数：函数定义者要求调用者提供的信息。
函数体：完成该功能的语句。

---

(3) 函数的第一行语句建议使用文档字符串描述函数的功能与参数。

# 形式参数：表面的不具体的数据
def attack(count):
"""
攻击
:param count:次数
"""
for __ in range(count):
print("直拳")
print("摆拳")
print("勾拳")

5.4.2 调用函数

(1) 语法：函数名(实际参数)
(2) 说明：根据形参传递内容。

# 实际参数：真实的具体的数据
attack(5)
attack(2)

练习1： 定义函数,在终端中打印一维列表.

list01 = [5, 546, 6, 56, 76, ]
for item in list01:
print(item)
list02 = [7,6,879,9,909,]
for item in list02:
print(item)

练习2：创建函数,在终端中打印矩形.

number = int(input("请输入整数:")) # 5
for row in range(number):
if row == 0 or row == number - 1:
print("*" * number)
else:
print("*%s*" % (" " * (number - 2)))

5.4.3 返回值

(1) 定义：
函数定义者告诉调用者的结果。

---

(2) 语法：
return 数据

---

(3) 说明：
return后没有语句，相当于返回 None。
函数体没有return，相当于返回None。

def func01():
print("func01执行了")
return 100
# 1. 调用者,可以接收也可以不接收返回值
func01()
res = func01()
print(res)
# 2.在Python语言中,
# 函数没有return或return后面没有数据,
# 都相当于return None
def func02():
print("func02执行了")
return
res = func02()
print(res) # None
# 3.return可以退出函数
def func03():
print("func03执行了")
return
print("func03又执行了")
func03()
# 4. return 可以退出多层循环嵌套
def func04():
while True:
while True:
while True:
# break 只能退出一层循环
print("循环体")
return
func04()

练习1：创建计算治愈比例的函数

confirmed = int(input("请输入确诊人数:"))
cure = int(input("请输入治愈人数:"))
cure_rate = cure / confirmed * 100
print("治愈比例为" + str(cure_rate) + "%")

练习2：定义函数,根据总两数,计算几斤零几两.:
提示：使用容器包装需要返回的多个数据

total_liang = int(input("请输入两:"))
jin = total_liang // 16
liang = total_liang % 16
print(str(jin) + "斤零" + str(liang) + "两")

练习3：创建函数,根据课程阶段计算课程名称

number = input("请输入课程阶段数：")
if number == "1":
print("Python语言核心编程")
elif number == "2":
print("Python高级软件技术")
elif number == "3":
print("Web全栈")
elif number == "4":
print("项目实战")
elif number == "5":
print("数据分析、人工智能")

练习4：创建函数,计算IQ等级

ma = int(input("请输入你的心里年龄："))
ca = int(input("请输入你的实际年龄："))
iq = ma / ca * 100
if 140 <= iq:
print("天才")
elif 120 <= iq:
print("超常")
elif 110 <= iq:
print("聪慧")
elif 90 <= iq:
print("正常")
elif 80 <= iq:
print("迟钝")
else:
print("低能")

练习5：创建函数,根据年龄计算人生阶段

age = int(input("请输入年龄："))
if age <= 6:
print("童年")
elif age <= 17: # 程序能执行到本行,说明age一定大于6
print("少年")
elif age <= 40:
print("青年")
elif age <= 65:
print("中年")
else:
print("老年")

练习6：定义函数，根据年月日计算是这一年的第几天.
 如果2月是闰年,则29天平年28

month = int(input("请输入月:"))
day = int(input("请输入日:"))
days_of_month = (31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
total_days = sum(days_of_month[:month - 1])
total_days += day
print(f"{month}月{day}日是第{total_days}天.")
year = int(input("请输入年份:"))
if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
day = 29
else:
day = 28

5.5 可变／不可变类型在传参时的区别

(1) 不可变类型参数有:
数值型(整数，浮点数)
布尔值bool
None 空值
字符串str
元组tuple

---

(2) 可变类型参数有:
列表 list
字典 dict
集合 set

---

(3) 传参说明：
不可变类型的数据传参时，函数内部不会改变原数据的值。
可变类型的数据传参时，函数内部可以改变原数据。

---

练习1：画出下列代码内存图，并写出打印结果。

def func01(p1, p2):
p1 = "孙悟空"
p2["八戒"] += 50
a = "悟空"
b = {"八戒": 100}
func01(a, b)
print(a) # ?
print(b) # ?

练习2：画出下列代码内存图，并写出打印结果

def func01(p1, p2):
p1 = [100, 200]
p2[:] = [300, 400]
a = [10, 20]
b = [30, 40]
func01(a, b)
print(a) # ?
print(b) # ?

练习3：根据下列代码，创建降序排列函数。

list01 = [5, 15, 25, 35, 1, 2]
for r in range(len(list01) - 1):
	for c in range(r + 1, len(list01)):
		if list01[r] < list01[c]:
		list01[r], list01[c] = list01[c], list01[r]
print(list01)

练习4：定义函数，将列表中大于某个值的元素设置为None
 参数 结果
[34, 545, 56, 7, 78, 8] -10-> [None,None,None,7,None,8]
[34, 545, 56, 7, 78, 8] -100-> [34, None, 56, 7, 78, 8]

5.6 函数参数

5.6.1 实参传递方式argument

5.6.1.1 位置传参

定义：实参与形参的位置依次对应。

def fun01(p1, p2, p3):
	print(p1)
	print(p2)
	print(p3)
# 位置实参:根据顺序与形参进行对应
fun01(1, 2, 3)

5.6.1.2 序列传参

定义：实参用*将序列拆解后与形参的位置依次对应。

def func01(p1, p2, p3):
	print(p1, p2, p3)
# 序列实参:拆,按照顺序与形参对应
list01 = [1, 2, 3]
name = "孙悟空"
tuple01 = (4, 5, 6)
# func01(list01)
func01(*list01) # 拆 1, 2, 3
func01(*name) # 拆 孙 悟 空
func01(*tuple01) # 拆 4, 5, 6

5.6.1.3 关键字传参

定义：实参根据形参的名字进行对应。

def fun01(p1, p2, p3):
	print(p1)
	print(p2)
	print(p3)
# 关键字实参:根据名字与形参进行对应
fun01(p1=1, p2=2, p3=3)
fun01(p2=2, p1=1, p3=3)

5.6.1.4 字典关键字传参

(1) 定义：实参用**将字典拆解后与形参的名字进行对应。
(2) 作用：配合形参的缺省参数，可以使调用者随意传参。

def func01(p1, p2, p3):
	print(p1, p2, p3)
# 字典实参:拆,按照名称与形参对应
dict01 = {"p2":"B","p1":"A","p3":"C"}
func01(**dict01)

5.6.2形参定义方式parameter

5.6.2.1 缺省形参

(1) 语法：
def 函数名(形参名1=默认实参1, 形参名2=默认实参2, ...):
 函数体

---

(2) 说明：
缺省参数必须自右至左依次存在，如果一个参数有缺省参数，则其右侧的所有参数都必须有缺省参数。

def func01(p1 =0, p2="", p3=100):
	print(p1)
	print(p2)
	print(p3)
func01(p2=2)
func01(p2=2,p3=3)
# 支持同时使用位置实参与关键字实参
func01(1,p3=3)
# 注意1:先位置实参,后关键字实参
# func01(p1 =1,2,3) # 错误

练习：
定义函数,根据小时、分钟、秒,计算总秒数
调用：提供小时、分钟、秒
调用：提供分钟、秒
调用：提供小时、秒
调用：提供分钟

5.6.2.2 位置形参

语法：
def 函数名(形参名1, 形参名2, ...):
函数体

5.6.2.3 命名关键字形参

(1) 语法：
def 函数名(*args, 命名关键字形参1, 命名关键字形参2, ...):
函数体
def 函数名(*, 命名关键字形参1, 命名关键字形参2, ...):
函数体

---

(2) 作用：
强制实参使用关键字传参

# 命名关键字形参:
# 星号元组形参后面的位置形参
# 限制实参必须是关键字实参
def func01(*args, p1, p2):
	print(args)
	print(p1)
	print(p2)
	
func01(p1=1, p2=2)
func01(1, 2, 3, p1=1, p2=2)

def func02(p1, *, p2=0):
	print(p1)
	print(p2)
# 通常星号后面的命名关键字形参属于辅助参数,可选.
func02(1)
func02(1, p2=2)

5.6.2.4 星号元组形参

(1) 语法：
def 函数名(*元组形参名):
函数体

---

(2) 作用：
可以将多个位置实参合并为一个元组

---

(3) 说明：
一般命名为'args'
形参列表中最多只能有一个

# 位置实参数量可以无限
def func01(*args):
	print(args)
	
func01() # 空元组
func01(1, 2, 34) # (1, 2, 34)
# 不支持关键字实参
# func01(args = 1,a=1)

练习：定义数值累乘的函数

5.6.2.5 双星号字典形参

(1) 语法：
def 函数名(**字典形参名):
函数体

---

(2) 作用：
可以将多个关键字实参合并为一个字典

---

(3) 说明:
一般命名为'kwargs'
形参列表中最多只能有一个

# 关键字实参数量无限
def func01(**kwargs):
	print(kwargs) # {'a': 1, 'b': 2}
	
func01(a=1,b=2)
# func01(1,2,3) # 报错

5.6.2.6 参数自左至右的顺序

位置形参 --> 星号元组形参 --> 命名关键字形参 --> 双星号字典形参

---

练习：说出程序执行结果.

def func01(list_target):
	print(list_target)# ?
	
def func02(*args):
	print(args)# ?
	
def func03(*args,**kwargs):
	print(args)# ?
	print(kwargs)# ?
def func04(p1,p2,*,p4,**kwargs):
	print(p1)# ?
	print(p2)# ?
	print(p4)# ?
	print(kwargs)# ?
func01([1,2,3])
func02(*[1,2,3])
func03(1,2,3,a=4,b=5,c=6)
func04(10,20,p4 = 30,p5 = 40)

5.7 作用域LEGB

5.7.1 定义

变量起作用的范围。

5.7.2 分类

(1) Local局部作用域：函数内部。
(2) Enclosing 外部嵌套作用域 ：函数嵌套。
(3) Global全局作用域：模块(.py文件)内部。
(4) Builtin内置模块作用域：builtins.py文件。

5.7.3 变量名的查找规则

(1) 由内到外：L -> E -> G -> B
(2) 在访问变量时，先查找本地变量，然后是包裹此函数外部的函数内部的变量，之后是全局变量，最后
是内置变量。

5.7.4 局部变量

(1) 定义在函数内部的变量(形参也是局部变量)
(2) 只能在函数内部使用
(3) 调用函数时才被创建，函数结束后自动销毁

5.7.5 全局变量

(1) 定义在函数外部,模块内部的变量。
(2) 在整个模块(py文件)范围内访问（但函数内不能将其直接赋值）。

5.7.6 global 语句

(1) 作用：
在函数内部修改全局变量。
在函数内部定义全局变量(全局声明)。

---

(2) 语法：
global 变量1, 变量2, …

---

(3) 说明
在函数内直接为全局变量赋值，视为创建新的局部变量。
不能先声明局部的变量，再用global声明为全局变量。

5.7.7 nonlocal 语句

(1) 作用：
在内层函数修改外层嵌套函数内的变量

---

(2) 语法
nonlocal 变量名1,变量名2, ...

---

(3) 说明
在被嵌套的内函数中进行使用

# 2. 全局作用域:文件内部
# 全局变量:在全部作用域内创建的变量
# 适用范围:整个文件
data02 = 20
data03 = [30]
def func01():
# 1. 局部作用域:函数内部
# 局部变量:在局部作用域内创建的变量
# 适用范围:一个函数
	data01 = 10
	print(data01)
	print(data02)
	
def func02():
	# print(data01) # 不能访问其他函数局部变量
	print(data02) # 读取全局变量
	
def func03():
	# 在局部作用域中不能修改全局变量
	# data02 = 200
	# 必须通过global语句声明
	global data02
	data02 = 200
	
def func04():
	# 没有修改全局变量
	# 在修改全局变量指向的列表
	# 所以不需要通过global语句声明
	data03[0] = 300
func01()
func02()
func03()
func04()
print(data02) # 200
print(data03) # [300]

练习：画出下列代码内存图

data01 = 10
def func01(p):
	global data01
	data01 += 1
	p += 1
	data02 = 10
func01(data02)
func01(data02)
print(data01) # ?
print(data02) # ?

练习：根据下列代码，创建函数

# 商品字典
dict_commodity_infos = {
1001: {"name": "屠龙刀", "price": 10000},
1002: {"name": "倚天剑", "price": 10000},
1003: {"name": "金箍棒", "price": 52100},
1004: {"name": "口罩", "price": 20},
1005: {"name": "酒精", "price": 30},
}
# 订单列表
list_orders = [
{"cid": 1001, "count": 1},
{"cid": 1002, "count": 3},
{"cid": 1005, "count": 2},
]
# 1.定义函数，打印所有商品信息,
for cid, info in dict_commodity_infos.items():
	print("商品编号%d,商品名称%s,商品单价%d." % (cid, info["name"],
info["price"]))

# 2. 定义函数，打印单价大于10000的商品信息,
for cid, info in dict_commodity_infos.items():
	if info["price"]>10000:
		print("商品编号%d,商品名称%s,商品单价%d." % (cid, info["name"],
info["price"]))

# 3. 定义函数，查找数量最多的订单(使用自定义算法,不使用内置函数)
max_value = list_orders[0]
for i in range(1, len(list_orders)):
	if max_value["count"] < list_orders[i]["count"]:
		max_value = list_orders[i]
print(max_value)

# 4. 定义函数，根据购买数量对订单列表降序(大->小)排列
for r in range(len(list_orders) - 1):
	for c in range(r + 1, len(list_orders)):
		if list_orders[r]["count"] < list_orders[c]["count"]:
		list_orders[r], list_orders[c] = list_orders[c], list_orders[r]
print(list_orders)