Python函数基础

Python中的函数，是由若干语句组成的语句块、函数名称、参数列表构成，它是组织代码的最小单元。借助函数我们能实现一定的功能。

python函数的作用在于

1. 结构化编程，对代码进行基本封装，（一般）按照功能组织一段代码
2. 方便代码的复用，减少冗余代码
3. 代码简洁易懂

在python中，函数可分为：

1. 内建函数，如max()、reverse()

2. 库函数，如math.ceil()

3. 自定义函数，使用def关键字定义

一、函数的定义

def 函数名(参数列表):
    函数体（代码块）
    [return 返回值]

• 函数名就是变量标识符，要求同样是下划线、数字、字母组成，不得以数字开头
• 语句块必须缩进，约定是4个字符
• python的函数如若没有return语句，会隐式返回一个None值
• 定义中的参数列表称为形式参数，只是一种符号表达（标识符），简称形参

二、函数调用

python函数的定义只是声明了一个函数，它不能被执行，需要被调用执行。调用的形式，就是函数名加上小括号，如有必要，括号内要填上参数。函数被调用的时候，写的参数是实际参数，是实实在在传入的数值，简称实参。

def add(x,y):         #函数的定义
    result = x + y    #函数体
    return result     #返回值
    
out = add(4,5)        #函数调用
print(out)

上面代码的解释：

• 定义一个函数add，函数名是add，接受2两个参数
• 该函数的计算结果，通过返回值返回，需要return语句
• 调用时，通过函数名add后加两个参数，使用变量来接收函数返回值
• 函数名是标识符，返回值是值
• 定义需要在调用之前，也就是说在调用的时候，函数已经被定义了，否则抛出NameError异常
• 函数是可调用对象，即callable()

三、函数的参数

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

3.1 传参方式

传参方式分为两种：位置传参和关键字传参。

3.1.1 位置传参

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

3.1.2 关键字传参

定义时是 def f(x, y, z)，调用时使用 f(x=1, y=2, z=3)，使用形参的名字来传入实参。如果使用这种方式，那么传参顺序就可和定义的顺序不一样。

位置参数必须在关键字参数之前传入，位置参数是按照位置对应的。

def f(x, y, z):
    pass
    
f(z=None, y=10, x=[1])
f((1,), z=6, y=0.1)
f(x=1, z=3, 0.6) # 错误传参

3.2 参数的缺省值

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

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

举例：

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

# 能否这样定义def add(x, y=5) 或 def add(x=4, y) ? 

# 定义一个函数login，参数名为host，port，username，password
def login(host='127.0.0.1', port=8080, username='jacky', passwd='pinginglab'):
    print('{}/{}@{}:{}'.format(username, password, host, port))
    
login()
login('tom', 'tom', '127.0.0.1', 80)
login('tom', host='127.0.0.1')
login('tom', port=80, password='tom')
login(port=80, passwd='tom', host='localhost')

3.3 可变参数

需求：写一个函数，可以对多个数进行累加。

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

上面的例子，传入可迭代对象，并累积每一个元素。

也可以使用可变参数来完成上面的函数定义：

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

print(sum(1,2,3))   

3.3.1 可变位置参数

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

3.3.2 可变关键字参数

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

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

3.3.3 混合使用

def showconfig(username, passwd, **kwargs)
def showconfig(username, *args, **kwargs)
def showconfig(username, passwd, **kwargs, *args) # SyntaxError: invalid syntax

总结：

1. 有可变位置参数和可变关键字参数
2. 可变位置参数在形参前使用一个 *****
3. 可变关键字参数在形参前使用两个 ******
4. 可变位置参数和可变关键字参数都可以收集若干个实参，可变位置参数收集形成一个tuple，可变关键字参数收集形成一个dict
5. 混合使用参数的时候，普通参数要放在前面，可变参数要放到后面，可变位置参数要在可变关键字参数的前面

使用举例

def fn(x, y, *args, **kwargs):
    print(x, y, args, kwargs, sep='\n', end='\n\n')
    
fn(3, 5, 9, 10, a=1, b='abc')
fn(3, 5)
fn(3, 5, 7)
fn(3, 5, a=1, b='abc')
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, y了，'y=5, x=3'重复传值了

3.4 keyword-only 参数

def fn(*args, x, y, **kwargs):
    print(x, y, args, kwargs, sep='\n', end='\n\n')
    
fn(3, 5) # TypeError: fn() missing 2 required keyword-only arguments: 'x' and 'y'
fn(3, 5, 7) # TypeError: fn() missing 2 required keyword-only arguments: 'x' and 'y'
fn(3, 5, a=1, b='abc') # TypeError: fn() missing 2 required keyword-only arguments: 'x' and 'y'
fn(3, 5, y=6, x=7, a=1, b='abc')

从上面可以看出，普通参数 x & y 放在 *args 并没有报错，而且从运行结果可以看出，它们并不是普通位置参数，变成了关键字参数。

这是因为，在python3之后，新增了keyword-only参数。在形参定义时，在一个可变位置参数之后，出现的普通参数，就不再是普通参数了，而是keyword-only参数。

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

keyword-only参数，言下之意就是该参数必须采用关键字传参。

可以认为，上例中，*args截获了所有位置参数，其后的x不可能通过位置参数传入了

那么：def fn(**kwargs, x) 呢？

def fn(**kwargs, x):
    print(x, kwargs, sep='\n', end='\n\n')

直接语法错误。

可以认为，**kwarg 会截获所有关键字传参，x没有机会获得关键字传参，这种语法不存在。

keyword-only的另一种形式：

* 号后所有的普通参数都变成keyword-only参数

def fn(*, x, y):
    print(x, y)
    
fn(x=6, y=7)
fn(y=6, x=7)

3.5 参数混合使用规则

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

注意：

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

3.6 参数解构

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, 5))

add(*{'a':10, 'b':10}) # 正常，结果是 a b
add(**{'a':10, 'b':10}) # TypeError: add() got an unexpected keyword argument 'a'；**{'a':10, 'b':10} 解构出来是 a=10, b=10
add(**{'x':10, 'y':10}) # 正常，结果是10 10

参数解构：

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

四、课堂习题

1. 编写一个函数，至少接受两个参数，返回最大最小值

def select(x, y, *args):
    print(x, y, args)
    return min(x, y, *args), max(x, y, *args)

import random
print(*select(*[random.randint(10, 20) for i in range(random.randint(2, 10))]))

2. 编写一个函数，可以接受输入的多个参数，每一次都能返回目前为止的最大最小值

def double_values():
    max_ = min_ = None
    while True:
        x = input('>>>')
        nums = [int(c) for c in x.replace(',', ' ').split(' ')]
        if not nums:
            continue
        if max_ is None: # 使得第一次比较和后面的其他次比较共用了下面的代码
            max_ = min_ = nums[0]
        max_ = max(max_, *nums)
        min_ = min(min_, *nums)
        print(max_, min_)

double_values()