Python-函数参数、返回值

1、函数参数

函数在定义是要定义好形式参数，调用时也提供足够的实际参数，一般来说，形参和实参个数要一致（可变参数除外）。

2、实参传参方式

2.1、位置传参

定义时def f(x, y, z)， 调用使用 f(1, 3, 5)，按照参数定义顺序传入实参

2.2、关键字传参

定义时def f(x, y, z)，调用使用 f(x=1, y=3, z=5)，使用形参的名字来传入实参的方式，如果使用了形参名
字，那么传参顺序就可和定义顺序不同
要求位置参数必须在关键字参数之前传入，位置参数是按位置对应的

2.3、示例

def add(x, y):
    print(x)
    print(y)
    print('-' * 30)

add(4, 5)
add(5, 4) # 按顺序对应，反过来x和y值就不同

add(x=[4], y=(5,))
add(y=5.1, x=4.2) # 关键字传参，按名字对应，无所谓顺序

add(4, y=5) # 正确
add(y=5, 4) # 错误传参

3、形参缺省值

3.1、作用

缺省值也称为默认值，可以在函数定义时，为形参增加一个缺省值。其作用：

参数的默认值可以在未传入足够的实参的时候，对没有给定的参数赋值为默认值
参数非常多的时候，并不需要用户每次都输入所有的参数，简化函数调用

3.2、示例

3.2.1、函数的缺省调用

def add(x=4, y=5):
    return x+y
测试调用 add()、add(x=5)、add(y=7)、add(6, 10)、add(6, y=7)、add(x=5, y=6)、
add(y=5, x=6)、add(x=5, 6)、add(y=8, 4)、add(11, x=20)

能否这样定义 def add(x, y=5) 或 def add(x=4,y) ？ 这种是错误的

3.2.2、定义一个函数login，参数名称为host、port、username、password

def login(host='localhost', port=3306, username='root', password='root'):
    print('mysql://{2}:{3}@{0}:{1}/'.format(host, port, username, password))
login()
login('127.0.0.1')
login('127.0.0.1', 3361, 'wayne', 'wayne')
login('127.0.0.1', username='wayne')
login(username='wayne', password='wayne', host='www.magedu.com')

4、可变参数

4.1、有可变与没有可变的对比

4.1.1、没有可变：写一个函数，可以对多个数累加求和

def sum(iterable):
    s = 0
    for x in iterable:
        s += x
    return s
print(sum([1,3,5]))
print(sum(range(4)))

4.1.2、可变：写一个函数，可以对多个数累加求和

def sum(*nums):
    sum = 0
    for x in nums:
        sum += x
    return sum

print(sum(1, 3, 5))
print(sum(1, 2, 3))

4.2、可变位置参数：*args

在形参前使用 * 表示该形参是可变位置参数，可以接受多个实参
它将收集来的实参组织到一个tuple中

4.3、可变关键字参数：**kwargs

4.3.1、语法

在形参前使用 ** 表示该形参是可变关键字参数，可以接受多个关键字参数
它将收集来的实参的名称和值，组织到一个dict中

4.3.2、示例

def showconfig(**kwargs):
    for k,v in kwargs.items():
        print('{}={}'.format(k,v), end=', ')
showconfig(host='127.0.0.1', port=8080, username='wa', password='edu')

4.4、混合使用

可以定义为下列方式吗？
def showconfig(username, password, **kwargs) # 可以
def showconfig(username, *args, **kwargs) # 可以
def showconfig(username, password, **kwargs, *args) # 不可以

4.5、示例判断

def fn(x, y, *args, **kwargs):
    print(x, y, args, kwargs, sep='\n', end='\n\n')
fn(3, 5, 7, 9, 10, a=1, b='abc')
fn(3, 5)
fn(3, 5, 7)
fn(3, 5, a=1, b='abc')
fn(x=1, y=2, z=3)
fn(x=3, y=8, 7, 9, a=1, b='abc') # 错在位置传参必须在关键字传参之前
fn(7, 9, y=5, x=3, a=1, b='abc') # 错在7和9已经按照位置传参了，x=3、y=5有重复传参了

4.6、总结

有可变位置参数和可变关键字参数
可变位置参数在形参前使用一个星号*
可变关键字参数在形参前使用两个星号**
可变位置参数和可变关键字参数都可以收集若干个实参，可变位置参数收集形成一个tuple，可变
关键字参数收集形成一个dict
混合使用参数的时候，普通参数需要放到参数列表前面，可变参数要放到参数列表的后面，可变位
置参数需要在可变关键字参数之前

5、keyword-only参数

5.1、引入代码示例

def fn(*args, x, y, **kwargs):
    print(x, y, args, kwargs, sep='\n', end='\n\n')
# fn(3, 5) # 报错
# fn(3, 5, 7) #  报错
# fn(3, 5, a=1, b='abc') # 报错
fn(3, 5, y=6, x=7, a=1, b='abc') # 正常

5.2、keyword-only参数语法

5.2.1、语法

在Python3之后，新增了keyword-only参数。
keyword-only参数：在形参定义时，在一个*星号之后，或一个可变位置参数之后，出现的普通参数，就已经不是普通的参数了，称为keyword-only参数。

5.2.2、示例

def fn(*args, x):
    print(x, args, sep='\n', end='\n\n')
# fn(3, 5) # 报错
# fn(3, 5, 7) # 报错
fn(3, 5, x=7)

# 7
# (3, 5)

# keyword-only参数，言下之意就是这个参数必须采用关键字传参。
# 可以认为，上例中，args可变位置参数已经截获了所有位置参数，其后的变量x不可能通过位置传参传入了。

5.3、def fn(**kwargs, x) 可以吗？

def fn(**kwargs, x):
    print(x, kwargs, sep='\n', end='\n\n')
    
直接语法错误了。
可以认为，kwargs会截获所有关键字传参，就算写了x=5，x也没有机会得到这个值，所以这种语法不存在。

5.4、keyword-only参数另一种形式

# * 星号后所有的普通参数都成了keyword-only参数。
def fn(*, x, y):
    print(x, y)
fn(x=6, y=7)
fn(y=8, x=9)

6、Positional-only参数

# Python 3.8 开始，增加了最后一种形参类型的定义：Positional-only参数。（2019年10月发布3.8.0）
def fn(a, /):
    print(a, sep='\n')
fn(3)
fn(a=4) # 错误，仅位置参数，不可以使用关键字传参

7、参数的混合使用

7.1、可变位置参数、keyword-only参数、缺省值

def fn(*args, x=5):
    print(x)
    print(args)
fn() # 等价于fn(x=5)
fn(5)
fn(x=6)
fn(1,2,3,x=10)

7.2、普通参数、可变位置参数、keyword-only参数、缺省值

def fn(y, *args, x=5):
    print('x={}, y={}'.format(x, y))
    print(args)
# fn() # 报错
fn(5)
fn(5, 6)
# fn(x=6) # 报错
fn(1, 2, 3, x=10)
# fn(y=17, 2, 3, x=10) #  报错
# fn(1, 2, y=3, x=10) # 报错
fn(y=20, x=30)

7.3、普通参数、缺省值、可变关键字参数

def fn(x=5, **kwargs):
    print('x={}'.format(x))
    print(kwargs)
fn()
fn(5)
fn(x=6) 
fn(y=3, x=10)
fn(3, y=10)
fn(y=3, z=20)

8、参数规则

8.1、说明

参数列表参数一般顺序是：positional-only参数、普通参数、缺省参数、可变位置参数、keyword-only
参数（可带缺省值）、可变关键字参数。

8.2、注意

8.2.1、注意事项

代码应该易读易懂，而不是为难别人
请按照书写习惯定义函数参数

8.2.2、代码示例

def fn(a, b, /, x, y, z=3, *args, m=4, n, **kwargs):
    print(a, b)
    print(x, y, z)
    print(m, n)
    print(args)
    print(kwargs)
    print('-' * 30)

def connect(host='localhost', user='admin', password='admin', port='3306', **kwargs):
    print('mysql://{}:{}@{}:{}/{}'.format(
        user, password, host, port, kwargs.get('db', 'test')))

connect(db='cmdb') # 参数的缺省值把最常用的缺省值都写好了
connect(host='192.168.1.123', db='cmdb')
connect(host='192.168.1.123', db='cmdb', password='mysql')

8.3、总结

定义最常用参数为普通参数，可不提供缺省值，必须由用户提供。注意这些参数的顺序，最常用的先定义
将必须使用名称的才能使用的参数，定义为keyword-only参数，要求必须使用关键字传参
如果函数有很多参数，无法逐一定义，可使用可变参数。如果需要知道这些参数的意义，则使用可变关键字参数收集

9、参数解构

9.1、代码示例判断

def add(x, y):
    print(x, y)
    return x + y
add(4, 5)
# add((4, 5)) # 报错
t = 4, 5
add(t[0], t[1])
add(*t)
add(*(4, 5))
add(*[4, 5])
add(*{4, 5}) # 注意有顺序吗？
add(*range(4, 6))
add(*{'a':10, 'b':11}) 
# add(**{'a':10, 'b':11}) #  报错
add(**{'x':100, 'y':110}) #

9.2、参数解构

9.2.1、说明

在给函数提供实参的时候，可以在可迭代对象前使用 * 或者 ** 来进行结构的解构，提取出其中所
有元素作为函数的实参
使用 * 解构成位置传参
使用 ** 解构成关键字传参
提取出来的元素数目要和参数的要求匹配

9.2.2、代码示例

def add(*nums):
    result = 0
    for x in nums:
        result += x
    return result
add(1, 2, 3)
add(*[1, 3, 5])
add(*range(5))

9.2.3、3.8以后，下面就不可以使用字典解构后的关键字传参了-代码示例

def add(x, y, /): # 仅位置形参
    print(x, y)
    return x + y
add(**{'x':10, 'y':11}) # 报错

10、函数返回值

10.1、示例

10.1.1、return语句之后可以执行吗？

def showplus(x):
    print(x)
    return x + 1
    print('~~end~~') # return之后会执行吗？ 不会执行
showplus(5)

10.1.2、 多条return语句都会执行吗

def showplus(x):
    print(x)
    return x + 1  # 到此为止
    return x + 2
showplus(5)

10.1.3、if多个return可以执行吗？

def guess(x):
    if x > 3:
        return "> 3"
    else:
        return "<= 3"
print(guess(10))

10.1.4、下面函数执行的结果是什么

def fn(x):
    for i in range(x):
        if i > 3:
            return i
    else:
         print("{} is not greater than 3".format(x))
print(fn(5)) # 打印什么？ 4  3 is not greater than 3
print(fn(3)) # 打印什么？ None

10.2、能够一次返回多个值吗？

def showvalues():
    return 1, 3, 5
showvalues() # 返回了多个值吗？ (1, 3, 5)

函数不能同时返回多个值
return 1, 3, 5 看似返回多个值，隐式的被python封装成了一个元组
x, y, z = showlist() 使用解构提取返回值更为方便

10.3、总结

Python函数使用return语句返回“返回值”
所有函数都有返回值，如果没有return语句，隐式调用return None
return 语句并不一定是函数的语句块的最后一条语句
一个函数可以存在多个return语句，但是只有一条可以被执行。如果没有一条return语句被执行到，隐式调用return None
如果有必要，可以显示调用return None，可以简写为return
如果函数执行了return语句，函数就会返回，当前被执行的return语句之后的其它语句就不会被执行了
返回值的作用：结束函数调用、返回“返回值”