函数小知识点（文档字符串，闭包等）

1 文档字符串（Documentation Strings）

    一般被称为docstring,一款你应当使用的重要工具，它能够帮助你更好地记录程序并让其更加易于理解。令人惊叹的是，当程序实际运行时，我们甚至可以通过一个函数来获取文档！

    Python 的  help()  函数，它所做的便是获取函数的  __doc__  属性并以一种整洁的方式将其呈现给你。

def print_max(x, y):

    '''Prints the maximum of two numbers.打印两个数值中的最大数。

 The two values must be integers.这两个数都应该是整数'''     #该函数的文档字符串
    # 如果可能，将其转换至整数类型
    x = int(x)　　
    y = int(y)
    if x > y:
        print(x, 'is maximum')
    else:
        print(y, 'is maximum')


print_max(3, 5)
print(print_max.__doc__)    #通过使用函数的  __doc__  属性（属于函数的名称）来获取函数  print_max  的文档字符串属性。只消记住                                                                                                            Python 将所有东西都视为一个对象，这其中自然包括函数。

---5 is maximum
---Prints the maximum of two numbers.打印两个数值中的最大数。

---The two values must be integers.这两个数都应该是整数

2 函数名的使用方法

（这玩意儿其实就是一个内存地址，可以当作变量来使用）

2.1 可以被当做值或变量引用

def func():
    print(111)


print(func)         # <function func at 0x00000218A911AB70> --函数在内存中的地址
f = func             # 将其传给变量f
print(f)                 # <function func at 0x00000279A5A6AB70>
f()                        # 111

 2.2 函数可以被当做容器类型的元素存储 

# 将其当做容器存储在列表中
def func1():
    print('func1')


def func2():
    print('func2')


def func3():
    print('func3')


lis = [func1, func2, func3]
lis[0]()        # func1
lis[1]()       # func2
lis[2]()       # func3

2.3 可以当做函数的参数和返回值

#当做参数和返回值
def func1():
    print('func1')


def func(argv):
    argv()
    return argv  # func1作为返回值


f = func(func1)  # func1作为参数
f()
# 输出
func1
func1

3 闭包

闭包： 

　　在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。

　　内层函数，对外层函数(非全局)的变量的引用

# 闭包函数的基本用法
def func():
    name = 'eva'

    def inner():
        print(name)

    return inner


f = func()       #这里不好理解，改用fun()()应该好接受一点，调用函数里面的内嵌函数
f()              # eva

闭包函数的意义及应用领域：

　　 闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域

　　应用领域：延迟计算（原来我们是传参，现在我们是包起来）

用法：

def multipliers():
    return [lambda x : i*x for i in range(4)]

print [m(2) for m in multipliers()] 

output:
# [6, 6, 6, 6]

如何输出[0,2,4,6]呢？

def multipliers():
    # 添加了一个默认参数i=i
    return [lambda x, i=i: i*x for i in range(4)]

print [m(2) for m in multipliers()] 

output:
# [0, 2, 4, 6]

 这里的multipliers就是一个闭包函数。Python的延迟绑定其实就是只有当运行嵌套函数的时候，才会引用外部变量i，不运行的时候，并不是会去找i的值，这个就是第一个函数，为什么输出的结果是[6,6,6,6]的原因。

闭包在开发中的实际作用：

　　帮助开发者维护一个“私密”空间，用于为以后执行提供数据。

def f1(a1,a2):
    def inner():
        ret = a1 + a3 
        return ret 
    return inner
    
n1 = f1('安安','张三') # 内存 a1=安安,a2=张三
n2 = f1('马哥','小鲜肉') # 内存 a1=马哥,a2=小鲜肉
n3 = f1('渣渣辉','小李子') # 内存 a1=渣渣辉,a2=小李子
n1()      

3.1 检测闭包函数的公共属性：__closure__

# 闭包函数
# 输出结果如果有 cell 就是闭包函数
def wrapper():
    name = '是闭包'
    def inner():
        print(name)  # 是闭包

    inner()
    print(inner.__closure__)        # (<cell at 0x000001945CE07588: str object at 0x000001945CE06B70>,)


wrapper()



# 非闭包函数
# 输出结果如果是 None 就不是闭包函数
name = '不是闭包'
def wrapper():
    def inner():
        print(name)  # 不是闭包

    inner()
    print(inner.__closure__)  # None


wrapper()

3.2 带有参数的闭包函数

#带有参数的闭包函数
def wrapper(a):     #a是外部传入的参数
    b = 10
    def inner():
        #在内函数inner中 用到了外函数的临时变量b
        print(a + b)        #20
    inner()    #对inner函数进行调用，这步必不可少

wrapper(10)