面向对象、接口编程的重要性 python 为什么引入接口interface

面向对象编程的实践

有个产品，其有10个子产品，现在要统计每日消费数据
其中8个子产品的消费入账金额算法相同，2个不同;

拓展性差的糟糕的代码

def ConsumptionSum(product):
product_id = product.get(product)
if product == 'p1':
return p1CS()
if product == 'p2':
return p2CS()

PEP 245 -- Python Interface Syntax | Python.org https://www.python.org/dev/peps/pep-0245/

PEP 245 -- Python Interface Syntax

Formal Interface Syntax

Python syntax is defined in a modified BNF grammar notation described in the Python Reference Manual [8]. This section describes the proposed interface syntax using this grammar:

interfacedef:   "interface" interfacename [extends] ":" suite

extends:        "(" [expression_list] ")"

interfacename:  identifier

This PEP also proposes an extension to Python's 'class' statement:

classdef:    "class" classname [inheritance] [implements] ":" suite

implements:  "implements" implist

implist:     expression-list

classname,

inheritance,

suite,

expression-list:  see the Python Reference Manual

The Problem

Interfaces are important because they solve a number of problems that arise while developing software:

• There are many implied interfaces in Python, commonly referred to as "protocols". Currently determining those protocols is based on implementation introspection, but often that also fails. For example, defining __getitem__ implies both a sequence and a mapping (the former with sequential, integer keys). There is no way for the developer to be explicit about which protocols the object intends to implement.
• Python is limited, from the developer's point of view, by the split between types and classes. When types are expected, the consumer uses code like 'type(foo) == type("")' to determine if 'foo' is a string. When instances of classes are expected, the consumer uses 'isinstance(foo, MyString)' to determine if 'foo' is an instance of the 'MyString' class. There is no unified model for determining if an object can be used in a certain, valid way.
• Python's dynamic typing is very flexible and powerful, but it does not have the advantage of static typed languages that provide type checking. Static typed languages provide you with much more type safety, but are often overly verbose because objects can only be generalized by common subclassing and used specifically with casting (for example, in Java).

There are also a number of documentation problems that interfaces try to solve.

• Developers waste a lot of time looking at the source code of your system to figure out how objects work.
• Developers who are new to your system may misunderstand how your objects work, causing, and possibly propagating, usage errors.
• Because a lack of interfaces means usage is inferred from the source, developers may end up using methods and attributes that are meant for "internal use only".
• Code inspection can be hard, and very discouraging to novice programmers trying to properly understand code written by gurus.
• A lot of time is wasted when many people try very hard to understand obscurity (like undocumented software). Effort spend up front documenting interfaces will save much of this time in the end.

Interfaces try to solve these problems by providing a way for you to specify a contractual obligation for your object, documentation on how to use an object, and a built-in mechanism for discovering the contract and the documentation.

Python has very useful introspection features. It is well known that this makes exploring concepts in the interactive interpreter easier, because Python gives you the ability to look at all kinds of information about the objects: the type, doc strings, instance dictionaries, base classes, unbound methods and more.

Many of these features are oriented toward introspecting, using and changing the implementation of software, and one of them ("doc strings") is oriented toward providing documentation. This proposal describes an extension to this natural introspection framework that describes an object's interface.

interface CountFishInterface:

    "Fish counting interface"

    def oneFish():

        "Increments the fish count by one"

    def twoFish():

        "Increments the fish count by two"

    def getFishCount():

        "Returns the fish count"

interface ColorFishInterface:

    "Fish coloring interface"

    def redFish():

        "Sets the current fish color to red"

    def blueFish():

        "Sets the current fish color to blue"

    def getFishColor():

        "This returns the current fish color"

interface FishMarketInterface(CountFishInterface, ColorFishInterface):

    "This is the documentation for the FishMarketInterface"

    def getFishMonger():

        "Returns the fish monger you can interact with"

    def hireNewFishMonger(name):

        "Hire a new fish monger"

    def buySomeFish(quantity=1):

        "Buy some fish at the market"

class FishError(Error):

    pass

class FishMarket implements FishMarketInterface:

    number = 0

    color = None

    monger_name = 'Crusty Barnacles'

    def __init__(self, number, color):

        self.number = number

        self.color = color

    def oneFish(self):

        self.number += 1

    def twoFish(self):

        self.number += 2

    def redFish(self):

        self.color = 'red'

    def blueFish(self):

        self.color = 'blue'

    def getFishCount(self):

        return self.number

    def getFishColor(self):

        return self.color

    def getFishMonger(self):

        return self.monger_name

    def hireNewFishMonger(self, name):

        self.monger_name = name

    def buySomeFish(self, quantity=1):

        if quantity > self.count:

            raise FishError("There's not enough fish")

        self.count -= quantity

        return quantity