一、接口与归一化设计

1、什么是接口

调用某个功能的方法/方式/入口

2、为什么要用接口

接口提取了一群类共同的函数，可以把接口当做一个函数的集合。

然后让子类去实现接口中的函数。

这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。

归一化的好处在于：

1. 归一化让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。

2. 归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合

二、多态和多态性

1、多态

多态指的是一类事物有多种形态

动物有多种形态：人，狗，猪

import abc

class Animal(metaclass=abc.ABCMeta): #同一类事物:动物

    @abc.abstractmethod

    def talk(self):

        pass

class People(Animal): #动物的形态之一:人

    def talk(self):

        print('say hello')

class Dog(Animal): #动物的形态之二:狗

    def talk(self):

        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪

    def talk(self):

        print('say aoao')

文件有多种形态：文本文件，可执行文件

import abc

class File(metaclass=abc.ABCMeta): #同一类事物:文件

    @abc.abstractmethod

    def click(self):

        pass

class Text(File): #文件的形态之一:文本文件

    def click(self):

        print('open file')

class ExeFile(File): #文件的形态之二:可执行文件

    def click(self):

        print('execute file')

2、多态性

    . 什么是多态动态绑定（在继承的背景下使用时，有时也称为多态性）

    多态性是指在不考虑实例类型的情况下使用实例

    . 多态性分为静态多态性和动态多态性

　静态多态性：如任何类型都可以用运算符+进行运算

　动态多态性：如下

peo=People()

dog=Dog()

pig=Pig()

#peo、dog、pig都是动物,只要是动物肯定有talk方法

#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用

peo.talk()

dog.talk()

pig.talk()

#更进一步,我们可以定义一个统一的接口来使用

def func(obj):

    obj.talk()

  3、为什么要用多态性（多态性的好处）

其实大家从上面多态性的例子可以看出，我们并没有增加什么新的知识，也就是说python本身就是支持多态性的，这么做的好处是什么？

1.增加了程序的灵活性

　　    以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)

2.增加了程序额可扩展性

　　    通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用

>>> class Cat(Animal): #属于动物的另外一种形态：猫

...     def talk(self):

...         print('say miao')

...

>>> def func(animal): #对于使用者来说，自己的代码根本无需改动

...     animal.talk()

...

>>> cat1=Cat() #实例出一只猫

>>> func(cat1) #甚至连调用方式也无需改变，就能调用猫的talk功能

say miao

'''

这样我们新增了一个形态Cat，由Cat类产生的实例cat1，使用者可以在完全不需要修改自己代码的情况下。使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1)

'''

三、封装

    一、引子

    从封装本身的意思去理解，封装就好像是拿来一个麻袋，把小猫，小狗，小王八，还有alex一起装进麻袋，然后把麻袋封上口子。照这种逻辑看，封装=‘隐藏’，这种理解是相当片面的

二、先看如何隐藏

在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）

#其实这仅仅这是一种变形操作

#类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：

class A:

    __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N

    def __init__(self):

        self.__X=10 #变形为self._A__X

    def __foo(self): #变形为_A__foo

        print('from A')

    def bar(self):

        self.__foo() #只有在类内部才可以通过__foo的形式访问到.

#A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形

这种自动变形的特点：

1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。

2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。

3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

这种变形需要注意的问题是：

1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N

2.变形的过程只在类的定义是发生一次,在定义后的赋值操作，不会变形

3.在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

#正常情况

>>> class A:

...     def fa(self):

...         print('from A')

...     def test(self):

...         self.fa()

...

>>> class B(A):

...     def fa(self):

...         print('from B')

...

>>> b=B()

>>> b.test()

from B

#把fa定义成私有的，即__fa

>>> class A:

...     def __fa(self): #在定义时就变形为_A__fa

...         print('from A')

...     def test(self):

...         self.__fa() #只会与自己所在的类为准,即调用_A__fa

...

>>> class B(A):

...     def __fa(self):

...         print('from B')

...

>>> b=B()

>>> b.test()

from A

    三、封装不是单纯意义的隐藏

    1.封装数据：将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制。

class Teacher:

    def __init__(self,name,age):

        self.__name=name

        self.__age=age

    def tell_info(self):

        print('姓名:%s,年龄:%s' %(self.__name,self.__age))

    def set_info(self,name,age):

        if not isinstance(name,str):

            raise TypeError('姓名必须是字符串类型')

        if not isinstance(age,int):

            raise TypeError('年龄必须是整型')

        self.__name=name

        self.__age=age

t=Teacher('egon',18)

t.tell_info()

t.set_info('egon',19)

t.tell_info()

2、封装方法：目的是隔离复杂度

封装方法举例：

1. 你的身体没有一处不体现着封装的概念：你的身体把膀胱尿道等等这些尿的功能隐藏了起来，然后为你提供一个尿的接口就可以了（接口就是你的。。。，），你总不能把膀胱挂在身体外面，上厕所的时候就跟别人炫耀：hi，man，你瞅我的膀胱，看看我是怎么尿的。

2. 电视机本身是一个黑盒子，隐藏了所有细节，但是一定会对外提供了一堆按钮，这些按钮也正是接口的概念，所以说，封装并不是单纯意义的隐藏！！！

3. 快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了

提示：在编程语言里，对外提供的接口（接口可理解为了一个入口），可以是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体。

#取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱

#对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做

#隔离了复杂度,同时也提升了安全性

class ATM:

    def __card(self):

        print('插卡')

    def __auth(self):

        print('用户认证')

    def __input(self):

        print('输入取款金额')

    def __print_bill(self):

        print('打印账单')

    def __take_money(self):

        print('取款')

    def withdraw(self):

        self.__card()

        self.__auth()

        self.__input()

        self.__print_bill()

        self.__take_money()

a=ATM()

a.withdraw()

隔离复杂度示例

四、特性(property)

1、什么是特性

property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值

例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）

成人的BMI数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖, 高于32
　　体质指数（BMI）=体重（kg）÷身高^2（m）
　　EX：70kg÷（1.75×1.75）=22.86

class People:

    def __init__(self,name,weight,height):

        self.name=name

        self.weight=weight

        self.height=height

    @property

    def bmi(self):

        return self.weight / (self.height**2)

p1=People('egon',75,1.85)

print(p1.bmi)

例二：圆的周长和面积

import math

class Circle:

    def __init__(self,radius): #圆的半径radius

        self.radius=radius

    @property

    def area(self):

        return math.pi * self.radius**2 #计算面积

    @property

    def perimeter(self):

        return 2*math.pi*self.radius #计算周长

c=Circle(10)

print(c.radius)

print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值

print(c.perimeter) #同上

'''

输出结果:

314.1592653589793

62.83185307179586

'''

#注意：此时的特性arear和perimeter不能被赋值

c.area=3 #为特性area赋值

'''

抛出异常:

AttributeError: can't set attribute

'''

    2、为什么要用property

    将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则

除此之外，看下

ps：面向对象的封装有三种方式:
【public】
这种其实就是不封装,是对外公开的
【protected】
这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
【private】
这种封装对谁都不公开

python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现

class Foo:

    def __init__(self,val):

        self.__NAME=val #将所有的数据属性都隐藏起来

    @property

    def name(self):

        return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)

    @name.setter

    def name(self,value):

        if not isinstance(value,str):  #在设定值之前进行类型检查

            raise TypeError('%s must be str' %value)

        self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME

    @name.deleter

    def name(self):

        raise TypeError('Can not delete')

f=Foo('egon')

print(f.name)

# f.name=10 #抛出异常'TypeError: 10 must be str'

del f.name #抛出异常'TypeError: Can not delete'

    五、封装与扩展性

    封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。

#类的设计者

class Room:

    def __init__(self,name,owner,width,length,high):

        self.name=name

        self.owner=owner

        self.__width=width

        self.__length=length

        self.__high=high

    def tell_area(self): #对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积

        return self.__width * self.__length

#使用者

>>> r1=Room('卧室','egon',20,20,20)

>>> r1.tell_area() #使用者调用接口tell_area

400

#类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码

class Room:

    def __init__(self,name,owner,width,length,high):

        self.name=name

        self.owner=owner

        self.__width=width

        self.__length=length

        self.__high=high

    def tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了

        return self.__width * self.__length * self.__high

#对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能

>>> r1.tell_area()

8000

四、面向对象高级

    一 isinstance(obj,cls)和issubclass(sub,super)

isinstance(obj,cls)检查是否obj是否是类 cls 的对象

class Foo(object):

     pass

obj = Foo()

isinstance(obj, Foo)

issubclass(sub, super)检查sub类是否是 super 类的派生类

1 class Foo(object):

2     pass

3

4 class Bar(Foo):

5     pass

6

7 issubclass(Bar, Foo)

二 反射

1 什么是反射

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

 2 python面向对象中的反射

通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）

四个可以实现自省的函数

下列方法适用于类和对象（一切皆对象，类本身也是一个对象）

判断object中有没有一个name字符串对应的方法或属性

hasattr(object,name)

def getattr(object, name, default=None): # known special case of getattr

    """

    getattr(object, name[, default]) -> value

    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.

    When a default argument is given, it is returned when the attribute doesn't

    exist; without it, an exception is raised in that case.

    """

    pass

getattr(object,name,default=None)

def setattr(x, y, v): # real signature unknown; restored from __doc__

    """

    Sets the named attribute on the given object to the specified value.

    setattr(x, 'y', v) is equivalent to ``x.y = v''

    """

    pass

setattr(x,y,v)

def delattr(x, y): # real signature unknown; restored from __doc__

    """

    Deletes the named attribute from the given object.

    delattr(x, 'y') is equivalent to ``del x.y''

    """

    pass

delattr(x,y)

class BlackMedium:

    feature = 'Ugly'

    def __init__(self,name,addr):

        self.name = name

        self.addr = addr

    def sell_house(self):

        print('%s 黑中介卖房子啦，傻逼才买呢，但是谁能证明自己不傻' %self.name)

    def rent_house(self):

        print('%s 黑中介租房子啦，傻逼才租呢' %self.name)

b1 = BlackMedium('万成置地','回龙观天露园')

#检测是否含有某属性

print(hasattr(b1,'name'))

print(hasattr(b1,'sell_house'))

#获取属性

n = getattr(b1,'name')

print(n)

func = getattr(b1,'rent_house')

func()

#getattr(b1,'aaaaa') #报错

print(getattr(b1,'aaaaa','不存在啊'))

#设置属性

setattr(b1,'sb',True)

setattr(b1,'show_name',lambda self: self.name+'sb')

print(b1.__dict__)

print(b1.show_name(b1))

#删除属性

delattr(b1,'addr')

delattr(b1,'show_name')

delattr(b1,'show_name111')   #不存在，则报错

print(b1.__dict__)

四个方法的使用展示

class Foo(object):

    staticField = "old boy"

    def __init__(self):

        self.name = 'wupeiqi'

    def func(self):

        return 'func'

    @staticmethod

    def bar():

        return 'bar'

print getattr(Foo, 'staticField')

print getattr(Foo, 'func')

print getattr(Foo, 'bar')

类也是对象

import sys

def s1():

    print('s1')

def s2():

    print('s2')

this_module = sys.modules[__name__]

print(this_module)

print(hasattr(this_module,'s1'))

print(getattr(this_module,'s2'))

反射当前模块成员

导入其他模块，利用反射查找该模块是否存在某个方法

def test():

    print('from the test')

module_test.py

 4 """

 5 程序目录：

 6     module_test.py

 7     index.py

 8

 9 当前文件：

10     index.py

11 """

12

13 import module_test as obj

14

15 #obj.test()

16

17 print(hasattr(obj,'test'))

18

19 getattr(obj,'test')()

3 为什么用反射之反射的好处

好处一：实现可插拔机制

有俩程序员，一个lili，一个是egon，lili在写程序的时候需要用到egon所写的类，但是egon去跟女朋友度蜜月去了，还没有完成他写的类，lili想到了反射，使用了反射机制lili可以继续完成自己的代码，等egon度蜜月回来后再继续完成类的定义并且去实现lili想要的功能。

总之反射的好处就是，可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实是一种‘后期绑定’，什么意思？即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能

class FtpClient:

    'ftp客户端,但是还么有实现具体的功能'

    def __init__(self,addr):

        print('正在连接服务器[%s]' %addr)

        self.addr=addr

egon没有实现的功能

最新文章

  1. [LoadRunner]LR11安装或破解时报错的解决方法
  2. Ionic中使用Chart.js进行图表展示以及在iOS/Android中的性能差异
  3. 如何在word里面插入目录
  4. postgresql安装配置
  5. c++ 从标注输入流读取行
  6. SQL中IN,NOT IN,EXISTS,NOT EXISTS的用法和差别
  7. git 解决多人修改相同的文件导致的冲突
  8. unity中多个门的开关动画保持独立性
  9. 【iCore4 双核心板_FPGA】例程五：基础逻辑门实验——逻辑门使用
  10. Excel连接SSAS提示“传输层中遇到错误”的问题
  11. sublime text3 激活码——许可证
  12. AJAX-DOM事件
  13. (转).net平台下垃圾回收机制
  14. spring事务配置的两种方式
  15. 算法题目-记hulu失败的实习面试
  16. IE下 input 的父级标签被 disabled 之后引发的怪异行为
  17. string，char*及CString类型的相互转换
  18. win10 显示详细信息窗格
  19. CentOS 文件隐藏属性
  20. 在weblogic上配置数据源

热门文章

  1. ios开发之--UICollectionView的使用
  2. swift学习笔记之—自定义函数的规则说明
  3. Jquery checkbox选中问题
  4. poj_1743 后缀数组
  5. poj_2774 后缀数组
  6. Delphi Live Bindings 初探
  7. Android Runtime.getRuntime().exec
  8. Android 7.1 SystemUI--Multi-Window多窗口模式
  9. 【BZOJ3275】Number 最小割
  10. 【BZOJ3156】防御准备 斜率优化