Python(面向对象)

一、UML

面向对象主要用于软件开发的分析和设计阶段，通常使用UML（统一建模语言）进行建模

统一建模语言并不是软件开发的方法，而是一种描述软件开发过程的图形化标记，UML使用若干种模型来描述软件中开发中的每个重要步骤。

（1）类图（ClassDiagram）。展现了一组对象、接口、协作和它们之间的关系。类图描述的是一种静态关系，在系统的整个生命周期都是有效的，是面向对象系统的建模中最常见的图。

（2）对象图（ObjectDiagram）。展现了一组对象以及它们之间的关系。对象图是类图的实例，几乎使用与类图完全相同的标示。

（3）用例图（UseCaseDiagram）。展现了一组用例、参与者（actor）以及它们之间的关系。用例图从用户角度描述系统的静态使用情况，用于建立需求模型。

（4）交互图。用于描述对象间的交互关系，由一组对象和它们之间的关系组成，包含它们之间可能传递的消息。交互图又分为序列图和协作图，其中序列图描述了以时间顺序组织的对象之间的交互活动；协作图强调收发消息的对象的结构组织。

（5）状态图（StateDiagram）。由状态、转换、事件和活动组成，描述类的对象所有可能的状态以及事件发生时的转移条件。通常状态图是对类图的补充，仅需为那些有多个状态的、行为随外界环境而改变的类画状态图。

（6）活动图（ActiveDiagram）。一种特殊的状态图，展现了系统内一个活动到另一个活动的流程。活动图有利于识别并行活动。

（7）组件图（ComponentDiagram）。展现了一组组件的物理结构和组件之间的依赖关系。部件图有助于分析和理解组件之间的相互影响程度。

（8）部署图（DeploymentDiagram）。展现了运行处理节点以及其中的组件的配置。部署图给出了系统的体系结构和静态实施视图。它与组件图相关，通常一个节点包含一个或多个构建。

二、类和对象

类是一些对象的抽象，隐藏了对象内部复杂的结构和实现。类由变量和函数两部分构成，类中的变量称为成员变量，类中的函数称为成员函数。

类是对客观世界中事物的抽象，而对象是类实例化后的实体。

2.1类的定义

Python使用class关键字定义一个类，类名的首字符一般要大写。类需要把使用的变量和方法组合在一起，这种方法称为封装。

class Fruit:    def __init__(self,name,color):        self.name = name        self.color = color    def grow(self):        print('Friut grow......')        return 0

注意：类的方法必须有1个self参数，但是在方法调用时，可以不传递这个参数。

2.2对象的创建

创建对象的过程称为实例化，当一个对象被创建后，包含3个方面的特性：对象的句柄、属性和方法，对象的句柄用于区分不同的对象，对象的属性和方法与类的成员变量和成员函数相对应。

if __name__ == "__main__":    friut = Fruit('apple','red')    print(friut.name)    print(friut.color)    print(friut.grow())

Python使用约定属性名称来达到这样数据封装的目的，如果属性的名字以两个下划线开始，就表示私有属性，反之，就表示公有属性。类的方法也这样约定。

Python中静态变量称为类变量，类变量可以在该类的所有实例中被共享，当创建新的实例化对象后，静态变量并不会获得新的内存空间，而是使用类创建的内存空间。

练习（实例变量和类变量的区别）：

class Fruit:    price = 0    def __init__(self):        self.color = 'red'        zone = 'China'if __name__ == "__main__":    print(Fruit.price)    apple = Fruit()    print(apple.color)    Fruit.price = Fruit.price+10    print("apple.price:",str(apple.price))    banana = Fruit()    print("banana.price:",str(banana.price))

class Friut:    def __init__(self):        self.__color = 'red'if __name__ == "__main__":    apple = Friut()  #实例化类    print(apple._Friut__color)  #通过这样的方式访问类的私有变量

类的内置属性：

class Friut:    def __init__(self):        self.__color = 'red'class Apple(Friut):    '''this is some of instrction of class'''    passif __name__ == "__main__":    fruit = Friut()    apple = Apple()    print('apple.doc',apple.__doc__)    print('apple.dict',apple.__dict__)    print('apple.module',apple.__module__)    print('apple.base',Apple.__bases__)      #Apple类的父类

2.3类的方法

Python使用函数staticmethod()或@staticmethod修饰器把普通函数转换为静态方法，要调用静态方法只需要使用类名作为前缀即可。

class Friut:    price = 0  #类变量    def __init__(self):        self.color = 'red'    def getColor(self):        print(self.color)    # @staticmethod    # def getPrice():    #     print('BEFORE Friut price:',Friut.price)    @staticmethod    def getPrice(cls):        print('BEFORE Friut price:', cls.price)    # def __getPrice(self):    #     Friut.price = Friut.price + 10    #     print('AFTER Friut price:',Friut.price)    def __getPrice(cls):        cls.price = cls.price + 10        print('AFTER Friut price:', cls.price)    count = staticmethod(__getPrice)if __name__ == "__main__":    apple = Friut()    apple.getColor()    Friut.count(apple)    banana = Friut()    Friut.count(banana)    Friut.getPrice(Friut)

2.4内部类的使用

class Car:    class Door:        def open(self):            print("door open")    class Wheel:        def run(self):            print("car run")if __name__ == "__main__":    car = Car()    backDoor = Car.Door()    frontDoor = car.Door()    backDoor.open()    frontDoor.open()    wheel = Car.Wheel()    wheel.run()

2.5__init__方法

构造函数用于初始化类的内部状态，为类的属性设置默认值。

class Fruit:    def __init__(self,color):        self.__color = color        print("init.self.color:",self.__color)    def getColor(self):        print("getColor.self.color:",self.__color)    def setColor(self,color):        self.__color = color        print("setColor.self.color:",self.__color)if __name__ == "__main__":    color = 'red'    fruit = Fruit(color)    fruit.getColor()    color = 'blue'    fruit.setColor(color)

2.6__del__方法

析构函数用于释放对象占用的资源，如果程序中不提供析构函数Python会自动在后台提供默认的析构函数。Python中定义了del()的实例将无法被Python循环垃圾收集器（gc）收集，所以谨慎。

class Fruit:    def __init__(self,color):        self.__color = color        print("init.self.color:",self.__color)    def __del__(self):        self.__color = " "        print("del.self.color:",self.__color)        print("del finish...")    def grow(self):        print("fruit grow...")if __name__ == "__main__":    color = "red"    apple =Fruit(color)    apple.grow()    del apple

2.7垃圾回收机制

Python采用垃圾回收机制清除对象，Python提供了gc模块释放不再使用的对象，垃圾回收的机制有很多算法，Python采用的时引用计数的方式，当某个对象在其作用域内引用计数为0时，Python会自动清除该对象。

#定义水果类import gc  #导入垃圾回收模块class Fruit:    def __init__(self,name,color):  #重写构造函数        self.__name = name    #初始化类的私有变量        self.__color = color    def getName(self): #获取类的私有变量值        return self.__name    def setName(self,name):  #设置类的私有变量值        self.__name = name        print("setName.name:",self.__name)    def getColor(self):        return self.__color    def setColor(self,color):        self.__color = color        print("setColor.color:",self.__color)class fruitShop:    def __init__(self):   #初始化fruitShop        self.__fruits = []    def getFruit(self):        print(self.__fruits)    def addFruit(self,fruit): #向私有变量中追加列表元素        fruit.parent = self  #设置fruit对象的parent属性为self        self.__fruits.append(fruit)if __name__ == "__main__":    fruit_shop  = fruitShop()  #实例化fruitShop类    fruit_shop.addFruit(Fruit('apple','red'))  #调用addFruit()    fruit_shop.addFruit(Fruit('banana','yellow'))    print('refer:\n',gc.get_referrers(fruit_shop))  #调用gc.get_referrers()函数获取对象的相关参数    del fruit_shop   #释放对象资源    print('collection:\n',gc.collect())   #获取垃圾回收的相关内容

2.8类的内置方法

（1）new()

实现单例模式，new()在init()之前被调用，用于创建实例对象

#__new__()在__init__()之前被调用#利用__new__()可以实现单例模式class singleton(object):    __instance = None    def __init__(self):        pass    def __new__(cls, *args, **kwargs):  #在__init__()之前调用__new__()        if singleton.__instance == None:  #生成唯一实例            singleton.__instance = object.__new__(cls,*args,**kwargs)        return singleton.__instance

（2）getattr()、setattr()和getatrribute()

class Fruit(object):    def __init__(self,color='red',price=0): #初始化类的私有变量        self.__color = color        self.__price = price    def __getattribute__(self, name):        return object.__getattribute__(self,name)    def __setattr__(self, key, value):        self.__dict__[key] = valueif __name__ == "__main__":    fruit = Fruit('blue',10)    print(fruit.__dict__.get('_Fruit__color'))  #获取类的color属性    fruit.__dict__['_Fruit__price'] = 20    #设置类的price属性    print(fruit.__dict__.get('_Fruit__price'))   #获取类的price

(3)getitem()

class FruitShop:    def __init__(self):        self.fruits = []    def __getitem__(self, i):  #返回fruits中的每个元素        return self.fruits[i]   #fruits属性被保存至__dict__字典中if __name__ == "__main__":    shop = FruitShop()    shop.fruits = ['apple','banana']    print(shop[0],shop[1])    print(shop)    for item in shop:        print(item,end=' ')

（4）str()

str()用于表示对象代表的含义，返回一个字符串

class Fruit:    '''Fruit类'''    def __str__(self):        return self.__doc__  #必须用return语句返回，否则print语句会出错if __name__ == "__main__":    fruit = Fruit()    print(str(fruit))  #通过函数str()触发__str__()的执行    print(fruit)  #直接使用print语句输出对象

（5）call()

在类中实现call()方法，可以在对象创建时直接返回call()的内容

class Fruit:    class Growth:        def __call__(self, *args, **kwargs):  #与静态类函数相似            print('grow...')    grow = Growth()  #调用Growth,将类Growth作为函数返回，即为外部函数定义函数grow()if __name__ == '__main__':    fruit = Fruit()    fruit.grow()    Fruit.grow()

2.9方法的动态特性

（1）动态添加方法

#动态添加方法class Fruit:    passdef add(self):    print('grow')if __name__ == '__main__':    Fruit.grow = add   #直接用类对象添加方法，之后在实例化出对象    fruit = Fruit()    fruit.grow()

（2）更新方法

class Fruit:    def grow(self):        print('grow...')def update(self):    print('update...')if __name__ == "__main__":    fruit = Fruit()    fruit.grow()    Fruit.grow = update  #更新类中的方法    fruit.grow()

三、继承

3.1使用继承

class Fruit:   #定义基类    def __init__(self,color):  #基类的构造函数        self.color = color        print('Fruit.color:',self.color)    def grow(self):        print('Fruit grow...')class Apple(Fruit):   #派生类继承父类    def __init__(self,color):  #派生类的构造函数        Fruit.__init__(self,color)  #显示调用父类的构造函数        print('Apple.color',self.color)class Banana(Fruit):    def __init__(self,color):        Fruit.__init__(self,color)        print('Banana.color',self.color)if __name__ == "__main__":    apple = Apple('red')   #实例化对象    apple.grow()  #调用从父类继承来的grow()函数    banana = Banana('yellow')    banana.grow()

3.2抽象继承

使用集成之后，子类可以重用父类中的属性和方法，并且可以对继承的方法进行重写，抽象基类时对一类事物的特征行为的抽象，由抽象方法组成，抽象基类不能被直接实例化

#定义抽象基类，需导入ABCMeta,abstractmethodfrom abc import ABCMeta,abstractmethodclass Fruit(metaclass=ABCMeta):  #继承抽象基类ABCMeta    @abstractmethod  #声明抽象函数    def grow(self):        passclass Apple(Fruit):  #子类重写抽象函数    def grow(self):        print('APPLE grow..')if __name__ == "__main__":    apple = Apple()    apple.grow()

3.3多态性

继承机制说明子类具有父类的公有属性和方法，而且子类可以扩展自身的功能，添加新的属性和方法，因此，子类可以代替父类对象，这种特性为多态性。

#实现类之间的多态class Fruit:   #定义基类并定义构造函数    def __init__(self,color=None):        self.color = colorclass Apple(Fruit):  #子类继承父类，并显示调用父类的构造函数    def __init__(self,color):        super(Apple,self).__init__()class Banana(Fruit):  #子类继承父类，并显示调用父类的构造函数    def __init__(self,color):        super(Banana,self).__init__()class FruitShop:    def sellFruit(self,fruit):  #判断传入的实例对象属于那个类，针对不同的类实行不同的动作        if isinstance(fruit,Apple):            print('sell apple...')        if isinstance(fruit,Banana):            print('sell banana...')        if isinstance(fruit,Fruit):            print('sell fruit')if __name__ == "__main__":    apple = Apple('red')    banana = Banana('yellow')    fruit = Fruit('blue')    shop = FruitShop()    shop.sellFruit(apple)    shop.sellFruit(banana)    shop.sellFruit(fruit)

3.4多重继承

#python支持多重继承class Fruit:    def __init__(self):        print("Fruit.init...")    def grow(self):        print("furit.grow...")class Veg:    def __init__(self):        print("Veg.init...")    def plant(self):        print("fruit.plant...")class Melon(Veg,Fruit):   #在继承会继承第一个父类的构造函数    passif __name__ == "__main__":    melon = Melon()    melon.grow()    melon.plant()

3.5Mixin机制
Mixin 机制把Fruit类、HuskdFruit类，DecorticateFruit类放在同一个层次，具体的水果类使用多重继承的方式继承所属的分类。

class Fruit(object):    pass# class HuskedFruit(Fruit):#     def __init__(self):#         print("initialize HuskedFruit")##     def husk(self):#         print("husk...")## class DecorticatedFruit(Fruit):#     def __init__(self):#         print("initialize DecorticatedFruit")##     def decorate(self):#         print("decorate...")# class Apple(HuskedFruit):#     pass## class Banana(DecorticatedFruit):#     pass#Mixin实现class HuskedFruit(object):    def __init__(self):        print("initialize HuskedFruit")    def husk(self):        print("husk...")class DecorticatedFruit(object):    def __init__(self):        print("initialize DecorticatedFruit")    def decorate(self):        print("decorate...")class Apple(HuskedFruit,Fruit):    passclass Banana(DecorticatedFruit,Fruit):    pass

3.5运算符重载

加号和大于号符号重载

class Friut:    def __init__(self,price=0):        self.price = price        print("init.self.price:",self.price)    def __add__(self, other):        return self.price+other.price    def __gt__(self, other):        if self.price>other.price:            return True        else:            return Falseclass Apple(Friut):    passclass Banana(Friut):    passif __name__ == "__main__":    apple = Apple(10)    banana = Banana(20)    total_price = apple+banana    print("total_price:",total_price)    print(apple>banana)

运算符<<的重载

import sysclass Stream:    def __init__(self,file):        self.file = file    def __lshift__(self, obj):        self.file.write(str(obj))        return selfclass Fruit(Stream):    def __init__(self,price=0,file=None):        Stream.__init__(self,file)        self.price = priceclass Apple(Fruit):    passclass Banana(Fruit):    passif __name__ == "__main__":    apple = Apple(10,sys.stdout)    banana = Banana(20,sys.stdout)    endl = '\n'    apple<<apple.price<<endl    banana<<banana.price<<endl

四、Python实现工厂模式

在工厂模式中，工厂方法用于创建产品，并隐藏了产品对象实例化的过程，工厂方法根据不同的参数生成不同的对象，因此，客户程序只需知道工厂类和产品的父类，并不需要知道产品的创建过程，以及返回的产品类型。

#工厂模式实现#工厂类，实现产品的生产class Factory:    def createFruit(self,fruit):        if fruit == "apple":            return Apple()        if fruit == "banana":            return Banana()class Fruit():    def __str__(self):        return 'Fruit...'class Apple(Fruit):    def __str__(self):        return 'apple...'class Banana(Fruit):    def __str__(self):        return 'banana...'if __name__ == "__main__":    factor = Factory()    print(factor.createFruit('apple'))    print(factor.createFruit('banana'))