流畅的Python第五章，一等函数笔记

Python中又一个名称叫一等对象，满足以下条件的程序实体：

1、在运行时创建

2、能赋值给变量或数据结构中的元素

3、能作为参数传给函数

4、能作为函数的返回结果

所以Python中，正数、字符串、字典与函数都是一等对象。

5.1把函数当做对象:

把函数当做对象，通过简单的__doc__可以输出函数的说明。

In [55]: def demo(a,b): 
    ...:     '''返回a,b''' 
    ...:     return a,b 
    ...:                                                                                                                

In [56]: demo.__doc__                                                                                                   
Out[56]: '返回a,b'

In [57]:  

 通过高阶函数把函数传递进去。

def fact(n):
    '''returns n!'''
    return 1 if n < 2 else n * fact(n - 1)

print(list(map(fact, range(10))))

[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]

 fact就是传递进去的函数。

5.2高阶函数

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

map,filter，reduce，包括sorted都是高阶，sorted的key可以接收函数.

按照这个定义，我们的闭包函数，装饰器函数，都可以称为高阶函数。

map,filter和reduce的现代替换品

map与filter因为列表生成式的使用，基本很多需要使用他们的地方都可以用列表生成式。

def fact(n):
    '''returns n!'''
    return 1 if n < 2 else n * fact(n - 1)

'''
接收函数为参数，或者把函数作为结果返回的函数是高阶函数。
所以，map,filter,reduce,sorted(因为key能接收函数)
'''

print(fact(10))

print(list(map(fact, range(10))))   # map需要传入函数fact

print([fact(i) for i in range(10)])   # 直接列表生成式，每个参数直接使用了函数fact，产生的返回值放入列表。

print(list(map(fact, filter(lambda n : n % 2, range(10)))))   # 在map的函数后面的可迭代对象进行了filter的过滤，需要能被2整除

# filter第一个只返回：后面条件成立的数值。
def condition(n):
    if n % 2 != 0:
        return n
print(list(map(fact, filter(condition, range(10)))))

print([fact(i) for i in range(10) if i % 2])     # 列表生成式第一个写函数或者参数，第二个写循环体，第三个写条件。
# 书中直接写if i % 2应该就是! % 2不能为0，这个写法更加精简。所以以后条件如果返回只要是真，写入就可以，生成的时候就会执行。
print([fact(i) for i in range(10) if i % 2 !=0])   # 如果我写，我一半写成这样。

/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第五章/高级函数.py
3628800
[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]
[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]
[1, 6, 120, 5040, 362880]
[1, 6, 120, 5040, 362880]
[1, 6, 120, 5040, 362880]

Process finished with exit code 0

 reduce现在用的很少，一般用在求和上面。

from functools import reduce
from operator import add

def s_add(x, y):
    return x + y

print(reduce(add, range(100)))
print(reduce(s_add, range(100)))
print(sum(range(100)))

/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第五章/t5.2.py
4950
4950
4950

Process finished with exit code 0

 归约函数all,any是蛮好的函数.

all(iterable)  里面的可迭代对象全部为真返回真。（有点像and）

any(iterable) 有一个真就返回真。 （有点像or）

a1 = '1232434'
a2 = [1, 2, 3, 0]
a3 = {'name': 'sidian', 'age': None}
a4 = (None, 9, 8)

print(a1, all(a1), any(a1))
print(a2, all(a2), any(a2))
print(a3, all(a3), any(a3))
print(a4, all(a4), any(a4))

1232434 True True
[1, 2, 3, 0] False True
{'name': 'sidian', 'age': None} True True
(None, 9, 8) False True

5.3匿名函数

lambda是Python表达式内创建匿名函数。然而Python简单的语法限制了lambda函数的定义题只能使用纯表达式。换句话说，lambda函数的定义体中不能赋值，也不能使用while和try等Python语句。

lambda(init:return)，lambda函数通过分号相隔，前面是输入参数，后面是返回参数。

lambda语法是语法糖，更def一样，会创建可以调用的函数对象。

5.4可调用对象

可调用对象就是能用()的对像(里面有__call__的方法)，可以用callable来测试是否是可调用对象，Python数据模型里面有7种可调用对象。

1、用户定义的函数

比如使用def或者lambda创建的对象。

2、内置函数

使用C语言显示的函数，比如len或time.strftime

3、内置方法

使用C语言实现的方法，比如dict.get

4、方法

在类的实体中定义的函数

5、类

在实例化类的使用，首先调用的是__call__，然后调用__new__创建对象，最后__init__来初始化对象。

6、类的实例

在类里面定义了__call__，那么实例就可以成为调用对象。

7、生成器

调用生成器函数可以返回一个生成器对象。

5.5 用户定义的可调用类型。

通过类里面给予定义函数__call__

import random

class BingCage:

    def __init__(self, items):
        self._items = list(items)     # 设置成私有变量
        random.shuffle(self._items)

    def pick(self):
        try:
            return self._items.pop()
        except IndexError:
            raise LookupError('pick from empty BingoCage')

    def __call__(self, *args, **kwargs):     # 让对象拥有call方法，能直接被调用
        return self.pick()

bingo = BingCage('abc')
for i in range(5):
    try:
        print(bingo.pick())
    except LookupError as e:
        print(e)

/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第五章/t_5.5.py
b
c
a
pick from empty BingoCage
pick from empty BingoCage

Process finished with exit code 0

5.6 函数内省

函数有很多属性，我们通过dir来查看。

dir(lambda x : x[2])                                                                                           
Out[57]: 
['__annotations__',
 '__call__',
 '__class__',
 '__closure__',
 '__code__',
 '__defaults__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__get__',
 '__getattribute__',
 '__globals__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__kwdefaults__',
 '__le__',
 '__lt__',
 '__module__',
 '__name__',
 '__ne__',
 '__new__',
 '__qualname__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__']

 首先说一个，函数对象有__dict__属性，所以可以通过.或者setattr来进行属性赋值，这个我以前还真不知道。（但一般很少对函数对象进行属性赋值）

def demo(): 
    ...:     ... 
    ...:                                                                                                                

In [63]: demo.abc = 'abc'                                                                                               

In [64]: demo.__dict__                                                                                                  
Out[64]: {'abc': 'abc'}

In [65]: setattr(demo,'name','sidian')                                                                                  

In [66]: demo.name                                                                                                      
Out[66]: 'sidian'

In [67]: demo.__dict__                                                                                                  
Out[67]: {'abc': 'abc', 'name': 'sidian'}

In [68]:                                                                                                                

 下面列出函数独有，但对象没有的属性，我准备跟类也对比一下。

class C:
    ...

def func():
    ...

c = C()

print(set(dir(C)) - set(dir(func)))
print(set(dir(func)) - set(dir(C)))
print(set(dir(c)) - set(dir(func)))
print(set(dir(func)) - set(dir(c)))

/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第五章/t_5.6.py
{'__weakref__'}
{'__annotations__', '__get__', '__globals__', '__call__', '__name__', '__qualname__', '__code__', '__kwdefaults__', '__defaults__', '__closure__'}
{'__weakref__'}
{'__annotations__', '__get__', '__globals__', '__call__', '__name__', '__qualname__', '__code__', '__kwdefaults__', '__defaults__', '__closure__'}
Hello sidian

Process finished with exit code 0

 从中可以看出来，对象或者类比函数对了一个属性__weakref__，我查了一些资料好像是关于垃圾回收相关，具体资料很少。

https://stackoverflow.com/questions/36787603/what-exactly-is-weakref-in-python这个链接有一些英文的答案。

但函数比对象多了很多属性。

__closure_是闭包函数里面取值的。

__kwdefaults__是查看*后面的关键字默认参数

5.7从实际参数到仅限关键字参数。

def tag(name, *content, cls=None, **attrs):
    '''生成一个或多个HTML标签'''
    if cls is not None:
        attrs['class'] = cls
    if attrs:
        attr_str = ''.join(' %s="%s" ' % (attr, value)
                           for attr, value
                           in sorted(attrs.items()))
    else:
        attr_str = ''
    if content:
        return '
'.join(f'<{name}{attr_str}>{c}</{name}>' for c in content)
    else:
        return "<%s%s />" % (name, attr_str)


if __name__ == '__main__':
    print(tag('br'))
    print(tag('p', 'hello', 'world'))
    print(tag('p', 'hello', 'world', cls='sidebar'))
    print(tag(content='testing', name='img'))
    print(tag(**{'name': 'img', 'title': 'Sunset Boulevard', "src": 'sunset.jpg', 'cls': 'framed'}))

/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第五章/t5-7.py
<br />
<p>hello</p>
<p>world</p>
<p class="sidebar" >hello</p>
<p class="sidebar" >world</p>
<img content="testing"  />
<img class="framed"  src="sunset.jpg"  title="Sunset Boulevard"  />

Process finished with exit code 0

 上面的代码还是比较简单的，就是cls成为了传参关键字参数，如果不用cls关键字传参，它永远都是默认值None

如果不需要*后面的参数，可以直接写一个*

In [836]: def f(a, *, b): 
     ...:     return a,b 
     ...:      
     ...:                                                                                                               

In [837]: f(1,b=2)                                                                                                      
Out[837]: (1, 2)

In [838]: f(1, 2)                                                                                                       
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-838-c9c271413adf> in <module>
----> 1 f(1, 2)

TypeError: f() takes 1 positional argument but 2 were given

 上面的代码，b成了关键字必填写参数。

5.8获取关于参数信息。

def clip(text, max_len=8):
    '''
    :param text: 在max_len前面或后面的第一个空格处截断文本
    '''
    end = None
    if len(text) > max_len:
        space_before = text.rfind(' ', 0, max_len)  # 从右向左找，rfind，对应max_len前面的第一个空格
        if space_before >= 0:
            end = space_before
        else:
            space_after = text.find(' ', max_len) # 找max_len的后面了
            if space_after >= 0:
                end = space_after
    if end is None:   # 没有找到，很聪明定义了一个None的开关
        end = len(text)
    return text[:end].rstrip()


string = '进入空格该文件的目录, 空格运行后 没有相关提示，报其他错了。'
print(clip(string))
print(clip.__code__.co_varnames)

这个一个截取字段串的代码：

('text', 'max_len', 'end', 'space_before', 'space_after')
In [6]: from t_5_8 import clip                                                                            

In [7]: clip.__code__.co_varnames                                                                         
Out[7]: ('text', 'max_len', 'end', 'space_before', 'space_after')

In [8]: clip.__code__.co_argcount                                                                         
Out[8]: 2

In [9]: clip.__defaults__                                                                                 
Out[9]: (8,)

In [10]: clip.__code__.co_name                                                                            
Out[10]: 'clip'

In [11]:  

 这是通过一些函数方法取出来的参数，感觉不是很好，后面通过inspect 来取出函数的参数。

In [16]: from inspect import signature                                                                    

In [17]: sig = signature(clip)                                                                            

In [18]: sig                                                                                              
Out[18]: <Signature (text, max_len=8)>

In [19]: str(sig)                                                                                         
Out[19]: '(text, max_len=8)'

In [20]: dir(sig)                                                                                         
Out[20]: 
['__class__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__setstate__',
 '__sizeof__',
 '__slots__',
 '__str__',
 '__subclasshook__',
 '_bind',
 '_bound_arguments_cls',
 '_hash_basis',
 '_parameter_cls',
 '_parameters',
 '_return_annotation',
 'bind',
 'bind_partial',
 'empty',
 'from_builtin',
 'from_callable',
 'from_function',
 'parameters',
 'replace',
 'return_annotation']

In [21]: for name, param in sig.parameters.items(): 
    ...:     print(param.kind,':', name,'=',param.default) 
    ...:                                                                                                  
POSITIONAL_OR_KEYWORD : text = <class 'inspect._empty'>
POSITIONAL_OR_KEYWORD : max_len = 8

for name, param in tag.parameters.items(): 
    ...:     print(param.kind,':', name,'=',param.default) 
    ...:      
    ...:                                                                                                  
POSITIONAL_OR_KEYWORD : name = <class 'inspect._empty'>
VAR_POSITIONAL : content = <class 'inspect._empty'>
KEYWORD_ONLY : cls = None
VAR_KEYWORD : attrs = <class 'inspect._empty'>

In [25]: tag.parameters.items()                                                                           
Out[25]: odict_items([('name', <Parameter "name">), ('content', <Parameter "*content">), ('cls', <Parameter "cls=None">), ('attrs', <Parameter "**attrs">)])

In [26]: tag.parameters['name']                                                                           
Out[26]: <Parameter "name">

In [27]: dir(tag.parameters['name'])                                                                      
Out[27]: 
['KEYWORD_ONLY',
 'POSITIONAL_ONLY',
 'POSITIONAL_OR_KEYWORD',
 'VAR_KEYWORD',
 'VAR_POSITIONAL',
 '__class__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__setstate__',
 '__sizeof__',
 '__slots__',
 '__str__',
 '__subclasshook__',
 '_annotation',
 '_default',
 '_kind',
 '_name',
 'annotation',
 'default',
 'empty',
 'kind',
 'name',
 'replace']

In [28]: tag.parameters['name'].name                                                                      
Out[28]: 'name'

In [29]: tag.parameters['content'].name                                                                   
Out[29]: 'content'

In [30]: tag.parameters.annotation                                                                        
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-30-ca6845388021> in <module>
----> 1 tag.parameters.annotation

AttributeError: 'mappingproxy' object has no attribute 'annotation'

In [31]: tag.parameters                                                                                   
Out[31]: 
mappingproxy({'name': <Parameter "name">,
              'content': <Parameter "*content">,
              'cls': <Parameter "cls=None">,
              'attrs': <Parameter "**attrs">})

In [32]: tag.parameters['content'].annotation                                                             
Out[32]: inspect._empty

 从inspect.signature对象中我们可以方便的看到函数的行参，通过str可以

从对象的parameters字典中，里面的value有下面这些普通的属性。

'annotation',
 'default',
 'empty',
 'kind',
 'name',
 'replace'

通过调用kind属性获取不同的值。

POSITIONAL_OR_KEYWORD : name = <class 'inspect._empty'>     可以通过定位参数和关键字参数传入的行参
VAR_POSITIONAL : content = <class 'inspect._empty'>         可以定位参数的元祖
KEYWORD_ONLY : cls = None                                 仅限关键字参数
VAR_KEYWORD : attrs = <class 'inspect._empty'>                关键字参数字典


inspect.signature其实还有一个bind的方法，它可以模拟实参传递的过程，如果参数不对，会报错。

In [36]: tag                                                                                              
Out[36]: <Signature (name, *content, cls=None, **attrs)>

In [37]: my_tag = {'name': 'img', 'title': 'Sunset Boulevard', "src": 'sunset.jpg', 'cls': 'framed'}      

In [38]: bound_args = tag.bind(**my_tag)                                                                  

In [39]: bound_args                                                                                       
Out[39]: <BoundArguments (name='img', cls='framed', attrs={'title': 'Sunset Boulevard', 'src': 'sunset.jpg'})>

In [40]: for name, value in bound_args.arguments.items(): 
    ...:     print(name,'=',value) 
    ...:                                                                                                  
name = img
cls = framed
attrs = {'title': 'Sunset Boulevard', 'src': 'sunset.jpg'}

In [41]: del my_tag['name']                                                                               

In [42]: bound_args = tag.bind(**my_tag)                                                                  
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-42-137b62789a71> in <module>
----> 1 bound_args = tag.bind(**my_tag)

/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/lib/python3.7/inspect.py in bind(*args, **kwargs)
   3013         if the passed arguments can not be bound.
   3014         """
-> 3015         return args[0]._bind(args[1:], kwargs)
   3016 
   3017     def bind_partial(*args, **kwargs):

/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/lib/python3.7/inspect.py in _bind(self, args, kwargs, partial)
   2928                             msg = 'missing a required argument: {arg!r}'
   2929                             msg = msg.format(arg=param.name)
-> 2930                             raise TypeError(msg) from None
   2931             else:
   2932                 # We have a positional argument to process

TypeError: missing a required argument: 'name'

 上面通过对象的bind属性，模拟传参的的过程，当参数中缺少必要参数时，报错。

5.9 函数注解。

def clip(text:str, max_len:'int' =8) -> str:
    '''
    :param text: 在max_len前面或后面的第一个空格处截断文本
    '''
    end = None
    if len(text) > max_len:
        space_before = text.rfind(' ', 0, max_len)  # 从右向左找，rfind，对应max_len前面的第一个空格
        if space_before >= 0:
            end = space_before
        else:
            space_after = text.find(' ', max_len) # 找max_len的后面了
            if space_after >= 0:
                end = space_after
    if end is None:   # 没有找到，很聪明定义了一个None的开关
        end = len(text)
    return text[:end].rstrip()

In [63]: from t_5_8 import clip                                                                           

In [64]: clip.__annotations__                                                                             
Out[64]: {'text': str, 'max_len': 'int', 'return': str}

In [65]:                   

 还是蛮有意思的，这样的写法感觉非常便于维护。

在参数后面添加:后面就是注释，然后在)于:之间通过->和一个表达式，添加返回的内容形式。

当然你也可以从inspect.signature获取annotation

In [65]: clip = signature(clip)                                                                           

In [66]: clip                                                                                             
Out[66]: <Signature (text: str, max_len: 'int' = 8) -> str>

In [67]: clip.return_annotation                                                                           
Out[67]: str

In [68]: str(clip)                                                                                        
Out[68]: "(text: str, max_len: 'int' = 8) -> str"

In [74]: for param in sig.parameters.values(): 
    ...:     note = repr(param.annotation).ljust(13) 
    ...:     print(note, ':', param.name, '=', param.default) 
    ...:                                                                                                  
<class 'inspect._empty'> : text = <class 'inspect._empty'>
<class 'inspect._empty'> : max_len = 8

5.10 支持函数式编程的包

主要讲了一些operator以及functools里面的一些实用模块，确实非常实用。

from functools import reduce
from operator import mul

def fact0(n):
    return reduce(lambda a, b: a* b, range(1, n))

def fact1(n):
    return reduce(mul, range(1, n))

print(fact0(100), fact1(100),sep='
')

/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第五章/t_5_10.py
933262154439441526816992388562667004907159682643816214685929638952175999932299156089414639761565182862536979208272237582511852109168640000000000000000000000
933262154439441526816992388562667004907159682643816214685929638952175999932299156089414639761565182862536979208272237582511852109168640000000000000000000000

 operator里面会让你就连写lambda的机会都没有。

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

def fact0(n):
    return reduce(lambda a, b: a* b, range(1, n))

def fact1(n):
    return reduce(mul, range(1, n))

print(fact0(100), fact1(100),sep='
')
print()

metro_data = [
    ('Tokyo', 'JP', 36.933, (35.33453, 13.93434)),
    ('Delhi NCR', 'IN', 21.935, (28.34345345, 88.123523)),
    ('Mexico City', 'MX', 20.142, (19.4546456, -99.34132343))
]

for city in sorted(metro_data, key=itemgetter(1)): # 从对象中[]取出1号参数
    print(city)

print()
cc_name = itemgetter(1,0)    # 从一个对象中通过[]取出里面的参数
for city in metro_data:
    print(cc_name(city))

/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第五章/t_5_10.py
933262154439441526816992388562667004907159682643816214685929638952175999932299156089414639761565182862536979208272237582511852109168640000000000000000000000
933262154439441526816992388562667004907159682643816214685929638952175999932299156089414639761565182862536979208272237582511852109168640000000000000000000000

('Delhi NCR', 'IN', 21.935, (28.34345345, 88.123523))
('Tokyo', 'JP', 36.933, (35.33453, 13.93434))
('Mexico City', 'MX', 20.142, (19.4546456, -99.34132343))

('JP', 'Tokyo')
('IN', 'Delhi NCR')
('MX', 'Mexico City')

Process finished with exit code 0

 itemgetter也是不给你任何机会写lambda

其实itemgetter(1) 跟lamdba x:x[1]一样,当然itrmgetter(1, 0 )于lambda x: (x[0],x[1])效果也一样。

还有一个attrgetter效果其实也差不多，只不过这个是通过.来获取属性。

from operator import attrgetter

LatLong = namedtuple('LatLong', 'lat long')
Metropolis = namedtuple('Metropolis', 'name cc pop coord')
metro_areas = [Metropolis(name, cc, pop, LatLong(lat, long))
               for name, cc, pop, (lat, long) in metro_data]
print(metro_areas[0])
print(metro_areas[0].coord.lat)

# for city in sorted(metro_areas, key=attrgetter('coord.lat')):    # 通过对象里面的coord对象的lat进行排序
for city in sorted(metro_areas, key= lambda x: x.coord.lat):    # 效果一样。
    print(city)

 本节还介绍了一个methodcaller的函数，有点意思。

它可以把对象的方法变成函数

In [82]: from operator import methodcaller                                                                

In [83]: upper_call = methodcaller('upper')                                                               

In [84]: upper_call('sdfghjk')                                                                            
Out[84]: 'SDFGHJK'

In [85]: replcae_call = methodcaller('replace', ' ', '_')                                                 

In [86]: replcae_call('123 456 789')                                                                      
Out[86]: '123_456_789'

 非常有意思的一个工具。

5.10.2实用functools.partial冻结参数。

In [87]: from operator import mul                                                                         

In [88]: from functools import partial                                                                    

In [89]: triple = partial(mul,3)                                                                          

In [90]: triple(7)                                                                                        
Out[90]: 21

In [91]: [triple(i) for i in range(10)]                                                                   
Out[91]: [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

 非常实用的一个函数，返回的也是一个函数，但这个函数已经带有默认值了，默认值就是你后面的参数。我尝试把默认值填满试试。

In [92]: triple = partial(mul,1,2)                                                                        

In [93]: triple()                                                                                         
Out[93]: 2

 果然可以

In [94]: from t5_7 import tag                                                                             

In [95]: tag                                                                                              
Out[95]: <function t5_7.tag(name, *content, cls=None, **attrs)>

In [96]: picture = partial(tag,'img',cls='pic-frame')                                                     

In [97]: picture(src='wumpus.jpg')                                                                        
Out[97]: '<img class="pic-frame"  src="wumpus.jpg"  />'

In [98]: picture.func()                                                                                   
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-98-c94e1f1add40> in <module>
----> 1 picture.func()

TypeError: tag() missing 1 required positional argument: 'name'

In [99]: picture.func                                                                                     
Out[99]: <function t5_7.tag(name, *content, cls=None, **attrs)>

In [100]: picture.args                                                                                    
Out[100]: ('img',)

In [101]: picture.keywords                                                                                
Out[101]: {'cls': 'pic-frame'}

 从partial返回的函数对象中可以看到，它的属性中含有原函数，感觉它更像一个简单的装饰器。

还有一个functoos.partialmethod函数用法于partail一样，但是用在方法上的。