关于python:Python-中的面向接口编程

”面向接口编程“写 Java 的敌人耳朵曾经能够听出干茧了吧，当然这个思维在 Java 中十分重要，甚至简直所有的编程语言都须要，毕竟程序具备良好的扩展性、维护性谁都不能回绝。

最近无意间看到了我刚开始写 Python 时的局部代码，过后实现的需要有个很显著的特点：

不同对象具备公共的行为能力，但具体每个对象的实现形式又各不相同。

说人话就是商户须要接入平台，接入的步骤雷同，但具体实现不同。

作为一个”资深“Javaer，需要还没看完我就洋洋洒洒的把各个实现类写好了：

当然最终也顺利实现需要，甚至把组里一个没写过 Java 的大哥唬的一愣一愣的，直呼牛逼。

不过预先也给我吐槽：

你这设计是不错，然而感觉好简单，跟代码时要找到真正的业务逻辑（实现类）得绕几圈。

截止目前 Python 写多了，我总算是能总结他的感触：就是不够 Pythonic。

虽说 Python 没有相似 Java 这样的 Interface 个性，但作为面向对象的高级语言也是反对继承的；

在这里咱们也能够利用继承的个性来实现面向接口编程：

class Car:
    def run(self):
        pass

class Benz(Car):
    def run(self):
        print("benz run")

class BMW(Car):

    def run(self):
        print("bwm run")

def run(car):
    car.run()

if __name__ == "__main__":
    benz = Benz()
    bmw = BMW()

    run(benz)
    run(bmw)

代码非常简单，在 Python 中也没有相似于 Java 中的 extends 关键字，只须要在类申明开端用括号蕴含基类即可。

这样在每个子类中就能独自实现业务逻辑，不便扩大和保护。

因为 Python 作为一个动静类型语言，无奈做到 Java 那样在编译期间校验一个类是否齐全实现了某个接口的所有办法。

为此 Python 提供了解决办法，那就是 abc(Abstract Base Classes)，当咱们将基类用 abc 申明时就能近似做到：

import abc
class Car(abc.ABC):
    @abc.abstractmethod
    def run(self):
        pass

class Benz(Car):
    def run(self):
        print("benz run")

class BMW(Car):
    pass

def run(car):
    car.run()

if __name__ == "__main__":
    benz = Benz()
    bmw = BMW()

    run(benz)
    run(bmw)

一旦有类没有实现办法时，运行期间便会抛出异样：

bmw = BMW()
TypeError: Can't instantiate abstract class BMW with abstract methods run

尽管无奈做到在运行之前（毕竟不须要编译）进行校验，但有总比没有好。

以上两种形式看似曾经毕竟优雅的实现面向接口编程了，但实际上也不够 Pythonic。

在持续之前咱们先聊聊 接口 的实质到底是什么？

在 Java 这类动态语言中面向接口编程是比拟麻烦的，也就是咱们常说的子类向父类转型，因而须要编写额定的代码。

带来的益处也是不言而喻，只须要父类便可运行。

但咱们也不用过于执着于接口，它自身只是一个协定、标准，并不特指 Java 中的 Interface，甚至有些语言压根没有这个关键字。

动静语言的个性也不须要强制校验是否实现了办法。

在 Python 中咱们能够利用鸭子类型来优雅的实现面向接口编程。

在这之前先理解下鸭子类型，借用维基百科的说法：

“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就能够被称为鸭子。”

我用大白话翻译下就是：

即使两个齐全不想干的类，如果他们都实现了雷同的办法，那就能够把他们当做同一类型的类来应用。

举个简略例子：

class Order:
    def create(self):
        pass

class User:
    def create(self):
        pass

def create(obj):
    obj.create()

if __name__ == "__main__":
    order = Order()
    user = User()
    create(order)
    create(user)

这里的 order 和 user 自身齐全没有关系，只是他们都有雷同办法，又得益于动静语言没法校验类型的特点，所以齐全能够在运行的时候认为他们是同一种类型。

因而基于鸭子类型，之前的代码咱们能够稍作简化：

class Car:
    def run(self):
        pass

class Benz:
    def run(self):
        print("benz run")

class BMW:
    def run(self):
        print("bwm run")

def run(car):
    car.run()

if __name__ == "__main__":
    benz = Benz()
    bmw = BMW()

    run(benz)
    run(bmw)

因为在鸭子类型中咱们在意的是它的行为，而不是他们的类型；所以齐全能够不必继承便能够实现面向接口编程。

我感觉平时没有接触过动静类型语言的敌人，在理解完这些之后会发现新大陆，就像是 Python 新手第一次应用 Java 时；尽管感觉语法啰嗦，但也会艳羡它的类型查看、参数验证这类特点。

动静语言之争这里不做探讨了，各有各的好，鞋好不好穿只有本人晓得。

前言

类型查看

鸭子类型

总结