Python函数(一)
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 "" , 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_)