Python函数

1 Python函数

　　数学定义： ​ y = f(x)，y 是 x 的函数，x 是自变量。y = f(x0, x1, ... xn)

　　Python函数： ​ 由若干语句组成的语句块、函数名称、参数列表构成，它是组织代码的最小单元 ​ 完成一定的功能

　　函数的作用： ​ 结构化编程对代码的最基本的封装，一般按照功能组织一段代码 ​ 封装的目的为了复用，减少冗余代码 ​ 代码更加简洁美观、可读易懂

　　函数的分类： ​ 内建函数，如 max()，reversed() 等 ​ 库函数，如 math.ceil() 等 ​ 自定义函数，使用 def 关键字定义

2 函数定义

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

　　函数名就是标识符，命名要求一样 ​ 语句块必须缩进，约定 4 个空格 ​ Python 的函数若没有 return 语句，会隐式返回一个 None 值 ​ 定义中的参数列表称为形式参数，只是一种符号表达（标识符），简称形参

3 函数调用

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

def add(x,y):      # 函数定义，创建一个标识符 add 指向函数对象
    result = x + y # 函数体
    return result  # 返回值
print(add(4,5))    # 函数的调用，函数名后使用小括号，小括号中填入实际参数，简称为实参
​
print(callable(add))    # 函数是可调用对象，callable()

def add(x,y):
    return x + y
print(add(4,5),add(5,6),add('a','b'),add([0],[1]))    # 通用，问题？
​
# 执行结果：
9 11 ab [0, 1]

4 函数参数

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

4.1 传参方式

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

　　关键字传参： ​ 定义时 def f(x, y, z)，调用使用 f(x=1, y=3, z=5)，使用形参的名字来传入实参的方式，如果使用了形参名字，那么传参顺序就可和定义顺序不同。

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

def f(x, y, z):
    pass
​
f(z=None, y=10, x=[1])
f((1,), z=6, y=4.1)
f(y=5, z=6, 2)    # 错误传参

4.2 参数缺省值

　　缺省值也称为默认值，可以在函数定义时，为形参增加一个缺省值。其作用： 参数的默认值可以在未传入足够的实参的时候，对没有给定的参数赋值为默认值 参数非常多的时候，并不需要用户每次都输入所有的参数，简化函数调用

def add(x=4,y=5):
    return x + y
print(add())            # 9
print(add(10))          # 15
print(add(10, y=6))     # 16
print(add(y=11, x=12))  # 23
print(x=5, 6)           # 语法错误
print(5, y=6, x=10)     # 语法错误，x多值错误

def add(x=4, 5):        # 语法错误，无缺省值形参应在有缺省值形参之前
    return x + y

4.3 可变参数

　　需求：写一个函数，可以对多个数累加求和

def sums(iterable):     # 传入可迭代对象，并累加每一个元素
    result = 0
    for x in iterable:
        result += x
    return result
print(sums(range(10)))
print(sums((1, 2, 3)))
print(sums({'a':1, 'b':2}.values()))

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

def sums(*nums):        # 可变的位置参数
    result = 0
    for x in nums:
        result += x
    return result
print(sums(1, 2, 3))

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

def showconfig(**kwargs):
    print(type(kwargs))
    for k,v in kwargs.items():
        print('{}={}'.format(k, v), end=' ')
showconfig(IPADDR='192.168.100.20', PREFIX='24', GATEWAY='192.168.100.2')

# 执行结果：
<class 'dict'>
IPADDR=192.168.100.20 PREFIX=24 GATEWAY=192.168.100.2 

　　混合使用：

# 可以定义下列方式吗？
def showconfig(username, password, **kwargs):
    pass
def showconfig(username, *args, **kwargs):
    pass
def showconfig(username, password, **kwargs, *args):    # 语法错误
    pass

　　总结：

　　1> 有可变位置参数和可变关键字参数

　　2> 可变位置参数在形参前使用一个星号*

　　3> 可变关键字参数在形参前使用两个星号**

　　4> 可变位置参数和可变关键字参数都可以收集若干个实参，可变位置参数收集形成一个 tuple，可变关键字参数收集形成一个 dict

　　5> 混合使用参数的时候，普通参数需要放到参数列表前面，可变参数要放到参数列表的后面，可变位置参数需要在可变关键字参数之前

def fn(x, y, *args, **kwargs):
    print(x, y, args, kwargs, sep='
')
fn(2, 3, 4, 5, a=1, b='abc')

# 执行结果：
2
3
(4, 5)
{'a': 1, 'b': 'abc'}

4.4 keyword-only参数

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

def fn(*args, x):    # 只能 keyword 传参，即keyword-only
    print(x)
    print(args)
fn(1,2,3,4)          # 语法错误
fn(1,2,3,4, x=6)

def fn1(*args, x, y, **kwargs):
    print(x, y, args, kwargs)
fn1(3, 5)        # 报错，x,y无值
fn1(3, 5, 7)     # 报错，x,y无值
fn1(3, 5, a=1, b='abc')    # 报错，x,y无值
fn1(3, 5, y=6, x=7, a=1, b='abc')

 

 

　　总结：

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

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

def fn2(**kwargs, x):             # 语法错误
    pass

　　keyword-only 参数的另一种形式

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

def fn3(x, y, *, z, **kwargs):    # * 号之后，为 keyword-only
    print(x, y, z, kwargs)
fn3(1, 2, z=3)

4.5 参数的混合使用

# 可变位置参数、keyword-only 参数、缺省值 
def fn(*args, x=5):
    print(x)
    print(args)
fn(), fn(1), fn(1,2,5), fn(x=10)

# 普通参数、可变位置参数、keyword-only 参数、缺省值
def fn(y, *args, x=5):
    print('x={}, y={}'.format(x, y))
    print(args)
fn(1), fn(1,2,3), fn(1,x=10), fn(x=10, y=20)

# 普通参数、缺省值、可变关键字参数
def fn(x=5, **kwargs):
    print('x={}'.format(x))
    print(kwargs)
fn(), fn(2), fn(y=100)

4.6 参数规则

　　1> 参数列表参数一般顺序是：普通参数、缺省参数、可变位置参数、keyword-only 参数（可带缺省值）、可变关键字参数。 ​ 注意： ​ 代码应该易读易懂 ​ 请按照书写习惯定义函数参数

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

5 参数解构

def add(x, y):
    print(x, y)
    return x + y
add(1, 2), add(3, y=4), add(x=5, y=6)
add(*[7, 8]), add(*(9, 10)), add(*range(11, 13))    # 参数解构
add(*{'a':1, 'b':2}.keys())
add(*{'a':1, 'b':2}.values())
add(*{'a':1, 'b':2}.items())
add(**{'a':1, 'b':2})    # 可以吗？
add(**{'x':1, 'y':2})
add(*{'x':1, 'y':2}.values())

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

def add(*iterable):
    result = 0
    for x in iterable:
        result += x
    return result
print(add([1, 3]))    # 可以吗？
print(add(*[1, 3]))
print(add(*range(10)))
print(add(x for x in range(10)))    # 可以吗？
print(add(*(x for x in range(10))))
print(add(1, 2, 3, *{x for x in range(10)}))

6 实例

1、编写一个函数，能够接受至少2个参数，返回最小值和最大值。

def getvalues(x, y, *args):
    print(max(x, y, *args))
    print(min(x, y, *args))
getvalues(6,3,9,1)

2、完成一个函数，可以接收输入的多个数，每一次都能返回到目前为止的最大值、最小值。

def return_values():
    max_ = None
    min_ = None
    while True:
        i = input(">>>")
        nums = i.replace(',', ' ').split()    # list str
        if nums[0] == 'EOF':
            break
        for x in nums:
            n = int(x)
            if max_ is None:
                max_ = n
                min_ = n
            if n > max_:
                max_ = n
            if n < min_:
                min_ = n
        print(max_,min_)
return_values()