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='\n') 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()
