Python基础——函数基础之参数与返回值

先来两个问答：

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)

下面通过一个整体举例说明一下上述四个名词

扫描二维码关注公众号，回复： 15663567 查看本文章

"""
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":"[email protected]"}  {}
    
# 只能按关键字传参
func(n1="HQSS")
func(n1="HQSS",age=18)
func(n1="HQSS",age=18,email="[email protected]")

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内存地址)

以上就是函数的参数与返回值的总结，如有不当之处，欢迎批评指正。