函数参数详解

一、缺省参数

调用函数时，缺省参数的值如果没有传入，则取默认值。

下例会打印默认的age，如果age没有被传入：

def printinfo(name, age=35):
   # 打印任何传入的字符串
   print("name: %s" % name)
   print("age %d" % age)

# 调用printinfo函数
printinfo(name="miki")  # 在函数执行过程中 age取默认值35
printinfo(age=9 ,name="miki")

以上实例输出结果：

name: miki
age: 35
name: miki
age: 9

总结： 在形参中默认有值的参数，称之为缺省参数

注意：带有默认值的参数一定要位于参数列表的最后面

def printinfo(name, age=35, sex):
     print name
  
    File "<stdin>", line 1
SyntaxError: non-default argument follows default argument

二、不定长参数

有时可能需要一个函数能处理比当初声明时更多的参数，这些参数叫做不定长参数，声明时不会命名。

基本语法如下：

def functionname([formal_args,] *args, **kwargs):
   """函数_文档字符串"""
   function_suite
   return [expression]

注意：

• 加了星号（*）的变量args会存放所有未命名的变量参数，args为元组
• 而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典.

def test(a, b, *args, **kwargs):
      "函数在声明时，需要两个参数"
    print('a={},b={},args={},kwargs={}'.format(a,b,args,kwargs))

test(2, 3, '你好', 'hi', 'how do you do', name="zhangsan", age=18)
# a=2,b=3,args=('你好', 'hi', 'how do you do'),kwargs={'name': 'zhangsan', 'age': 18}


b = ('hi', '大家好', '今天天气真好')
d = {'name': "zhangsan", "age": 19}

# 注意，在传入参数时的星号问题。
test(10, 20, *b, **d) 
# a=10,b=20,args=('hi', '大家好', '今天天气真好'),kwargs={'name': 'zhangsan', 'age': 19}


# 如果在传值时，不使用星号，会把后面的参数当做 args
test(10,20,b,d)
# a=10,b=20,args=(('hi', '大家好', '今天天气真好'), {'name': 'zhangsan', 'age': 19}),kwargs={}

三、缺省参数在*args后面

def sum_nums_3(a, *args, b=22, c=33, **kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)

sum_nums_3(100, 200, 300, 400, 500, 600, 700, b=1, c=2, mm=800, nn=900)

说明： 如果很多个值都是不定长参数，那么这种情况下，可以将缺省参数放到args的后面，但如果有**kwargs的话，kwargs必须是最后的

可变、不可变类型

总结

• 所谓可变类型与不可变类型是指：数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变

• 可变类型(修改数据，内存地址不会发生变化)有：列表、字典、集合

• 不可变类型(修改数据，内存地址必定发生变化)有：数字、字符串、元组

递归函数

1. 什么是递归函数

通过前面的学习知道一个函数可以调用其他函数。

如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。

2. 递归函数的作用

举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * ... * n

解决办法1: 使用循环来完成

def cal(num):
    result,i = 1,1
    while i <= num:
        result *= i
        i+= 1
    return result

print(cal(3))

看阶乘的规律 1! = 1 2! = 2 × 1 = 2 × 1! 3! = 3 × 2 × 1 = 3 × 2! 4! = 4 × 3 × 2 × 1 = 4 × 3! ... n! = n × (n-1)!

解决办法2: 使用递归来实现

def factorial(num):
    result = 1
    if num == 1:
        return 1
    result = num * factorial(num -1)
    return result

print(factorial(3))

原理

练习：使用递归实现斐波那契数列。1、1、2、3、5、8、13、21、34、……

匿名函数

用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。

lambda函数的语法只包含一个语句，如下：

lambda 参数列表: 运算表达式

如下实例：

sum = lambda arg1, arg2: arg1 + arg2

# 调用sum函数
print("Value of total : %d" % sum( 10, 20 ))
print("Value of total : %d" % sum( 20, 20 ))

以上实例输出结果：

Value of total :  30
Value of total :  40

Lambda函数能接收任何数量的参数但只能返回一个表达式的值

匿名函数可以执行任意表达式(甚至print函数)，但是一般认为表达式应该有一个计算结果供返回使用。

python在编写一些执行脚本的时候可以使用lambda，这样可以接受定义函数的过程，比如写一个简单的脚本管理服务器。

应用场合

函数作为参数传递

def fun(a, b, opt):
    print("a = " % a)
    print("b = " % b)
    print("result =" % opt(a, b))

add = lambda x,y:x+y
fun(1, 2, add)  # 把 add 作为实参传递

以上示例输出：

a = 1
b = 2
result = 3

练习

有一个列表

students = [
    {'name': 'zhangsan', 'age': 18, 'score': 92},
    {'name': 'lisi', 'age': 20, 'score': 90},
    {'name': 'wangwu', 'age': 19, 'score': 95},
    {'name': 'jerry', 'age': 21, 'score': 98},
    {'name': 'chris', 'age': 17, 'score': 100},
]

要求，对上述列表里的数据按照score进行升序排序。

Python中使用函数作为参数的内置函数和类:

函数名或类名	功能	参数描述
sorted函数	用来将一个无序列表进行排序	函数参数的返回值规定按照元素的哪个属性进行排序
filter类	用来过滤一个列表里符合规定的所有元素，得到的结果是一个迭代器	函数参数的返回值指定元素满足的过滤条件
map类	将列表里的每一项数据都执行相同的操作，得到的结果是一个迭代器	函数参数用来指定列表里元素所执行的操作
reduce函数	对一个序列进行压缩运算，得到一个值。python3以后，这个方法被移到了functools模块	函数参数用来指定元素按照哪种方式合并

高阶函数

在Python中，函数其实也是一种数据类型。

def test():
    return 'hello world'

print(type(test))  # <class 'function'>

函数对应的数据类型是 function，可以把它当做是一种复杂的数据类型。

既然同样都是一种数据类型，我们就可以把它当做数字或者字符串来处理。

定义一个变量指向函数

在Python中，我们还可以定义一个变量，让它来指向一个函数，相当于给函数起了一个别名。

def test():
    return 'hello wrold'

fun = test   # 定义了一个变量fun,让它指向了 test 这个函数
print(fun())   # 使用fun()可以直接调用test这个函数

print(id(fun))  # 1819677672040
print(id(test))  # 1819677672040

注意：在定义一个变量表示一个函数时，函数后面不能加括号！加括号表示的是调用这个函数。

def test():
    return 'hello world'

result = test()   # 这种写法是调用test函数，并把函数的返回值赋值给result变量
print(result())   # 这里会报错  TypeError: 'str' object is not callable

fun = test   # 这种写法是给test函数起了一个别名，注意，这里的test后面不能加()
fun()        # 可以使用别名调用这个函数

高阶函数

既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，同样，我们还可以把一个函数当做另一个函数的返回值。这种函数的使用方式我们称之为高阶函数。

函数做为另一个函数的参数

def test(age, action):
    if age < 18:
        print('您还没满十八岁，请退出')
    action()   # 把参数action直接当做一个函数来调用

def smoke():
    print('我已经年满十八岁了，我想抽烟')

my_action = smoke  # 定义一个变量my_action，让它指向smoke函数
test(21, my_action)  # 将my_action传给test函数作为它的参数

test(21, smoke)  # 还可以不再定义一个新的变量，直接传入函数名

函数作为另一个函数的返回值

def test():
    print('我是test函数里输入的内容')

def demo():
    print('我是demo里输入的内容')
    return test  # test 函数作为demo函数的返回值

result = demo()  # 我是demo里输入的内容  调用 demo 函数，把demo函数的返回值赋值给 result
print(type(result)) # <class 'function'>  result 的类型是一个函数

result() # 我是demo里输入的内容    我是test函数里输入的内容   既然result是一个函数，那么就可以直接使用() 调用这个函数

demo()()  # 我是demo里输入的内容    我是test函数里输入的内容

闭包

函数只是一段可执行代码，编译后就“固化”了，每个函数在内存中只有一份实例，得到函数的入口点便可以执行函数了。函数还可以嵌套定义，即在一个函数内部可以定义另一个函数，有了嵌套函数这种结构，便会产生闭包问题。

函数嵌套

在函数里面还可以定义函数，可以嵌套多层，执行需要被调用。

def outer():
    print('outer----hello')
    def inner():  # inner这个函数是在outer函数内部定义的
        print('inner----hello')
    inner()  # inner函数只在outer函数内部可见

outer()
# inner()  这里会报错，在outer函数外部无法访问到inner函数

什么是闭包

闭包是由函数及其相关的引用环境组合而成的实体(即：闭包=函数块+引用环境)。

def outer(n):
    num = n
    def inner():
        return num+1
    return inner

print(outer(3)())  # 4
print(outer(5)())  # 5

在这段程序中，函数 inner 是函数 outer 的内嵌函数，并且 inner 函数是outer函数的返回值。我们注意到一个问题：内嵌函数 inner 中引用到外层函数中的局部变量num，Python解释器会这么处理这个问题呢？先让我们来看看这段代码的运行结果，当我们调用分别由不同的参数调用 outer 函数得到的函数时，得到的结果是隔离的(相互不影响)，也就是说每次调用outer函数后都将生成并保存一个新的局部变量num，这里outer函数返回的就是闭包。如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure)。

修改外部变量的值

闭包里默认不能修改外部变量。

def outer(n):
    num = n
    def inner():
        num = num + 1
        return num
    return inner

print(outer(1)())

上述代码运行时会报错！

UnboundLocalError: local variable 'num' referenced before assignment

原因分析

在python里，只要看到了赋值语句，就会认为赋值语句的左边是一个局部变量。num = num + 1 这段代码里，num 在=的左边，python解析器会认为我们要修改inner函数里num这个局部变量，而这个变量使用之前是未声明的，所以会报错。

解决方案

我们分析过，报错的原因在于当我们在闭包内修改外部变量时，会被python解析器误会为内部函数的局部变量。所以，解决方案就在于，我们需要想办法，让解析器知道我们不是要修改局部变量，而是要修改外部变量。

解决方法：使用 nonlocal 关键字

def outer(n):
    num = n
    def inner():
        nonlocal num  # 修改前使用nonlocal关键字对 num 变量进行说明
        num = num + 1
        return num
    return inner

print(outer(2)())