Python 函数设计与使用

一、函数的代码定义

''' 注释写在此处更好 '''

def 函数名([参数列表]) :

    ''' 注释 '''

    函数体

参数的类型：

• 位置参数：调用时实参和形参的顺序和数量必须一致。

def demo(a, b, c):
    return 0

demo(3, 4, 5)

• 默认值参数：在定义函数时为形参设置默认值。默认值参数必须出现在函数形参的最右端，且其只会在第一次调用时进行解释。

def 函数名(···, 形参名 = 默认值) ：
    函数体

• 关键参数：（主要指实参）通过关键参数可以按参数名字传递值，实参顺序可以和形参顺序不一致。

>>> def demo(a, b, c = 5):
        print(a, b, c)
>>> demo(c = 8, a = 9, b = 0)
9 0 8

• 可变长度参数：主要有两种形式 *parameter 和 **parameter。前者用来接收任意多个实参并将其放在一个元组中，如果可变参数在函数调用时没有指定，即为空元组；后者接受类似于关键参数一样显式赋值形式的多个实参并将其放入字典中。

1. 无论调用该函数时传递了多少实参，一律放入元组中：

>>> def demo(*p):
        print(p)
>>> demo(1, 2, 3)
(1, 2, 3)

     2. 在调用函数时自动将接受的参数转换为字典：

>>> def demo(**p):
        for item in p.items():
            print(items)
>>> demo(x = 1, y = 2, z = 3)
('y', 2)
('x', 1)
('z', 3)

定义函数时不同形式的参数混合使用的用法：

    顺序必须为：位置参数、默认参数、可变参数、关键参数。

• 大多数情况下，在函数内部直接修改形参的值不会影响实参。
• 但可以通过特殊的方式在函数内部修改实参的值：

         如果传递给函数的是 Python 可变序列，并且在函数内部使用下标或其他方式为可变序列增加、删除元素或修改元素的值时，实参也得到相应的改变。 

二、函数定义变量时的关键字

    一般来说，局部变量的引用比全局变量速度快。

    如果想要在函数内部修改一个定义在函数外的变量值，那么这个变量就不能是局部（局部变量在函数运行结束后被自动删除而不可访问）的，其作用域必须为全局的，能够同时作用与函数内外，成为全局变量，可以通过 global 来声明或定义。分两种情况：

1. 一个变量已经在函数外定义，可以在函数内用 global 声明这个变量为全局变量，明确声明要使用已定义的同名全局变量。
2. 在函数内部直接使用 global 关键字将一个变量声明为全局变量，即使在函数外没有定义该全局变量，在调用这个函数之后，将自动添加新的全局变量。

三、序列解包的整体过程

       为含有多个变量的函数传递参数时，可以使用列表、元组、集合、字典以及其他可迭代对象作为实参，并在实参名称前加一个 * 星号，Python 解释器将自动进行解包，然后传递给多个单变量形参。如果使用字典对象作为实参，则默认使用字典的“键”，如果需要将字典中的“键 - 值对”作为参数则需要使用 items() 方法；如果需要使用字典的“值”作为参数则需要调用字典的 values() 方法。最后，务必保证实参中元素的个数与形参个数相等，否则将出现错误。

>>> def demo(a, b, c):
        print(a + b + c)
>>> seq = [1, 2, 3]
>>> def( * seq)
6
>>> tup = (1, 2, 3)
>>> demo( * tup)
6
>>> dic = {1: 'a', 2: 'b', 3: 'c'}
>>> demo( * dic)
6
>>> set = {1, 2, 3}
>>> demo( * set)
6
>>> demo( * dic.values())
abc

四、Lambda 表达式

    Lambda 表达式可以用来声明匿名函数，即没有函数名字的临时使用的小函数。

    Lambda 表达式只可以包含一个表达式，不允许包含其他复杂的语句，但可以在表达式中调用其他函数，并支持默认值参数和关键参数，该表达式的计算结果就是函数的返回值。

>>> f = lambda x, y, z : x + y + z    # 其中，“x, y, z”为变量，“x + y + z”为函数体，
                                      # “f”为表达式的名字
>>> print(f(1, 2, 3))
6
>>> g = lambda x, y = 2, z = 3 : x + y + z
>>> print(g(1))
6
>>> print(g(2, z = 4, y = 5))
11
>>> L = [(lambda x : x ** 2), (lambda x : x ** 3)]
>>> print(L[0](2), L[1](2))
4 8
>>> D = {'f1' : (lambda : 2+3), 'f2' : (lambda : 2*3)}
>>> print(D['f1'](), D['f2]())
5 6
>>> L = [1, 2, 3, 4]
>>> print(map((lambda x : x + 10), L))    # 没有名字的 lambda 表达式
                                          # map 对序列中每个元素依次执行函数
                                          # 并将结果作为新的 list 返回
[11, 12, 13, 14]
>>> L
[1, 2, 3, 4]
>>> def demo(n) :
        return n * n
>>> list(map(lambda x : demo(x), L))
[1, 4, 9, 16, 25]
>>> data = [4, 13, 3, 11, 12, 15]
>>> data.sort(key = lambda x : x)
>>> data
[3, 4, 11, 12, 13, 15]

    匿名函数的三个规则：

• 一般只有一行表达式，必须有返回值；
• 不能有 return 语句
• 可以没有参数，也可以有一至多个参数。 

五、认识常用内置函数

1、map()：将一个单参数函数依次作用到一个升序或迭代器对象的每个元素上，并返回一个 map 对象作为结果，其中每个元素时原序列中元素经过该函数处理后的结果，该函数不对原序列或迭代器对象做任何修改。

    压缩和解包的方法：zip() 和 map()

2、reduce()：可以接收将一个两个参数的函数一累积的方式从左到右依次作用到一个序列或迭代器对象的所有元素上。

3、filter()：将一个单参数函数作用到一个序列上没返回该序列中使得该函数返回值为 True 的哪些元素组成的列表、元素或字符串。