先跳过一下第四章，并非第四章不重要，先总结核心语法部分的内容，后续再补吧。
在Python中函数是一等对象。编程语言理论家把“一等对象”定义为满足以下条件的程序实体：
- 在运行时创建
- 能赋值给变量或者数据结构中的元素
- 能作为参数传给函数
- 能作为函数的返回结果
在Python中，整数，字符串和字典都是一等对象--没什么特别的。
把函数视为对象
def factorial(n): '''returns n!''' return 1 if n < 2 else n * factorial(n - 1) print(factorial(10)) print(factorial.__doc__) # returns n! print(type(factorial)) # <class 'function'> factorial 是function的实例
我们创建一个函数，读取doc，并确定它是function类的实例。
下例就可以体现函数的一等性：
fc = factorial print(fc(10))
高阶函数
接受函数作为参数，或者把函数作为结果返回的函数是高阶函数。比方说sorted函数：
fruits = ['fig', 'apple', 'cherry', 'ba'] print(sorted(fruits, key=len))
任何单参数函数都能作为key参数的值
函数式语言中通常会提供map，filter和reduce三个高阶函数。在Python3中，map和filter还是内置函数，但是由于引入列表推导和生成器表达式，它们变得没那么重要了：
print(list(map(fc, range(6)))) # 使用map print(list(fc(n) for n in range(6))) # 使用列表推导 print(list(map(fc, filter(lambda n: n%2, range(6))))) print(list(fc(n) for n in range(6) if n%2)) # 使用列表推导能替换掉map和filter
在Python2中。reduce是内置函数，但是在Python3中放到functools模块里了。这个函数最常用于求和，自2.3起，最好使用sum函数
reduce(add, range(100)) sum(range(100)) # 与上面等价
匿名函数
lambda 关键字在Python表达式内创建匿名函数。
fruits = ['fig', 'apple', 'cherry', 'ba'] print(sorted(fruits, key=lambda word: word[::-1]))
Python简答的句法限制了lambda函数的定义体只能使用纯表达式。换句话说，lambda函数的定义体中不能赋值，也不能使用while和try等Python语句。除了作为参数传给高阶函数之外，Python很少使用匿名函数。lambda句法就是简单的语法糖。
可调用对象
除了用户定义的函数，调用运算符（即 ()）还可以应用到其他对象上。如果想判断对象能否调用，可以使用内置的callable()函数。文档列举了7种可调用对象：
用户定义的函数：使用def语句或者lambda表达式创建。
内置函数：使用C实现的函数，例如len或者time.strftime。
内置方法：使用C实现的方法，如dict.get。
方法：在类的定义体中定义的函数。
类：调用类时会运行__new__方法创建一个实例，然后运行__init__方法，初始化实例，最后把实例返回给调用方。
类的实例：如果定义了__call__方法，那么它的实例可以作为函数调用。
生成器函数：使用yield关键字的函数或方法。
用户定义的可调用类型
不仅Python函数是真正的对象，任何Python对象都可以表现的像函数。为此只需要实现__call__方法。
class BingoCage: 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): return self.pick() bingo = BingoCage(range(3)) item = bingo() # 会访问 call方法
实现__call__方法的类是创建函数类对象的简便方式，此时必须在内部维护一个状态，让它在调用之间可用。装饰器就是这样，装饰器必须是函数，而且有时要在多次调用之间“记住”某些事[例如备忘，即缓存消耗大的计算结果，供后面使用]。
函数内省
除了doc，函数对象还有很多属性，使用dir可以探知factorial具体属性
print(dir(factorial)) # ['__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__']
其中大部分属性是Python对象共有的。下面说明一下函数专有而用户定义的一般对象没有的属性：
| 名称 | 类型 | 说明 |
| __annotations__ | dict | 参数和返回值的注解 |
| __call__ | method-wrapper | 实现()运算符；即可调用对象协议 |
| __closure__ | tuple | 函数闭包，即自由变量的绑定 |
| __code__ | code | 编译成字节码的函数元数据和函数定义体 |
| __defaults__ | tuple | 形式参数的默认值 |
| __get__ | method-wrapper | 实现只读描述符协议 |
| __globals__ | dict | 函数所在模块中的全局变量 |
| __kwdefaults__ | dict | 仅限关键字形式参数的默认值 |
| __name__ | str | 函数名称 |
| __qualname__ | str | 函数的限定名称，如Random.chice |
从定位参数到仅限关键字参数
Python最好的特性之一是提供了极为灵活的参数处理机制，而Python3进一步提供了仅限关键字参数。
def tag(name, *content, cls=None, **attrs): 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) my_tags = {'name':'img', 'title':'Sunset Boulevard', 'src':'sunset.jpg','cls':'framed'} print(tag(**my_tags)) # 其他使用方式不说明，之前大概都有提过，简单说一下最后这个参数。 # 在my_tags前面加**，所有参数会被看作单参数传入，对应到其命名部分 # 其余多余出来的，会传入最后那个**attrs 里面
cls参数只能通过关键词传入，它不会捕获未命名定位参数（会被content全截了）。
最后说一下，命名定位的话就和传参顺序没有关系了
def test_in(a, b, c): return a*a - b - c print(test_in(c = 3, a = 2, b = 1)) # 这样之后就可以无视顺序函数会自动对应到其位置
获取关于参数的信息
HTTP微框架Bobo中有个使用函数内省的好例子。示例5-12是对Bobo教程中“Hello world”应用的改编，说明了内省怎么使用。
@bobo.query('/') def hello(person): return 'Hello %s!' % person
Bobo会内省hello函数，发现它需要一个名为person的参数，然后从请求中获取那个名称对应的参数，将其传给hello函数，因此程序员不用触碰请求对象。（这部分后续补吧，我还没太弄明白要怎么使用函数内省）
函数注解
def clip(text:str, max_len:'int > 0' = 80) -> str: '''在max_len前面或后面的第一个空格处截断文本''' end = None if len(text) > max_len: space_before = text.rfind(' ', 0, max_len) if space_before >= 0: end = space_before else: space_after = text.rfind(' ', max_len) if space_after >= 0: end = space_after if end is None: # 没找到空格 end = len(text) return text[:end].rstrip() print(clip.__annotations__) # {'text': <class 'str'>, 'max_len': 'int > 0', 'return': <class 'str'>}
函数声明中的各个参数可以在：之后增加注解表达式。如果参数有默认值，注解放在参数名和=号之间。如果想注解返回值，在 ) 和函数声明末尾的 : 之间添加 -> 和一个表达式。表达式可以为任何类型。注解中最常用的类型是类（如str或int）和字符串（如'int > 0'）。函数注解最大的影响或许不是让Bobo等框架自动设置，而是为IDE和lint程序等工具中的静态类型检查功能提供额外的类型信息。
支持函数式编程的包
operator模块
求和可以用sum但是求积没有这样的函数，可以用reduce和lambda解决：
def fact(n): return reduce(lambda a, b: a*b, range(1, n+1))
但是operator模块为多个算术运算符提供了对应的函数。
def fact(n): return reduce(mul, range(1, n+1)) triple = partial(mul, 3) print(triple(7)) print(mul(3, 7))
其余的内容不赘述了，triple是一个绑定，这里就是绑定了3和mul，也就是说 triple(7) 是 3*7 的意思。还有itemgetter是一个用来给第i位排序的（元祖列表，按第i位排序用的）。