本文详细介绍了Python函数的定义、作用、内存分布、调用方式、形参与实参、返回值、参数类型区别以及作用域。通过示例阐述了位置实参、关键字实参、序列和字典实参的传递方式，并探讨了函数的局部和全局变量。最后总结了函数的应用，并提供了学习资源。
定义
用于封装一个特定的功能，表示一个功能或者行为
函数是可以重复执行的语句块, 可以重复调用。
分为制作函数和使用函数
作用
提高代码的可重用性和可维护性（代码层次结构更清晰）
定义函数
def 关键字：全称是define，意为”定义”
函数名：对函数体中语句的描述，规则与变量名相同。
形式参数：方法定义者要求调用者提供的信息。
函数体：完成该功能的语句
"""
函数 - 功能
价值1：减少代码的重复
制作
def 函数名称():
函数体
使用
函数名称()
将共性行为提取到函数中,将数据的变化作为参数。
"""
# 做
def attack():
print("摆拳")
print("勾拳")
print("侧踹")
print("正蹬")
print("直拳")
print("发大招")
# 用
attack()
attack()函数内存分布
"""
1. 传入可变对象
2. 修改可变对象
3. 函数外可以得到结果(不用return)
"""
# 将函数的代码存储到代码区中
def func01(p1, p2):
p1[0] = 100
p2 = 200
list01 = [10]
list02 = [20]
# 调用函数在内存中开辟一块空间(栈帧),
# 用于存储在函数中创建的变量
func01(list01, list02)
# 函数执行后栈帧释放
print(list01[0]) # 100
print(list02[0]) # 20
调用函数
形参
形参是指形式上的参数，在未赋值时时没有实际值的，在函数中的形式可以理解为一个变量：形参的作用是以变量的形式来传递当前未知的值。
实参
实参是指有具体值得参数，可以是字符串或数字。以赋值方式在调用时修改实参传递值。
"""
函数 - 功能
参数：调用函数 给 制作函数 传递的信息
"""
# 做
def single_attack():
print("摆拳")
print("勾拳")
print("侧踹")
print("正蹬")
print("直拳")
print("发大招")
# 形式参数
def multiple_attacks(count):
# count = 10
for __ in range(count):
print("摆拳")
print("勾拳")
print("侧踹")
print("正蹬")
print("直拳")
print("发大招")
# 用
# 实际参数
multiple_attacks(10)
multiple_attacks(3)
函数执行、调用的顺序
程序自生而下运行
创建函数的代码要先加载到内存中
再去调用函数
# --------------创建(定义)函数-------------------
def single_attack():
print("摆拳")# 3
print("勾拳")
print("侧踹")
print("正蹬")
print("直拳")
print("发大招")
def multiple_attacks(count):
# count = 10
for __ in range(count):# 2
single_attack()
# --------------调用(使用)函数-------------------
multiple_attacks(2) # 1
multiple_attacks(5) # 1返回值
返回单个的值
"""
函数 -- 返回值 语法
制作函数 给 使用函数 传递的信息
def 函数名():
函数体
return 数据 # 返回 结果
变量名 = 函数名()
"""
# 做
def func01():
print("func01执行喽")
return 10 # return 数据 返回 结果
# 用
result = func01()
print("函数的返回值是:%d" % result)
# 如果函数没有return,相当于return None
# 如果函数return后面没有数据,也相当于return None
def func02():
print("func01执行喽")
# return None
return
result = func02()
print(result)
返回多个值
#return返回多个值的时候，需要用元组（tuple）来接收数据
def calculate_weight(amount):
"""
计算重量
:param amount: 总两数
:return: 元组类型,斤两
"""
jin = amount // 16
liang = amount % 16
return jin, liang
result = calculate_weight(100)
print(type(result))
print(result)返回值：如果满足条件,不会执行return "课程不存在"
def get_course_name(number):
"""
:param number:
:return:
"""
list_course_name = [
"Python语言核心编程",
"Python高级软件技术",
"Web全栈",
"网络爬虫",
"数据分析、人工智能"
]
# if 1<= number <= len(list_course_name):
# return list_course_name[number - 1]
# else:
# return "课程不存在"
if 1 <= number <= len(list_course_name):
return list_course_name[number - 1]
return "课程不存在"
name = get_course_name(2)
print(name) # Python语言核心编程可变/不可变类型传参时的区别
不可变类型参数有:
数值型(整数，浮点数)
布尔值bool
None 空值
字符串str
元组tuple
可变类型参数有：
列表 list
字典 dict
集合 set
函数的作用域
局部变量和全局变量
"""
作用域
局部作用域：函数内部有效
全局作用域：整个文件有效
小范围(一个函数)使用局部变量
大范围(多个函数)使用全局变量
"""
# ------------全局作用域：整个文件有效------------
b = 200
# ------------函数------------
def func01():
# 局部作用域：函数内部有效
a = 100
print(a)
def func02():
# 局部可以访问全局
print(b)
# ------------调用(入口)------------
func01()
func02()
print(b)局部变量更改全局变量
a = 100
def func01():
# 不能修改全局变量
# a = 200 # (创建了新的局部变量)
# 如果局部作用域修改全局变量：必须声明变量
global a
a = 200 # 修改全局
func01()
print(a)
函数参数
参数的顺序
位置形参 --> 星号元组形参 --> 命名关键字形参 --> 双星号字典形参
def func01(*args, **kwargs): # 实参数量无限
print(args)
print(kwargs)
func01()
func01(1, 2, a=1, b=2)
# p1:位置形参:必填
# p2:位置形参+默认形参:可选
# args:星号元组形参：位置实参数量无限
# p3:命名关键字形参+默认形参:关键字实参(可选)
# kwargs:双星号字典形参：关键字实参数量无限
def func02(p1, p2="", *args, p3=0, **kwargs):
print(p1)
print(p2)
print(args)
print(p3)
print(kwargs)
func02(1,2,3,4,5,p3 = 3,a=1,b=2)
func02(1)实参传递方式：与形参进行对应
位置实参：
实参与形参的位置依次对应
关键字实参
实参根据形参的名字进行对应
"""
函数参数
实际参数
1. 位置实参:实参按照位置与形参进行对应
2. 关键字实参：实参按照名称与形参进行对应
"""
def func01(p1, p2, p3):
"""
我是函数
:param p1: 我的第一个参数
:param p2:
:param p3:
:return:
"""
print(p1)
print(p2)
print(p3)
# ctrl + p 查看参数
# ctrl + q 查看文档
func01(1, 2, 3)
func01(p1=1, p2=2, p3=3)序列实参
实参用*将序列拆解后与形参的位置依次对应
字典实参
实参用**将字典拆解后与形参的名字进行对应
配合形参的缺省参数，可以使调用者随意传参
def func01(p1, p2, p3):
print(p1)
print(p2)
print(p3)
list01 = [1, 2, 3]
str02 = "123"
tuple03 = (1, 2, 3)
func01(*list01) # 拆
dict04 = {"p1": 1, "p2": 2, "p3": 3}
func01(**dict04)形参传递方式：约束实参
默认形参：实参可选
缺省参数必须自右至左依次存在，如果一个参数有缺省参数，则其右侧的所有参数都必须有缺省参数
缺省参数可以有0个或多个，甚至全部都有缺省参数
"""
函数参数
形式参数
默认形参：实参可选
"""
# 注意：必须从右到左依次存在
def func01(p1= "", p2 = 0, p3 = 1):
print(p1)
print(p2)
print(p3)
# 全部传递
func01(1, 2)
# 指定某一个形参
func01(p2=2)
func01(1, p3=3)位置形参
# 1. 位置形参：实参必填
def func01(p1, p2, p3):
print(p1)
print(p2)
print(p3)
func01(1, 2, 3)不定长形参
可以将多个位置实参合并为一个元组
一般命名为'args'
形参列表中最多只能有一个
def func01(p1, p2, p3):
print(p1)
print(p2)
print(p3)
func01(1, 2, 3)
# 2. 星号元组形参：将位置实参合并为元组
# 注意1：形参中只有一个
# 注意2：只支持位置实参
def func02(*args):
print(args)
# 练习：定义多个数值累乘的函数
def multiply(*args):
sum = 1
for number in args:
sum *= number
return sum
print(multiply())
print(multiply(12, 3, 342, 35, 6, 75, 8))命名关键字形参
# 3. p1, p2 是命名关键字形参:
# 限制实参必须是关键字实参
def func03(*args, p1, p2):
print(args)
func03(1, 2, 3, 4, 5, p1=1, p2=2)
# p1 是必填的信息
# p2 是可选的信息
def func04(p1, *, p2=0):
print(p1)
print(p2)
func04(1, p2=2)
# print(10,20,30,end = " ")
print(10, 20, 30, sep="------")
print(10, 20, 30, sep="------", end=" ")
# 如果木有命名关键字形参的技术
# 下列代码可读性非常差的写法,就不能避免了.
# print(10,20,30,"------"," ")双星号字典形参
可以将多个关键字实参合并为一个字典
一般命名为'kwargs'
形参列表中最多只能有一个
# 4. 双星号字典形参：关键字实参数量无限
def func04(**kwargs):
print(kwargs)
func04()
func04(a=1, b=2, c=3)
函数总结
函数参数 - 总结
实际参数：对应
1.位置实参：顺序
函数名(数据1,数据2,数据3)
3. 序列实参：拆
函数名(*序列)
2.关键字实参：名字
函数名(参数名2=数据2)
4. 字典实参：拆
函数名(**字典)
形式参数：约束
1. 默认形参：可选
def 函数名(参数名1 = 数据1,参数名2=数据2)
2. 位置形参：必填
def 函数名(参数名1,参数名2,参数名3)
3. 命名关键字形参：必须是关键字实参
def 函数名(*,参数名1,参数名2)
def 函数名(*args,参数名1,参数名2)
4. 不定长形参：长度无限
4.1 星号元组形参：合并位置实参
def 函数名(*args)
4.2 双星号字典形参：合并关键字实参
def 函数名(**kwargs)
函数的应用
学习的链接
https://docs.python.org/zh-cn/3/
https://www.runoob.com/python3/python3-tutorial.html
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
