我的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)
'function'>
-- i等于返回 x 的值，需要得到 x * y 的返回值，需要调用i(y) -->
>>> i(5)
40
也可以直接操作:
>>> funx(8)(5)
40
funy()是内部函数，不能在外部被调用
>>> funy(5)
Traceback (most recent call last):
` File "", 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 "", line 1, in 
    print(funa())
  File "", line 6, in funa
    return funb()
  File "", line 4, in funb
    x *= x
UnboundLocalError: 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
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
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 result

num = int(input('请输入一个正整数：'))
result = factorial(num)
print('%d 的阶乘是 %d' % (num,result))

请输入一个正整数：5
5 的阶乘是 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))