面向对象、接口编程的重要性 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
PEP: | 245 |
---|---|
Title: | Python Interface Syntax |
Author: | Michel Pelletier <michel at users.sourceforge.net> |
Discussions-To: | http://www.zope.org/Wikis/Interfaces |
Status: | Rejected |
Type: | Standards Track |
Created: | 11-Jan-2001 |
Python-Version: | 2.2 |
Post-History: | 21-Mar-2001 |
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.
Overview of the Interface Syntax
For the most part, the syntax of interfaces is very much like the syntax of classes, but future needs, or needs brought up in discussion, may define new possibilities for interface syntax.
A formal BNF description of the syntax is givena later in the PEP, for the purposes of illustration, here is an example of two different interfaces created with the proposed syntax:
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"
This code, when evaluated, will create two interfaces called CountFishInterface and ColorFishInterface. These interfaces are defined by the interface statement.
The prose documentation for the interfaces and their methods come from doc strings. The method signature information comes from the signatures of the def statements. Notice how there is no body for the def statements. The interface does not implement a service to anything; it merely describes one. Documentation strings on interfaces and interface methods are mandatory, a 'pass' statement cannot be provided. The interface equivalent of a pass statement is an empty doc string.
You can also create interfaces that "extend" other interfaces. Here, you can see a new type of Interface that extends the CountFishInterface and ColorFishInterface:
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"
The FishMarketInteface extends upon the CountFishInterface and ColorfishInterface.
Interface Assertion
The next step is to put classes and interfaces together by creating a concrete Python class that asserts that it implements an interface. Here is an example FishMarket component that might do this:
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
面向对象、接口编程的重要性 python 为什么引入接口interface的更多相关文章
- 【PHP面向对象(OOP)编程入门教程】20.PHP5接口技术(interface)
PHP与大多数面向对象编程语言一样,不支持多重继承.也就是说每个类只能继承一个父类.为了解决这个问题,PHP引入了接口,接口的思想是指定了一个实现了该接口的类必须实现的一系列方法.接口是一种特殊的抽象 ...
- 吴裕雄--天生自然JAVA面向对象高级编程学习笔记:抽象类与接口的应用
abstract class A{ // 定义抽象类A public abstract void print() ; // 定义抽象方法print() }; class B extends A { / ...
- PHP面向对象(OOP)编程入门教程
面向对象编程(OOP)是我们编程的一项基本技能,PHP5对OOP提供了良好的支持.如何使用OOP的思想来进行PHP的高级编程,对于提高 PHP编程能力和规划好Web开发构架都是非常有意义的.下面我们就 ...
- Mybatis接口编程原理分析(二)
在上一篇博客中 Mybatis接口编程原理分析(一)中我们介绍了MapperProxyFactory和MapperProxy,接下来我们要介绍的是MapperMethod MapperMethod:它 ...
- 谈面向对象的编程(Python)
(注:本文部分内容摘自互联网,由于作者水平有限,不足之处,还望留言指正.) 今天中秋节,也没什么特别的,寻常日子依旧. 谈谈面向对象吧,什么叫面向对象? 那么问题来了,你有对象吗? 嗯,,,那我可 ...
- python学习笔记--面向对象的编程和类
一.面向对象的编程 面向对象程序设计--Object Oriented Programming,简称oop,是一种程序设计思想.二.面向对象的特性类:class类,对比现实世界来说就是一个种类,一个模 ...
- Python 中的面向接口编程
前言 "面向接口编程"写 Java 的朋友耳朵已经可以听出干茧了吧,当然这个思想在 Java 中非常重要,甚至几乎所有的编程语言都需要,毕竟程序具有良好的扩展性.维护性谁都不能拒绝 ...
- 【GoLang】golang 面向对象编程 & 面向接口编程
005.面向对象&接口编程 1 面向函数编程 1.1 将数据作为参数传递到函数入参 1.2 对象与函数是分离的 2 面向对象编程 2.1 使用者看起来函数作为对象的属性而非参数 2.2 函数属 ...
- IT第十九天 - 继承、接口、多态、面向对象的编程思想
IT第十九天 上午 继承 1.一般情况下,子类在继承父类时,会调用父类中的无参构造方法,即默认的构造方法:如果在父类中只写了有参的构造方法,这时如果在子类中继承时,就会出现报错,原因是子类继承父类时无 ...
随机推荐
- NSDate 问题
类型 比特数 有效数字 数值范围 float 32 6-7 -3.4*10(-38)-3.4*10(38) double 64 15-16 -1.7*10(-308)-1.7*10(308) long ...
- React Native Android入门实战及深入源代码分析系列(2)——React Native源代码编译
本文为老曾原创.转载需注明出处:viewmode=contents">http://blog.csdn.net/minimicall?viewmode=contents 在上一节中,我 ...
- shell脚本循环嵌套
嵌套循环 在循环语句内使用任意类型的命令,包括其他循环命令,叫做嵌套循环.因为是在迭代中迭代,需要注意变量的使用以及程序的效率问题. 下面举一个for循环嵌套for循环的例子: wangsx@SC-2 ...
- asp.net core mvc视频A:笔记6-1.应用发布与部署
显示:直接使用上节课的项目 一.使用vs发布应用 这里选择发布到文件夹,当然你可以选择其他的发布方式 部署模式:(我的VS里没有这个配置,不知道为啥...视频里有) 1.框架依赖:选择此模式,发布后需 ...
- 基于Linux的智能家居的设计(5)
4 软件设计 软件设计部分主要包含uboot移植.内核编译.系统移植.设备驱动编程.应用程序编程(QT编程.mysql数据库编程.控制系统编程).各个模块的功能函数(部分是在windows以下的IA ...
- Titel Block不显示
在原有原理图上New page时不显示Titel Block 解决办法:两种(1)(2) 方法1.在新建的原理图上右键选择Schematic Page Properties,按下图勾选即可 方法2.进 ...
- Atitit.软件命名空间 包的命名统计 及命名表(2000个名称) 方案java package
Atitit.软件命名空间 包的命名统计 及命名表(2000个名称) 方案java package 1. 统计的lib jar 列表1 2. Code3 3. 常用包名按找字母排序(2000个)4 ...
- C语言基础(21)-C语言编译过程及GCC参数简介
任何C语言的编译过程可分为以下三部分: 一.预编译 在C语言中,以#开头的语句又叫预编译指令.预编译主要做以下两件事情: 1.将#include包含的头文件做简单的文本替换: 2.将代码中的注释删除. ...
- Mat::operator =
Provides matrix assignment operators. C++: Mat& Mat::operator=(const Mat& m) C++: Mat& M ...
- libubox组件(1)——usock
一:相关API介绍 1.相关源码文件:usocket.h usocket.c 2.类型标志 1: #define USOCK_TCP 0 2: #define USOCK_UDP 1 3: #defi ...