Python 函数
#####此篇文章来源于我的老师Wayne,仅作记录以备复习
函数
数学定义
- y = f(x), y 是 x 的函数，x 是自变量。y = f(x0,x1,…,xn)
Python函数
- 由若干语句组成的语句块、函数名称、参数列表构成，它是组织代码的最小单元
- 完成一定的功能
函数的作用
- 结构化编程对代码的最基本的封装，一般按照功能组织一段代码
- 封装的目的是为了复用，减少冗余代码
- 代码更加简洁美观，可读易懂
函数的分类
- 内建函数，如 max()、reversed() 等
- 库函数，如 math.ceil() 等
- 自定义函数，使用 def 关键字定义
函数定义
def 函数名 （参数列表）：
函数体 （代码块）
[return 返回值]
- 函数名就是标识符，命名要求一样
- 语句块必须缩进，约定4个空格
- Python 的函数若没有 return 语句，会隐式返回一个None值
- 定义中的参数列表称为形式参数 ，只是一种符号表达（标识符），简称形参
函数调用
- 函数定义，只是声明了一个函数，它不能被执行，需要调用执行
- 调用的方式，就是函数名后加上小括号 ，如有必要再括号内填上参数
- 调用时写的参数是实际参数 ，是实实在在传入的值，简称 实参
def add(x,y): 函数定义
result = x + y 函数体
return result 返回值
out = add(4,5) 函数调用，可能有返回值，使用变量接收这个返回值
print(out) print函数加上括号也是调用上面代码解释：
- 定义一个函数add，及函数名是add，接受2个参数
- 该函数计算的结果，通过返回值返回，需要return语句
- 调用时，通过函数名add后加2个参数，返回值可使用变量接收
- 函数名也是标识符，返回值也是值
- 定义需要在调用前，也就是说调用时，已经被定义过了，否则抛NameError异常
- 函数是可调用的对象 ，callable()
函数参数
函数在定义时要约定好形式参数，调用时也提供足够的实际参数，一般来说，形参和实参个数要一致（可变参数除外）
传参方式
- 位置传参
定义时 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) 错误传参，关键字传参放到了位置传参之前参数缺省值
缺省值也成为默认值，可以在函数定义时，为形参添加一个缺省值。其作用：
- 参数的默认值可以在未传入足够的实参的时候，对没有给定的参数赋值为默认值
- 参数非常多的时候，并不需要用户每次都输入所有的参数，简化函数调用
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=6,x=5)
注意==add(x=5,6)、add(y=8,4)、add(11,x=20)==这
几种是错误传参，关键字传参放到了位置传参之前注意：def add(x=4,y) 这种设定缺省值的形式是错误的，而def add(x,y=4) 这样是可以的，有点类似于位置传参与关键字传参的关系。
def login(host='127.0.0.1',port='8080',username='kiffen',password='python'):
print('{}:{}@{}/{}'.format(host,port,username,password))
login()
login('127.0.0.1',80,'tom','tom')
login('127.0.0.1',username='root')
login('localhost',port=80,password='com')
login(port=80,password='python',host='www')可变参数
需求：写一个函数，可以对多个数累加求和
def sum(iterable):
sum = 0
for x in iterable:
sum += x
return sum
print(sum([1,2,3,4,5]))
print(sum(range(4)))上例，传入可迭代对象，并累加每一个元素
也可以使用可变参数完成上面的函数
def sum(*nums):
sum = 0
for x in nums:
sum += x
return sum
print(sum(1,3,5))
print(sum(1,2,3))- 可变位置参数
- 在形参前使用 * 表示该形参是可变位置参数，可以接受多个实参
- 它将收集来的实参组织到一个 tuple 中
- 可变关键字参数
- 在形参前使用 ** 表示该形参是可变关键字参数，可以接受多个关键字参数
- 它将收集来的实参的名称和值，组织到一个 dict 中
def showconfig(**kwargs):
for k,v in kwargs.items():
print('{}={}'.format(k,v),end=',')
showconfig(host='127.0.0.1',port=8080,username='kiffen',password='python')混合使用
可以定义下列方式么？
def showconfig(username,password,**kwargs):
def showconfig(username,*args,**kwargs):
下面这种定义方法是错误的，可变关键字参数应放置可变位置参数之后
def showconfig(username,**kwargs,*args) :?总结
* 有可变位置参数和可变关键字参数* 可变位置参数在形参前使用一个星号 ** 可变关键字参数在形参前使用两个星号 *** 可变位置参数和可变关键字参数都可以收集若干实参，可变位置参数收集形成一个元组 tuple ，可变关键字参数收集形成一个字典 dict* 混合使用参数时，普通参数需要放到参数列表前面，可变参数要放到参数列表后面，可变位置参数要放到可变关键字参数之前使用举例
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=3,y=8,7,9,a=1,b='abc')
fn(7,9,y=5,x=3,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’)，错在形参x,y,已经按照位置传参了，y=5,x=3有重复的传参
keyword-only 参数
让我们先看一段代码
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,x=6,y=7,a=1,b='abc')在Python 3 之后，新增了keyword-only参数。
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')
File "<ipython-input-155-a1a3fd0a3595>", line 1
def fn(**kwargs,x):
^
SyntaxError: invalid syntax直接就语法错误了。
可以认为，kwargs会截获所有关键字传参，就算写了 x=5 ，x也没有机会得到这个值，所以这种语法不存在。
keyword-only参数另一种形式
- 星号后所有的普通参数都成了keyword-only参数。
def fn(*,x,y):
print(x,y)
fn(x=6,y=9)
fn(y=6,x=9)参数的混合使用
可变位置参数，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)普通参数，可变位置参数，keyword-only参数
def fn(y,*args,x=5):
print('x={},y={}'.format(x,y))
print(args)
fn() 错误，缺少传入普通参数 y
fn(5)
fn(5,6)
fn(x=6) 错误，缺少传入普通参数 y
fn(1,2,3,x=10)
fn(y=17,1,2,3,x=10) 错误，关键字参数放到了位置参数之前
fn(1,2,3,y=3,x=10) 错误，y 已经按照位置传参了，y=3 有重复的传参出现普通参数、缺省值、可变关键字参数
def fn(x=5,**kwargs):
print(x)
print(kwargs)
fn()
fn(5)
fn(x=6)
fn(y=3,x=10)
fn(3,y=10)
fn(y=3,z=20)参数规则
参数列表参数一般顺序是：普通参数，缺省值，可变位置参数，keyword-only参数（可带缺省值），可变关键字参数
注意：
- 代码应易读易懂，而不是为难别人
- 请按照书写习惯定义函数参数
def fn(x,y,z=3,*args,m=4,n,**kwargs):
print(x,y,z,m,n)
print(args)
print(kwargs)
def connect(host='localhost',port='3306',user='admin',password='admin',**kwargs):
print(host,port)
print(user,password)
print(kwargs)
connect(db='cmdb')
connect(host='192.168.1.123',db='cmdb')
connect(host='192.168.1.123',db='cmdb',password='mysql')- 定义最常用参数为普通参数，可不提供缺省值，必须用户提供。注意这些参数的顺序，最常用的先定义
- 将必须使用名称的才能使用的参数，定义为keyword-only参数，要求必须使用关键字传参
- 如果函数有很多参数，无法逐一定义，可使用可变参数。如果需要知道这些参数的意义，则可使用可变关键字参数收集
参数解构
def add(x,y):
print(x,y)
return x+y
add(4,5)
add((4,5)) 错误，因为元组作为一个实参整体传入x，而y缺少实参的传入
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':10,'y':11})
第一条输出结果：
b a
'ba'
第二条输出结果：
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-205-c73998831612> in <module>
----> 1 add(**{'a':10,'b':11})
TypeError: add() got an unexpected keyword argument 'b'
第三条输出结果：
10 11
21参数解构：
- 在给函数提供实参的时候，可以在可迭代对象前使用 * 或者 ** 来进行结构的解构，提取出其中所有元素作为函数的实参
- 使用 * 解构成位置传参
- 使用 ** 解构成关键字传参
- 提取出来的元素数目要和参数的要求匹配
def add(*iterable):
result = 0
for x in iterable:
result += x
return result
add(1,2,3)
add(*[1,3,5])
add(*range(5))例题解答
- 编写一个函数，能够接收至少2个参数，返回最小值和最大值
def maxmin(x,y,*args):
print('max={}'.format(max(x,y,*args)))
print('max={}'.format(min(x,y,*args)))
import random
print(select(*[random.randint(10,20)for i in range(random.randint(2,10))]))or
def select(x,y,*args):
print(x,y,args)
return max(x,y,*args),min(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('>>>')
if isinstance(x,str):
print('Input Error')
break
nums = [int(i) for i 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_)
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
