先来两个问答:
1、函数到底是个什么东西?
答:函数,可以当做是一大堆功能代码的集合。
2、什么时候会用到函数?
答:有重复代码,用函数增加代码的重用性。
代码太长,用函数增强代码的可读性。
知道什么是函数与为什么用函数之后,他有两个重要的特性,那就是参数与返回值,接下来介绍他的参数与返回值
1、函数参数
在定义函数时,如果在括号中添加变量
,我们称它为函数的形式参数:
1.1 形参
定义有三个参数的函数(a1/a2/a3一般称为形式参数-形参)
def func(a1, a2, a3):
print(a1 + a2 + a3)
1.2 实参
执行函数并传入参数(执行函数传值时一般称为实际参数-实参)
func(11, 22, 33)
1.3 位置传参
def add(n1,n2):
print(n1+n2)
add(1,22)
1.4 关键字传参
def add(n1,n2):
print(n1+n2)
add(n1=1,n2=22)
下面通过一个整体举例说明一下上述四个名词
"""
1. 形参
2. 实参
3. 位置传参
4. 关键字传参
"""
# 定义有三个参数的函数(a1,a2,a3一般称为形式参数-形参)
def func(a1, a2, a3):
print(a1 + a2 + a3)
# 执行函数并传入参数(执行函数传值时一般称为实际参数-实参)
func(11, 22, 33)
# 执行函数并传入位置参数
func(9, 2, 103)
# 执行函数并传入关键字参数
func(a1=99, a2=88, a3=1)
func(a1=99, a3=1, a2=88)
2、函数默认参数
在定义函数的时候,有些参数会赋值一些默认值,这类赋值参数为默认参数。
如果在函数执行的时候没有给赋值的参数进行传参的话,会默认使用这个参数的默认值。
如果执行函数的时候传输给赋值参数一个值的话,会代替默认值来进行执行。
举例说明:
def func(a1, a2, a3=10):
print(a1 + a2 + a3)
# 位置传参
func(8, 19)
func(1, 2, 99)
# 关键字传参()
func(a1=12, a2=9, a3=90)
# 位置和关键混合时,关键字传参要在后面
func(12, 9, a3=90)
func(12, a2=9, a3=90)
来一个面试题:
def func(a1,a2=18):
print(a1,a2)
原理:Python在创建函数(未执行)时,如果发现函数的参数中有默认值,则在函数内部会创建一块区域并维护这个默认值。
- 执行函数未传值时,则让a2指向 函数维护的那个值的地址。 eg: func("root")
- 执行函数传值时,则让a2指向新传入的值的地址。 eg: func("admin",20)
在特定情况【默认参数的值是可变类型 list/dict/set】 & 【函数内部会修改这个值】下,参数的默认值 有坑 。
小坑:(示例中的地址为假设地址)
# 在函数内存中会维护一块区域存储 [1,2,666,666,666] 100010001
def func(a1,a2=[1,2]):
a2.append(666)
print(a1,a2)
# a1=100
# a2 -> 100010001
func(100) # 100 [1,2,666]
# a1=200
# a2 -> 100010001
func(200) # 200 [1,2,666,666]
# a1=99
# a2 -> 1111111101
func(99,[77,88]) # 66 [177,88,666]
# a1=300
# a2 -> 100010001
func(300) # 300 [1,2,666,666,666]
大坑:(示例中的地址为假设地址)
# 在内部会维护一块区域存储 [1, 2, 10, 20,40 ] ,内存地址 1010101010
def func(a1, a2=[1, 2]):
a2.append(a1)
return a2
# a1=10
# a2 -> 1010101010
# v1 -> 1010101010
v1 = func(10)
print(v1) # [1, 2, 10]
# a1=20
# a2 -> 1010101010
# v2 -> 1010101010
v2 = func(20)
print(v2) # [1, 2, 10, 20 ]
# a1=30
# a2 -> 11111111111 [11, 22,30]
# v3 -> 11111111111
v3 = func(30, [11, 22])
print(v3) # [11, 22,30]
# a1=40
# a2 -> 1010101010
# v4 -> 1010101010
v4 = func(40)
print(v4) # [1, 2, 10, 20,40 ]
深坑:(示例中的地址为假设地址)
# 内存中创建空间存储 [1, 2, 10, 20, 40] 地址:1010101010
def func(a1, a2=[1, 2]):
a2.append(a1)
return a2
# a1=10
# a2 -> 1010101010
# v1 -> 1010101010
v1 = func(10)
# a1=20
# a2 -> 1010101010
# v2 -> 1010101010
v2 = func(20)
# a1=30
# a2 -> 11111111111 [11,22,30]
# v3 -> 11111111111
v3 = func(30, [11, 22])
# a1=40
# a2 -> 1010101010
# v4 -> 1010101010
v4 = func(40)
print(v1) # [1, 2, 10, 20, 40]
print(v2) # [1, 2, 10, 20, 40]
print(v3) # [11,22,30]
print(v4) # [1, 2, 10, 20, 40]
3、函数动态参数
3.1 *
def func(*args):
print(args) # 元组类型 (22,) (22,33,99,) ()
# 只能按照位置传参
func(22)
func(22,33)
func(22,33,99)
func()
3.2 **
def func(**kwargs):
print(kwargs) # 字典类型 {"n1":"HQSS"} {"n1":"HQSS","age":"18","email":"HQSS@HQSS.COM"} {}
# 只能按关键字传参
func(n1="HQSS")
func(n1="HQSS",age=18)
func(n1="HQSS",age=18,email="xx@live.com")
3.3 *,**
def func(*args,**kwargs):
print(args,kwargs) # (22,33,99) {}
func(22,33,99)
func(n1="HQSS",age=18)
func(22,33,99,n1="HQSS",age=18)
func()
3.4 动参数的使用
1)动态参数,定义函数时在形参位置用 *或**
可以接任意个参数。
def func(*args,**kwargs):
print(args,kwargs)
func("宝强","杰伦",n1="alex",n2="eric")
2)在定义函数时可以用 *和**
,其实在执行函数时,也可以用。
- 形参固定,实参用
*和**
def func(a1,a2):
print(a1,a2)
func( 11, 22 )
func( a1=1, a2=2 )
func( *[11,22] )
func( **{"a1":11,"a2":22} )
- 形参用
*和**
,实参也用*和**
def func(*args,**kwargs):
print(args,kwargs)
func( 11, 22 )
func( 11, 22, name="武沛齐", age=18 )
# 小坑,([11,22,33], {"k1":1,"k2":2}), {}
func( [11,22,33], {"k1":1,"k2":2} )
# args=(11,22,33),kwargs={"k1":1,"k2":2}
func( *[11,22,33], **{"k1":1,"k2":2} )
# 值得注意:按照这个方式将数据传递给args和kwargs时,数据是会重新拷贝一份的(可理解为内部循环每个元素并设置到args和kwargs中)。
所以,在使用format字符串格式化时,可以可以这样:
v1 = "我是{},年龄:{}。".format("华青水上",18)
v2 = "我是{name},年龄:{age}。".format(name="华青水上",age=18)
v3 = "我是{},年龄:{}。".format(*["华青水上",18])
v4 = "我是{name},年龄:{age}。".format(**{"name":"华青水上","age":18})
注意事项
# 1. ** 必须放在 * 的后面
def func1(*args, **kwargs):
print(args, **kwargs)
# 2. 参数和动态参数混合时,动态参数只能放在最后。
def func2(a1, a2, a3, *args, **kwargs):
print(a1, a2, a3, args, **kwargs)
# 3. 默认值参数和动态参数同时存在
def func3(a1, a2, a3, a4=10, *args, a5=20, **kwargs):
print(a1, a2, a3, a4, a5, args, kwargs)
func3(11, 22, 33, 44, 55, 66, 77, a5=10, a10=123)
3.4 函数传参的秘密
在这之前可以先了解一个Python内置函数——查看某个值在内存中的地址——id(value)
v1 = [11,22,33]
v2 = [11,22,33]
print( id(v1) ) # 2212367673480
print( id(v2) ) # 2212367670664
v3 = 123
v4 = 123
print( id(v3) ) # 140718573518912
print( id(v4) ) # 140718573518912
记住一句话:函数执行传参时,传递的是内存地址。
def func(data):
print(data, id(data)) # "HQSS" 2212366897008
v1 = "HQSS"
print(id(v1)) # 2212366897008
func(v1)
上述事例要说明的是将变量v1传进函数func(data)的时候变量v1与函数变量data的内存地址是一样的。说明函数执行传参时,传递的是内存地址。
Python参数的这一特性有两个好处:
- 节省内存
- 对于可变类型且函数中修改元素的内容,所有的地方都会修改。可变类型:列表、字典、集合。
# 可变类型 & 修改内部修改
def func(data):
data.append(999)
v1 = [11,22,33]
func(v1)
print(v1) # [11,22,33,666]
# 特殊情况:可变类型 & 重新赋值
def func(data):
data = [HQSS","华青水上"]
v1 = [11,22,33]
func(v1)
print(v1) # [11,22,33]
# 特殊情况:不可变类型,无法修改内部元素,只能重新赋值。
def func(data):
data = "HQSS"
v1 = "华青水上"
func(v1)
注:其他很多编程语言执行函数时,默认传参时会将数据重新拷贝一份,会浪费内存。
提示注意:其他语言也可以通过 ref 等关键字来实现传递内存地址。
问:如果你不想让外部的变量和函数内部参数的变量一致 ,怎么办?
答:可以选择将外部值拷贝一份,再传给函数。如下示例:
import copy
# 可变类型 & 修改内部修改
def func(data):
data.append(999)
v1 = [11, 22, 33]
new_v1 = copy.deepcopy(v1) # 拷贝一份数据
func(new_v1)
print(v1) # [11,22,33]
4、函数返回值
4.1 函数返回值的常见情况。
在发过程中,我们希望函数可以帮助我们实现某个功能,但让函数实现某功能之后有时也需要有一些结果需要反馈给我们 ,这时候给函数一个返回值就可以实现了。
def magic(num):
result = num + 1000
return result
data = magic(9)
print(data) # 1009
返回值的3个关键知识 点:
1. 返回值可以是任意类型,如果函数中没写return,则默认返回None
def func():
return [1,True,(11,22,33)]
result = func()
print(result) # None
注意点:当在函数中未写返回值
或 return
或 return None
,执行函数获取的返回值都是None。
def func():
value = 1 + 1
return # 或 return None
ret = func()
print(ret) # None
2. return后面的值如果有逗号,则默认会将返回值转换成元组再返回。
def func():
return 1,2,3
value = func()
print(value) # (1,2,3)
3. 函数一旦遇到return就会立即退出函数(终止函数中的所有代码)
def func():
print(1)
for i in range(10):
print(i)
return 999
print(2)
result = func()
print(result)
# 输出
1
0
999
4.2 函数的返回值的秘密
问:函数传参的时候,传输的是变量地址,那么函数返回值返回的是值还是地址?
答:当然还是地址咯!
举个荔枝:
def func():
data = [11, 22, 33]
return data
v1 = func()
print(v1) # [11,22,33]
分析一下执行过程:
上述代码的执行过程:
- 执行func函数
data = [11, 22, 33]
创建一块内存区域,内部存储[11,22,33]
,data变量指向这块内存地址。return data
返回data指向的内存地址- v1接收返回值,所以 v1 和 data 都指向
[11,22,33]
的内存地址(两个变量指向此内存,引用计数器为2)- 由函数执行完毕之后,函数内部的变量都会被释放。(即:删除data变量,内存地址的引用计数器-1)
所以,最终v1指向的函数内部创建的那块内存地址。
再来个荔枝:
def func():
data = [11, 22, 33]
return data
v1 = func()
print(v1) # [11,22,33]
v2 = func()
print(v2) # [11,22,33]
分析一下执行过程:
上述代码的执行过程:
- 执行func函数
data = [11, 22, 33]
创建一块内存区域,内部存储[11,22,33]
,data变量指向这块内存地址 1000001110。return data
返回data指向的内存地址- v1接收返回值,所以 v1 和 data 都指向
[11,22,33]
的内存地址(两个变量指向此内存,引用计数器为2)- 由函数执行完毕之后,函数内部的变量都会被释放。(即:删除data变量,内存地址的引用计数器-1)
- 所以,最终v1指向的函数内部创建的那块内存地址。(v1指向的1000001110内存地址)
- 执行func函数
data = [11, 22, 33]
创建一块内存区域,内部存储[11,22,33]
,data变量指向这块内存地址 11111001110。return data
返回data指向的内存地址- v2接收返回值,所以 v1 和 data 都指向
[11,22,33]
的内存地址(两个变量指向此内存,引用计数器为2)- 由函数执行完毕之后,函数内部的变量都会被释放。(即:删除data变量,内存地址的引用计数器-1)
所以,最终v1指向的函数内部创建的那块内存地址。(v1指向的11111001110内存地址)
以上就是函数的参数与返回值的总结,如有不当之处,欢迎批评指正。