深入理解python中的函数

一等函数

把函数视作对象

Python 函数是对象。这里我们创建了一个函数，然后调用它，读取它的__doc__ 属性，并且确定函数对象本身是function 类的实例

def factorial(n):
    """return n!"""
    return 1 if n < 2 else n*factorial(n-1)

print(factorial(10))    # 3628800
# __doc__ 是函数对象众多属性中的一个,用于生成对象的帮助文本
print(factorial.__doc__)    # return n!
print(type(factorial))  # <class 'function'>

# 我们可以把factorial 函数对象给变量fact，然后通过变量名调用
fact = factorial
print(fact)     # <function factorial at 0x0000021A9F7E8400>
120
print(fact(5))    # 120
list(map(fact, range(11)))   
 # [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]

高阶函数

接受函数为参数，或者把函数作为结果返回的函数是高阶函数（higher-order function）

fruits = ['strawberry', 'fig', 'apple', 'cherry', 'raspberry', 'banana']
# 内置函数sorted就是高阶函数：可选的key 参数用于提供一个函数
sorted(fruits, key=len)     
# ['fig', 'apple', 'cherry', 'banana', 'raspberry', 'strawberry']

def reversed(word):
    return word[::-1]
sorted(fruits, key=reversed)    
# ['banana', 'apple', 'fig', 'raspberry', 'strawberry', 'cherry']

# 匿名函数lambda
sorted(fruits, key=lambda word:word[::-1])
['banana', 'apple', 'fig', 'raspberry', 'strawberry', 'cherry']

除此之外，常见的高阶函数还有map，filter, functools.reduce，map 和filter 返回生成器。

可调用对象
除了用户定义的函数，调用运算符（即()）还可以应用到其他对象上。如果想判断对象能否调用，可以使用内置的callable() 函数

>>> [callable(obj) for obj in (abs, str, 13, reversed)]
[True, True, False, True]

""" 不仅Python 函数是真正的对象，任何Python 对象都可以表现得像函数"""
class BingoCage(object):
    def __init__(self, items):
        self.items = list(items)
    def pick(self):
        try:
            return self.items.pop()
        except IndentationError:
            raise LookupError('pick from empty Bingocage')
    def __call__(self):
        print('call me!')
        return self.pick()
        
>>> bingo = BingoCage(range(3))
>>> bingo.pick()    
2
>>> bingo()     
call me! 
1
>>> bingo()     
call me! 
1

函数内省
使用dir()函数查看函数的属性

>>> dir(factorial)
['__annotations__',
 '__call__',
 '__class__',
 '__closure__',
 '__code__',
 '__defaults__',
 ...]

仅限关键字参数
调用函数时使用* 和**是可迭代对象，映射到单个参数

def func(name, *args, age=18, **kwargs):
    for s in args:
        print(s)
    if kwargs:
        for k,v in kwargs.items():
            print(k,v)
    print("age is :",age)
    print("my name is :",name)
    
>>> func('john')
age is : 18
my name is : john

""" 第一个参数后面的任意个参数会被*args 捕获，存入一个元组 """
>>> func('john','alice','bob')
alice
bob
age is : 18
my name is : john

""" 没有明确指定名称的关键字参数会被**kwargs 捕获，存入一个字典
 age参数只能作为关键字参数传入"""
>>> func('john','alice',age=30,hallie=12, eric=31)
eric 12
age is : 18
my name is : zude

operator模块
operator 模块为多个算术运算符提供了对应的函数，从而避免编写lambda a, b: a*b 这种匿名函数

from functools import reduce
from operator import mul
from operator impoer itemgetter

def fact1(n):
    return reduce(lambda a,b:a*b, range(1, n+1))
def fact2(n):
    return reduce(mul ,range(1, n+1))
    
>>> metro_data = [
... ('Tokyo', 'JP', 36.933, (35.689722, 139.691667)),
... ('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889))]

# 任何实现__getitem__ 方法的类都可以使用itemgetter
>>> for city in sorted(metro_data, key=itemgetter(1)):
        print(city)

使用一等函数实现设计模式

来看一个小例子，假如一个网店制定了下述折扣规则

• 有1000 或以上积分的顾客，每个订单享5% 折扣。
• 同一订单中，单个商品的数量达到20 个或以上，享10% 折扣。
• 订单中的不同商品达到10 个或以上，享7% 折扣。
  简单起见，我们假定一个订单一次只能享用一个折扣。 我们使用抽象基类和函数实现策略，代码如下

from abc import ABC, abstractmethod
from collections import namedtuple
Customer = namedtuple('Customer', 'name fidelity')

class LineItem(object):
    def __init__(self, product, quantity, price):
        self.product = product
        self.quantity = quantity
        self.price = price
    def total(self):
        return self.price * self.quantity
        
class Order(object):
    def __init__(self, customer, cart, promotion=None):
        self.customer = customer
        self.cart = list(cart)
        self.promotion = promotion
    def total(self):
        if not hasattr(self, '__total'):
            self.__total = sum(item.total() for item in self.cart)
        return self.__total
    
    def due(self):
        if self.promotion is None:
            discount = 0
        else:
            discount = self.promotion.discount(self)
        return self.total() - discount
    
    def __repr__(self):
        fmt = '<Order total: {:.2f} due: {:.2f}>'
        return fmt.format(self.total(), self.due())

# 把Promotion定义为抽象基类（Abstract Base CLASS）,
# 为了使用@abstractmethod装饰器,表明所用的模式
class Promotion(ABC):
    @abstractmethod
    def discount(self, order):
        """返回折扣金额（正值）"""

class FidelityPromo(Promotion):
    """为积分为1000或以上的顾客提供5%折扣"""
    def discount(self, order):
        return order.total() * .05 if order.customer.fidelity >= 1000 else 0

class BulkItemPromo(Promotion):
    """单个商品为20个或以上时提供10%折扣"""
    def discount(self, order):
        discount = 0
        for item in order.cart:
            if item.quantity >= 20:
                discount += item.total() * .1
        return discount
    
class LargeOrderPromo(Promotion):
    """订单中的不同商品达到10个或以上时提供7%折扣"""
    def discount(self, order):
        distinct_items = {item.product for item in order.cart}
        if len(distinct_items) >= 10:
            return order.total() * .07
        return 0

结果测试如下：

joe = Customer('John Doe', 0)
ann = Customer('Ann Smith', 1100)
cart = [LineItem('banana', 4, .5), 
        LineItem('apple', 10, 1.5),
        LineItem('watermellon', 5, 5.0)]
Order(joe, cart, FidelityPromo()) # <Order total: 42.00 due: 42.00>
Order(ann, cart, FidelityPromo()) # <Order total: 42.00 due: 39.90>

我们也可以进行迭代操作，找到折扣额度最大的

promos = [fidelity_promo, bulk_item_promo, large_order_promo] 
def best_promo(order): 
    """选择可用的最佳折扣"""
    return max(promo(order) for promo in promos)

函数装饰器和闭包

装饰器的一个关键特性是，它们在被装饰的函数定义之后立即运行。这通常是在导入时（即Python 加载模块时），如示例所示

registry = []
def register(func): 
    print('running register(%s)' % func)
    registry.append(func)
    return func 

@register 
def f1():
    print('running f1()')

@register
def f2():
    print('running f2()')

def f3(): 
    print('running f3()')

def main(): 
    print('running main()')
    print('registry ->', registry)
    f1()
    f2()
    f3()
    
if __name__=='__main__':
    main()
    
results:
running register(<function f1 at 0x00000220D84EA488>)
running register(<function f2 at 0x00000220D84EA1E0>)
running main()
registry -> [<function f1 at 0x00000220D84EA488>, <function f2 at 0x00000220D84EA1E0>]
running f1()
running f2()
running f3()

函数装饰器在导入模块时立即执行，而被装饰的函数只在明确调用 时运行。这突出了Python 程序员所说的导入时和运行时之间的区别

闭包
在函数体内定义函数

def make_averager():
    series = []
    def averager(new_value):
        series.append(new_value)
        total = sum(series)
        return total/len(series)
    return averager

avg = make_averager()
print(avg(10)) # 10.0
print(avg(11) # 10.5

"""
series 是make_averager 函数的局部变量，因为那个函数的定义体中初始化了
series：series = []。可是，调用avg(10) 时，make_averager 函数已经返回了，
而它的本地作用域也一去不复返了
"""
# 审查返回的average对象
avg.__code__.co_varnames   # ('new_value', 'total')

# 自由变量
avg.__code__.co_freevars    # ('series',)

# 有个cell_contents 属性，保存着真正的值
avg.__closure__[0].cell_contents    # [10, 11]

nonlocal声明

def make_averager():
    count = 0
    total = 0
    def averager(new_value):
        count += 1
        total += new_value
        return total / count
    return averager

avg = make_averager()
print(avg(10))

---------------------------------------------------------------------
UnboundLocalError                         Traceback (most recent call last)
<ipython-input-25-3f4d448a9326> in <module>()
      9 
     10 avg = make_averager()
---> 11 print(avg(10))

<ipython-input-25-3f4d448a9326> in averager(new_value)
      3     total = 0
      4     def averager(new_value):
----> 5         count += 1
      6         total += new_value
      7         return total / count

UnboundLocalError: local variable 'count' referenced before assignment

问题是，当count 是数字或任何不可变类型时，count += 1 语句的作用其实与count = count + 1 一样。因此，我们在averager 的定义体中为count 赋值了，这会把count 变成局部变量。total 变量也受这个问题影响。上个例子没遇到这个问题，因为我们没有给series 赋值，我们只是调用series.append，并把它传给sum 和len。也就是说，我们利用了列表是可变的对象这一事实。
但是对数字、字符串、元组等不可变类型来说，只能读取，不能更新。如果尝试重新绑定，例如count = count+1，其实会隐式创建局部变量count。这样，count 就不是自由变量了，因此不会保存在闭包中

使用nonlocal把变量标记为自由变量，即使在函数中为变量赋予新值了，也会变成自由变量

def make_averager():
    count = 0
    total = 0
    def averager(new_value):
        nonlocal count, total
        count += 1
        total += new_value
        return total/count
    return averager

avg = make_averager()
print(avg(10)) # 10.0
print(avg(11)) # 10.5

更多关于装饰器的内容可以参考：https://blog.csdn.net/John_xyz/article/details/84190920