我的Python第五篇 函数篇

一、新建函数
一个程序可以按照不同的功能实现，切割成许多的小个体，函数就是可以完成某一部分功能的个体的代码块。
在Python中，函数由def关键字+函数名+半角括号+括号中的参数+半角冒号:，然后在缩进块中编写函数体，函数的返回值用return语句返回。

1.新建函数：
A.

B.带参数的函数：

C.多参数函数：

二、函数的参数
1.形参与实参：
A.形参：只是一个形式，表示占据一个参数位置。

B.实参：有具体的参数值。

C.示例：

其中name是形参，Python是实参。

2.函数文档：

函数文档用于说明函数中的注释，必须放在函数名下。可以通过两种方法读取函数文档：
A.函数名.doc，加.表明是当前函数名的属性。

B.help(函数名)

C.help+函数名的方式要比函数名+.__doc__的方式更整洁和易于读懂。

3.位置参数：调用函数时，传入的两个值按照位置顺序依次赋值给参数。

4.默认参数：定义了默认值的参数在函数定义时对形参赋初值。

设置默认参数时，有几点要注意：

A.是必选参数在前，默认参数在后，否则Python的解释器会报错。

B.是如何设置默认参数。
当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

5.关键字参数：在函数调用的时候通过参数名定制需要赋值的参数。关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

A.在调用该函数时，可以只传入必选参数：

B.也可以传入任意个数的关键字参数：

C.关键字参数还可以扩展函数的功能。比如，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。
和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：

6.收集参数/可变参数：适用于暂时不确定需要调集几个参数的情况；定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数num接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数：
A.

B.如果收集参数后面要加上其他定制参数的话，使用关键字参数方法或默认参数方法。
a.关键字参数方法：

b.默认参数方法：

C.如果已经有一个list或者tuple，要调用一个可变参数：

*result 等于把 result 这个list的所有元素作为可变参数传进去。

三、全局变量（Global Variable）与局部变量（Local Variable）
全局变量在整个代码段中都可以被访问到，但是不要在函数内部去修改全局变量，否则Python会在函数内部新建一个与全局变量名一样的局部变量。
global关键字：将局部变量声明为全局变量

>>> temp = 5>>> def Myfun():                temp = 10                print(10)>>> Myfun()10>>> print(temp)5

通过global关键字声明变量temp：

>>> temp = 5>>> def Myfun():         global temp         temp = 10         print(10)>>> Myfun()10>>> print(temp)10

四、内部函数和闭包
1.内部函数：允许在函数内部创建函数。

>>> def fun1():                print('fun1()正在使用中。。。')                def fun2():                         print('fun2()正在使用中。。。')                fun2()>>> fun1()fun1()正在使用中。。。fun2()正在使用中。。。

2.闭包（closure）：函数式编程重要的语法结构。在一个内部函数里对外部作用域（但不是在全局作用域的变量）进行引用的内部函数。
例1：funy是def funx(x)的闭包：

>>> def funx(x):                def funy(y):                         return x * y                return funy>>> print(funx(8))<function funx.<locals>.funy at 0x00000222FDAD1E18>#调用fun(x)并赋值给i>>> i = funx(8)>>> i<function funx.<locals>.funy at 0x00000222FDAE3268>#查看i的类型>>> type(i)<class 'function'><!-- i等于返回 x 的值，需要得到 x * y 的返回值，需要调用i(y) -->>>> i(5)40也可以直接操作:>>> funx(8)(5)40funy()是内部函数，不能在外部被调用>>> funy(5)Traceback (most recent call last):` File "<pyshell#49>", line 1, in <module>         funy(5)NameError: name 'funy' is not defined

例2：

>>> def funa():               x = 5              def funb():                    x *= x                    return x              return funb()>>> print(funa())Traceback (most recent call last):  File "<pyshell#57>", line 1, in <module>    print(funa())  File "<pyshell#56>", line 6, in funa    return funb()  File "<pyshell#56>", line 4, in funb    x *= xUnboundLocalError: local variable 'x' referenced before assignment

解决方法：nonlocal方法，强制声明x不是funb()的局部变量

>>> def funa():                x = 5                def funb():                                 nonlocal x                                 x *= x                                 return x                return funb()>>> funa()25

五、lambda表达式
1.Python允许使用lambda关键字创建匿名函数，格式：
lambda 参数 :
例1 单参数：

>>> def g(x):                return 2 * x + 1>>> g(5)11>>> lambda x:2 * x + 1<function <lambda> at 0x000001F138AF3378>>>> g = lambda x:2 * x + 1>>> g(5)11

例2 多参数：

>>> def gg(a,b):                 return a*a + b*b>>> gg(3,4)25>>> lambda a,b:a*a + b*b<function <lambda> at 0x000001F138AF32F0>>>> gg = lambda a,b:a*a + b*b>>> gg(3,4)25

2.附2个lambda下常用的BIF：

A.filter()过滤器函数。filter有两个参数，第一个参数为function或是None，第二个参数为一个iterable。如果一个参数是function，则将第二个参数iterable中的每一个元素作为function的参数进行计算，筛选出返回True的值，并成为一个列表；如果第一个参数为None，则筛选出第二个参数iterable中返回True的值。也就是说过滤掉任何非True的值。

help(filter)
Help on class filter in module builtins:

class filter(object)
| filter(function or None, iterable) –> filter object
|
| Return an iterator yielding those items of iterable for which function(item)is true. If function is None, return the items that are true.

例1.奇数过滤器
一般写法：

>>> def odd(x):                return x % 2>>> temp = range(10)>>> show = filter(odd,temp)>>> list(show)[1, 3, 5, 7, 9]>>>lambda`写法：list(filter(lambda x:x % 2,range(10)))

B.map() 编程中 map() 一般表示映射，map() 有两个参数，第一个参数为function，第二个参数为一个iterable序列。功能是将序列的每一个元素作为函数的参数进行运算加工，直到可迭代序列的每一个元素都加工完毕，返回所有加工后的元素构成的新序列。

>>> list(map(lambda x:x * 2,range(10)))[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

将range(10)中的每一个元素代入参数x，返回的值加工成列表。

六、递归：函数调用自身的行为。
递归的两个条件，一是有调用函数自身的行为，二是有正确的返回条件。否则就是死循环，不是完整的递归。

1.例，写一个求阶乘的函数。
要求：正整数阶乘指从1*2*3*4….一直乘到所要求的数；

循环写法：
例如所给的数是5，则阶乘式是1*2*3*4*5，得到的积就是120，所以120就是4的阶乘。

def factorial(x):    result = x    for i in range(1,x):        result *= i    return resultnum = int(input('请输入一个正整数：'))result = factorial(num)print('%d 的阶乘是 %d' % (num,result))请输入一个正整数：55 的阶乘是 120

递归写法：

def factorial(x):    if x == 1:        return 1    else:        return x * factorial(x-1)num = int(input('请输入一个正整数：'))result = factorial(num)print('%d 的阶乘是%d' % (num,result))