函数的定义和传参方式

Python 函数

• 函数
   数学定义
   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()

函数参数

• 函数在定义时要约定好形式参数,调用时也提供足够的实际参数,一般来说,形式参数和实际参数是一致的(可变参数除外)

传参方式

1,位置参数
 定义def f(x,y,z),调用使用f(1,3,5),按照参数定义顺序传入实参
2,关键字传参
 定义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=5,y=6)
f(y=5,z=2,2) # 错误传参

参数缺省值

缺省值也称为默认值,可以在函数定义时,为形参增加一个缺省值,其作用:

• 参数的默认值可以在未传入足够的实际参数时,对没有给定的参数赋值为默认值
• 参数非常多的时候,并不需要用户每次都输入所有的参数,简化函数调用

可变参数

例如: 写一个函数,可以对多个数累加求和

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

上列,传入可迭代对象,并累加每一个元素,也可以使用可变参数完成上面的函数

def sum(*nums):
    sum = 0
    for x in nums:
        sum += x
    return sum
print(sum(1,3,5))

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

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

def showconfig(**kwargs):
    for k v in kwargs.items():
        print("{}={}".format(k,v),end = ",")
 showconfig(host = "127.0.0.1",port = 800)

混合使用

def showconfig(username,password,**kwargs)
def showconfig(username,*args,**kwargs)
def showconfig(username,password,**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') # 错误 x,y多传参  

keyword-only参数

在Python3之后，新增了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不可能通过位置传参传入了。

keyword-only参数另一种形式

• 星号后所有的普通参数都成了keyword-only参数。

如:

def fn(*, x, y):
 print(x, y)
fn(x=6, y=7)
fn(y=8, 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() #
fn(5)
fn(5, 6)
fn(x=6) #
fn(1, 2, 3, x=10)
fn(y=17, 2, 3, x=10) #
fn(1, 2, y=3, x=10) #

• 普通参数、缺省值、可变关键字参数

def fn(x=5, **kwargs):
 print('x={}'.format(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参数（可带缺省值）、可变关键字参数。
• 注意：代码应该易读易懂，而不是为难别人,需按照书写习惯定义函数参数
  定义最常用参数为普通参数，可不提供缺省值，必须由用户提供。
  注意这些参数的顺序，最常用的先定义将必须使用名称的才能使用的参数，定义为keyword-only参数，要求必须使用关键字传参如果函数有很多参数，无法逐一定义，可使用可变参数。
  如果需要知道这些参数的意义，则使用可变关键字参数收集

参数解构

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

def add(*iterable):
    result = 0
    for x in iterable:
        result += x
    return result

add(1,2,3)
add(*[1,2,3])
add(*range(5))

def fo(x,y):
    return x+2*y  
  
>>>fo(*[5,6]),fo(*{3,7}),fo(*(3,6)),fo(*{2:200,3:300}),fo(**{'x':200,'y':300})
>>>(17, 17, 15, 8, 800)