5. First-Class Functions

骑猪看日落 2021-12-03 06:05 240阅读 0赞

Function in python are **first-class objects **(runtime / element / argument / return)

### 1. Treating a Function Like an Object ###

def test(n):
        """ return n*2 """
        return n * 2
    
    print test(5)  # 10
    # '__doc__' is used to generate the help text of an object
    # 'help(test)' do like this in Python Interactive Console
    print test.__doc__  # ' return n*2 '
    # Function object is an instance of the function class.
    print type(test)  # <type 'function'>
    # assign it, call it, use it as an argument
    tmp = test
    print tmp(5)  # 10
    print list(map(tmp, range(5)))  # [0, 2, 4, 6, 8]

### 2. Higher-Order Functions ###

*  A function that takes a function as argument or returns a function

fruits = ['fig', 'apple', 'cherry']
    
    print sorted(fruits, key=len)  # ['fig', 'apple', 'cherry']
    # Any one-argument function can be used as the key.
    print sorted(fruits, key=lambda word: word[::-1])  # ['apple', 'fig', 'cherry']

#### 2.1 Modern Replacements for map, filter, and reduce ####

def test(n):
        return n * 2
       
    print list(map(test, range(5)))  # [0, 2, 4, 6, 8]
    print [test(n) for n in range(5)]  # [0, 2, 4, 6, 8]
    
    print list(map(test, filter(lambda n: n % 2, range(5))))  # [2, 6]
    print [test(n) for n in range(5) if n % 2]  # [2, 6]
    
    print reduce(lambda x,y: x+y, range(100))  # 4950
    print sum(range(100))  # 4950

### 3. The Seven Flavors of Callable Objects ###

*  **User-defined functions**: def or lambda.
 *  **Built-in functions**: like len or time.strftime.
 *  **Built-in methods**: like dict.get.
 *  **Methods**: functions in class.
 *  **Classes**: a class runs its \_\_new\_\_ method to create an instance, then \_\_init\_\_ to initialize it, and finally the instance is returned to the caller.
 *  **Class instances**: if a class defines a \_\_call\_\_ method, then its instances may be invoked as functions.
 *  **Generator functions**: functions or methods that use the yield keyword.

**\[notes\]**: To determine whether an object is callable, use the **callable()** built-in function.

### 4. User-Defined Callable Types ###

*  Python objects may also be made to behave like functions

class Test:
        def __init__(self, items):
            self._items = list(items)
        def pick(self):
            return self._items.pop()
        def __call__(self):
            return self.pick()
    
    t = Test(range(5))
    print t.pick()  # 4
    print t()  # 3
    print callable(t)  # True

### 5. Keyword-Only Parameters ###

*  Can only be given as a keyword argument.
 *  Python **3** only.

def tag(name, *content, cls=None, **attrs):  # cls: Keyword-Only
        """ Generate one or more HTML tags """
        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 '\n'.join('<%s%s>%s</%s>' % (name, attr_str, c, name) for c in content)
        else:
            return '<%s%s />' % (name, attr_str)
    print(tag('br'))  # <br />
    print(tag('a', 'hello', 'world', href='#'))  # <a href="#">hello</a>\n<a href="#">world</a>
    print(tag('div', 'im div~', cls='f-left'))  # <div class="f-left">im div~</div>
    print(tag(**{'name': 'img', 'id': 'my_img'}))  # <img id="my_img" />
    
    def f(a, *, b):  # b: Keyword-Only
        return a, b
    print(f(1, b=2))  # (1, 2)

### 6. Function Introspection ###

def test(n):
         return n * 2
    test.name = 'double it!'
    
    # a function uses the __dict__ attribute to store user attributes assigned to it
    print test.__dict__  # {'name': 'double it!'}

*  Attributes of functions that don’t exist in plain instances

![1614145-20190521224956506-613097820.png][]

### 7. Retrieving Information About Parameters ###

def test(a, b=2, c=3, **x):
        d = a * b * c
        return d
       
    print test.__defaults__  # (2, 3)
    # defaults for keyword-only arguments
    # print(test.__kwdefaults__)  # {'e': 3}
    print test.__code__  # <code object test at 0x...>
    # does't include any variable arguments prefixed with * or **
    print test.__code__.co_varnames  # ('a', 'b', 'c', 'd')
    print test.__code__.co_argcount  # 3

def test(a, b=2, c=3, **x):
        d = a * b * c
        return d
    
    from inspect import signature  # python 3
    tmp = signature(test)
    print(str(tmp))  # (a, b=2, c=3, **x)
    for name, param in tmp.parameters.items():
    	# 'kind' can also be: VAR_POSITIONAL / VAR_KEYWORD / KEYWORD_ONLY / POSITIONAL_ONLY
        print(param.kind)  # POSITIONAL_OR_KEYWORD
        print(name)  # a
        print(param.default)  # <class 'inspect._empty'>
    
    bind_tmp = tmp.bind(**{'a': 11, 'b': 22})
    for name, value in bind_tmp.arguments.items():
        print(name, '=', value)  # a = 11 \n b = 22

### 8. Function Annotations ###

*  Just annotation, noting else!
 *  Python **3** only.

def test(a:str, b:'in>0'=1) -> str:
        return a
    print(test('qqq', 2))  # qqq
    print(test.__annotations__)   # {'a': <class 'str'>, 'b': 'in>0', 'return': <class 'str'>}
    
    from inspect import signature  # python 3
    tmp = signature(test)
    for name, param in tmp.parameters.items():
        print(param.annotation)  # <class 'str'>
        print(param.name)  # a
        print(param.default)  # <class 'inspect._empty'>

###  9. Packages for Functional Programming ###

#### 9.1 operator ####

from operator import mul
    print mul(4, 5)  # 20
    
    
    from operator import itemgetter  # pick items from sequences
    test_data = [('b', 2), ('a', 1), ('c', 3)]
    for item in sorted(test_data, key=itemgetter(1)):  # lambda i: i[1]
        print item  # ('a', 1)
    func = itemgetter(1, 0)  # lambda i: (i[1], i[0])
    for item in test_data:
        print func(item)  # (2, 'b')
    
    
    from operator import attrgetter  # read attributes from objects
    class A:
        tmp = 1
    class B:
        a = A()
    class C:
        b = B()
        tmp = 2
    c = C()
    func = attrgetter('b.a.tmp', 'tmp')
    print func(c)  # (1, 2)
    
    
    from operator import methodcaller
    s = 'The time has come'
    my_upper = methodcaller('upper')
    print my_upper(s)  # s.upper()
    my_replace = methodcaller('replace', ' ', '-')
    print my_replace(s)  # s.replace(' ', '-')
    
    
    #['abs', 'add', 'and_', 'attrgetter', 'concat', 'contains', 'countOf',
    # 'delitem', 'eq', 'floordiv', 'ge', 'getitem', 'gt', 'iadd', 'iand',
    # 'iconcat', 'ifloordiv', 'ilshift', 'imod', 'imul', 'index', 'indexOf',
    # 'inv', 'invert', 'ior', 'ipow', 'irshift', 'is_', 'is_not', 'isub',
    # 'itemgetter', 'itruediv', 'ixor', 'le', 'length_hint', 'lshift',
    # 'lt', 'methodcaller', 'mod', 'mul', 'ne', 'neg', 'not_', 'or_', 'pos',
    # 'pow', 'rshift', 'setitem', 'sub', 'truediv', 'truth', 'xor']

#### 9.2 functools ####

def test(a, b, c):
        return a * b * c
        
    from functools import partial
    tmp = partial(test, 1, c=2)  # can't 'b=2' because 'c'
    print list(map(tmp, range(5)))  # [0, 2, 4, 6, 8]
    print test      # <function test at 0x10dca0e60>
    print tmp.func  # <function test at 0x10dca0e60>
    print tmp.args  # (1,)
    print tmp.keywords  # {'c': 2}

转载于:https://www.cnblogs.com/lb477/p/10902762.html

[1614145-20190521224956506-613097820.png]: /images/20211203/3c2d96ee73114a0f8ed64b55c66cb1cb.png