飛躍式發展的后現代Python世界

　　如果現代Python有一個標志性特性，那么簡單說來便是Python對自身定義的越來越模糊。在過去的幾年的許多項目都極大拓展了Python，并重建了“Python”本身的意義。

　　與此同時新技術的涌現侵占了Python的份額，并帶來了新的優勢：

1. Go - ( Goroutines, Types, Interfaces )
2. Rust - ( Traits, Speed, Types )
3. Julia - ( Speed, Types, Multiple Dispatch )
4. Scala - ( Traits, Speed, Types )
5. Clojure ( MetaPRogramming, DSLs, Protocols )

　　這是一篇Python對這些新技術、新庫及模型響應的簡短指南：

　元編程

　　MacroPy 是一個元編程框架，它提供了多種語法結構，將現代語言元素編譯成標準的Python代碼，擴展了Python AST。舉個例子，我們可以實現對代數數據類型的衡量:

from macropy.case_classes import case@caseclass Nil():    pass@caseclass Cons(x, xs):    passCons(1, Cons(2, Cons(3, Nil())))

然后模式和聲明的類型相匹配了:

def reduce(op, my_list):    with switch(my_list):        if Cons(x, Nil()):            return x        elif Cons(x, xs):            return op(x, reduce(op, xs))

　　消失的部分仍然是一個沿著camlp4路線，可擴展階段的元編程系統。但是 Mython提供了一個pgen2解析框架，給引用塊定義了新的語法，來解決這個問題。

my[namedtupledef] Point(x, y): passmy[c]:    int add (int x, int y) {        return x + y;    }print "Regular Python"

　類型

　　Python 是動態類型語言，并且引以為傲。我當然不希望對類型的“圣戰”煽風點火，但同時肯定有大學派認為構建可靠的應用程序需要有比只使用單元測試更加有力的保障。Benjamin Pierce對類型系統的定義如下：

...一種易于處理的語法，通過根據計算值的類型對詞組分類證明了缺少了特定的程序行為

　　重點是證明有關運行空間的屬性， 所有程序行為的運行空間替代了只是簡單地羅列有限種情況的運行空間。全靜態類型對于Python是否是正確的選擇讓人十分疑惑，但是在過度的動態類型和靜態類型保證之間肯定有更加合適的方案。MyPy project找到了一個不錯的平衡點，允許有類型的和沒有類型的代碼能夠同時存于語言的超集中。例如：

def simple_typed(x : int, y : int) -> int:    return x + ysimple_typed(1, 2)     # Type-checks succesfully# Fails: Argument 2 to "simple_typed" has incompatible type # "float"simple_typed(1, 2.0)# Fails: Argument 2 to "simple_typed" has incompatible type "str"simple_typed(1, "foo")

　　當然對C語言沒有太多的用處。所以我們不只限于簡單類型的函數，參數類型也有泛型，指針類型和各種各樣內建的類型級的函數。

from typing import Iterator, typevar, Generic, Function, ListT = typevar('T')def example_typed(x : Iterator[int]) -> Iterator[str]:    for i in x:        yield str(i)def example_generic(x : Iterator[T]) -> Iterator[T]:    for i in x:        yield i

　　我們也能定義更加高級的泛型結構例如函子和單元

a = typevar('a')b = typevar('b')class Functor(Generic[a]):    def __init__(self, xs : List[a]) -> None:        self._storage = xs    def iter(self) -> Iterator[a]:        return iter(self._storage)def fmap(f : Function[[a], b], xs : Functor[a]) -> Functor[b]:    return Functor([f(x) for x in xs.iter()])class Monad(Generic[a]):    def __init__(self, val : a) -> None:        self.val = valclass IdMonad(Monad):    # Monad m => a -> m a    def unit(self, x : a) -> Monad[b]:        return IdMonad(x)    # Monad m => m a -> (a -> m b) -> m b    def bind(self, x : Monad[a], f : Function[[a], Monad[b]]) -> Monad[b]:        return f(x.val)    # Monad m => m (m a) -> m a    def join(self, x : Monad[Monad[a]]) -> Monad[a]:        return x.val

　速度

　　“高性能”Python最近最重要的進展是Pandas庫提供的更高等級DataFrame容器的開發。Pandas混合各種Python進行操作，對于某些操作使用NumPy，其它的使用Cython，對于某些內部哈希表甚至使用C語言。Panda底層架構非教條式的方法已經讓它成為數據分析領域的標準庫。Pandas的開發體現了很多讓數值Python生態系統成功的東西。

In [1]: from pandas import DataFrameIn [2]: titanic = DataFrame.from_csv('titanic.csv')In [3]: titanic.groupby('pclass').survived.mean()pclass1st       0.6191952nd       0.4296033rd       0.255289Name: survived

　　然而改善Python性能最近的嘗試是利用LLVM編譯器有選擇的編譯某些Python代碼段為本地代碼。雖然不同的技術的實現方式不同，但是大部分與下述方式類似：

1. 在函數上添加@jit或@compile這樣的裝飾器。
2. 函數的AST或者bytecode被提取出來放入編譯器流水線，在流水線中被映射到內部AST，給定特定的輸入類型集合決定如何將給定的函數邏輯降低為機器代碼。
3. 編譯過的函數與一組類型一起被調用，參數被檢查過，代碼在給定類型下生成。生成的代碼連同參數被緩存使得接下來的調用直接分發到本地代碼。

　　這些項目增加了大家對Python語言技術和llvmpy項目開發的興趣，我猜測llvmpy在Python的歷史上比特定的JIT編譯器更重要。

　　最簡單的例子（來自極好的Kaleidescope教程）是創建一個簡單的本地乘加函數，然后通過解箱三個Python整數調用它：

import llvm.core as lcimport llvm.ee as lemod = lc.Module.new('mymodule')i32 = lc.Type.int(32)funty = lc.Type.function(lc.Type.int(), [i32, i32, i32])madd = lc.Function.new(mod, funty, "multiply")x = madd.args[0]y = madd.args[1]z = madd.args[2]block = madd.append_basic_block("L1")builder = lc.Builder.new(block)x0 = builder.mul(x, y)x1 = builder.add(x0, z)builder.ret(x1)print modtm = le.TargetMachine.new(features='', cm=le.CM_JITDEFAULT)eb = le.EngineBuilder.new(mod)engine = eb.create(tm)ax = le.GenericValue.int(i32, 1024)ay = le.GenericValue.int(i32, 1024)az = le.GenericValue.int(i32, 1024)ret = engine.run_function(madd, [ax, ay, az])print ret.as_int()print mod.to_native_assembly()

上述代碼編譯生成下述LLVM IR。

define i32 @multiply(i32, i32, i32) {L1:  %3 = mul i32 %0, %1  %4 = add i32 %3, %2  ret i32 %4}

　　雖然這個例子不太直觀，但是可以生成很快的JIT'd函數，與NumPy這樣的庫集成的很好，把數據做為大塊的解箱內存存儲。

　接口

　　分解行為到可組合的單元，而不是顯式的繼承層次結構是一個Python沒有解決好的問題，經常導致噩夢般的復雜的使用mixin。然而通過使用ABC模組模仿靜態定義的接口可以緩解這個問題。

import heapqimport collectionsclass Heap(collections.Sized):   def __init__(self, initial=None, key=lambda x:x):       self.key = key       if initial:           self._data = [(key(item), item) for item in initial]           heapq.heapify(self._data)       else:           self._data = []   def pop(self):       return heapq.heappop(self._data)[1]   def push(self, item):       heapq.heappush(self._data, (self.key(item), item))   def len(self):       return len(self._data)

　　例如建立一個等價類，讓所有類的實例實現eq()方法。我們可以這樣做：:

from abc import ABCMeta, abstractmethodclass Eq(object):    __metaclass__ = ABCMeta    @classmethod    def __subclasshook__(cls, C):        if cls is Eq:            for B in C.__mro__:                if "eq" in B.__dict__:                    if B.__dict__["eq"]:                        return True                    break        return NotImplementeddef eq(a, b):    if isinstance(a, Eq) and isinstance(b, Eq) and type(a) == type(b):        return a.eq(b)    else:        raise NotImplementedErrorclass Foo(object):    def eq(self, other):        return Trueclass Fizz(Foo):    passclass Bar(object):    def __init__(self, val):        self.val = val    def eq(self, other):        return self.val == other.valprint eq(Foo(), Foo())print eq(Bar(1), Bar(1))print eq(Foo(), Bar(1))print eq(Foo(), Fizz())

　　然后擴展這種類型的接口概念到多參數的函數，使得查詢__dict__越來越可能發生，在組合的情況下很脆弱。問題的關鍵是分解所有的事情到單一類型不同的接口，當我們真正想要的是聲明涵蓋一組多類型的接口時。OOP中的這種缺點是 表達式問題的關鍵。

　　諸如Scala、Haskell和Rust這樣的語言以trait和typeclass這樣的形式提供該問題的解決方案。例如Haskell可以自動地為所有類型的交叉產品推導出微分方程。

instance (Floating a, Eq a) => Floating (Dif a) where    pi               = C pi    exp (C x)        = C (exp x)    exp (D x x')     = r where r = D (exp x) (x' * r)    log (C x)        = C (log x)    log p@(D x x')   = D (log x) (x' / p)    sqrt (C x)       = C (sqrt x)    sqrt (D x x')    = r where r = D (sqrt x) (x' / (2 * r))

　異步編程

　　在這個主題下，我們還是有很多縫縫補補的解決方案，解決了部分的問題，但是引入了一整與常規Python背道而馳的套限制和模式。Gevent通過剪接底層C堆棧保持了Python自己的一致性。生成的API非常優雅，但是使得推理控制流和異常非常復雜。

import geventdef foo():    print('Running in foo')    gevent.sleep(0)    print('Explicit context switch to foo again')def bar():    print('Explicit context to bar')    gevent.sleep(0)    print('Implicit context switch back to bar')gevent.joinall([    gevent.spawn(foo),    gevent.spawn(bar),]) 

　　控制流展示在下面：

　　通過對標準庫相當不優美的縫縫補補（monkey-patching），我們可以模仿Erlang式帶有異步進入點和內部狀態的actor行為：

import geventfrom gevent.queue import Queuefrom SimplexmlRPCServer import SimpleXMLRPCServerclass Actor(object):    _export = [        'push',    ]    def __init__(self, address):        self.queue = Queue()        self._serv = SimpleXMLRPCServer(address, allow_none=True, logRequests=False)        self.address = address        for name in self._export:            self._serv.register_function(getattr(self, name))    def push(self, thing):        self.queue.put(thing)    def poll(self):        while True:            print(self.queue.get())    def periodic(self):        while True:            print('PING')            gevent.sleep(5)    def serve_forever(self):        gevent.spawn(self.periodic)        gevent.spawn(self.poll)        self._serv.serve_forever()def main():    from gevent.monkey import patch_all    patch_all()    serve = Actor(('', 8000))    serve.serve_forever()

　DSLs

　　Z3工程是嵌在Python對象層的擴展API。用Z3的實例來解決N皇后問題可以被描述為Python表達式和擴展SMT來解決問題:

from Z3 import *Q = [ Int('Q_%i' % (i + 1)) for i in range(8) ]# Each queen is in a column {1, ... 8 }val_c = [ And(1 <= Q[i], Q[i] <= 8) for i in range(8) ]# At most one queen per columncol_c = [ Distinct(Q) ]# Diagonal constraintdiag_c = [ If(i == j,               True,               And(Q[i] - Q[j] != i - j, Q[i] - Q[j] != j - i))            for i in range(8) for j in range(i) ]solve(val_c + col_c + diag_c)

　　在Theano,SymPy,PySpark中的其它工程大量使用基于Python表達式的重載操作符的方式。

from sympy import Symbolfrom sympy.logic.inference import satisfiablex = Symbol('x')y = Symbol('y')satisfiable((x | y) & (x | ~y) & (~x | y))