python之面向对象深入

Python之面向对象深入

一.面向对象的三大特征

python是面向对象的语言，支持面向对象编程的三大特征包括继承性、封装与多态

1.继承

如果在类中没有指定特定父类，默认父类为object类。也可以说object是所有类的父类
关于构造函数：字类可以选择是否重新些初始函数，即__init__，若不重写，会自动调用父类定义的__init__，若重新写，则不会调用父类定义的初始函数，但如果要使用父类的构造方法，要使用super关键字，也可以使用“父类名.init(self,参数)”来调用。

class people:
    def __init__(self,name,age):
        print("people的初始方法")
        self.name = name
        self.age = age
    def say_age(self):
        print(self.name,"的年龄为:",self.age)

class student(people):
    def __init__(self,name,age,grade):
        people.__init__(self,name,age)#继承
        #super(student,self).__init__(name,age)
        print("student构造方法")
        self.name = name
        self.age= age
        self.grade = grade 
s1 = student("李四",18,100)
s1.say_age()     #调用父类的方法

在继承过程中，子类可以对父类的方法进行重写，覆盖父类的方法

class people:
    def __init__(self,name,age):
        print("people的初始方法")
        self.name = name
        self.age = age
    def say_age(self):
        print(self.name,"的年龄为:",self.age)

class student(people):
    def __init__(self,name,age,grade):
        people.__init__(self,name,age)
        print("student构造方法")
        self.name = name
        self.age= age
        self.grade = grade
    def say_age(self):  #继续父类方法的重写
        print("我的年龄为",self.age)
s1 = student("李四",18,100)
s1.say_age()    

查看类的继承层次结构
通过类方法mro()或了的属性__mro__查看类的继承层次结构

class A:pass
class B(A):pass
class C(B):pass
print(C.__mro__)

关于object类
dir()为类的内置函数，用于查看对象属性

class students:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def say_name(self):
        print("我的名字为",self.name,"今年",self.age)
obj = object()
print(dir(obj)) 
s1 = students("tom",18)
print(dir(s1)) #这里的属性包含上面类所定义的属性与方法

重写__str__()方法
内置函数str(对象)，调用的就是重写方法，通常用于print()方法，所以可以用__str__()重写

class student:
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    def __str__(self):
        print("重写方法")
        return "名字为{0}，年龄为{1}".format(self.name,self.__age)
p = student("tom",19)
print(p)  #重新方法 名字为tom，年龄为19
#s = str(p)
#print(s)

多重继承
多重继承，即定义类时，继承两个或两个以上的类

class a:
    def aa(self):
        print("aa")
class b:
    def bb(self):
        print('bb')
class c(b,a):
    def cc(self):
        print("cc")
c = c()
c.cc()
c.bb()
c.aa()

super()
可以用super()代表父类定义，不是父类对象；在子类中调用父类的构造为super(子类名称,self).init()

class a:
    def __init__(self):
        print('aaaa')
    def say(self):
        print("say aaa")
class b(a):
    def __init__(self):
        super(b,self).__init__()#调用父类构造方法
    def said(self):
        super().say() #通过super()调用
        print('say bbb')
c = b()
c.said()

二.动态

多态指的是同一方法由于调用对象不同可能会产生不同行为，多态一般要有继承、方法重写

class food:
    def category(self):
        print("品种")

class fruit(food):
    def category(self):
        print("水果")

class vetg(food):
    def category(self):
        print("蔬菜")
def foodname(a):
    a.category()
foodname(fruit())  #水果

特殊属性

特殊属性	涵义
obj.dict	对象的属性字典
obj.class	对象所属的类
class.bases	显示类的父类
class.mro	显示类的层次结构
class.subclasses()	显示子类

class a:
    pass
class b:
    pass
class c(b,a):
    def __init__(self,nn):
        self.nn=nn
    def cc(self):
        print("cc")
d = c(3)
print(d.__dict__)
print(d.__class__)
print(c.__base__)
print(c.mro())  #c类的层次结构
print(a.__subclasses__())  #a类的子类c

组合
除了继承以外，“组合”也能实现代码的复用，组合核心是将父类对象作为子类的属性，进而可使用父类的方法

class people:
    def __init__(self,head,hand):
        self.head = head
        self.hand = hand
class head:
    def mind(self):
        print("头可以思考")
class hand:
    def handle(self):
        print("手可以处理事情")
        
c = head()
d = hand()
m = people(c,d)
m.head.mind()  #通过组合可以调用head中方法mind()
m.hand.handle()

三.设计模式

工厂模式
工厂模式可以使创建者和调用者的操作分离

class store:
    def fruit(self,category):
        if category == "香蕉":
            return banana()
        elif category == "苹果":
            return apple()
        elif category == "梨":
            return pear()
        else:
            return "未知水果"
class banana:
    pass
class apple:
    pass
class pear:
    pass

a = store()
b1 = a.fruit("香蕉")
b2 = a.fruit("苹果")
b3 = a.fruit("梨")
print(b1)
print(b2)
print(b3)

单例模式
单例模式可以控制只生成一个实例对象，减少对系统资源的浪费

class vocation:
    __hanjia = None
    __shujia = True
    def __new__(cls,*args,**kwargs):
        if cls.__hanjia == None:
            cls.__hanjia = object.__new__(cls)
            return cls.__hanjia
    def __init__(self,name):
        if vocation.__shujia:
            print('..init...')
            self.name = name
            vocation.__shujia=False
b = vocation("bb")
print(b)
a = vocation('aa')
print(a)

工厂与单例模式结合
可将上述两种模式进行结合

class vocation:
    __hanjia = None
    __shujia = True
    
    
    def fruit(self,category):
        if category == "香蕉":
            return banana()
        elif category == "苹果":
            return apple()
        elif category == "梨":
            return pear()
        else:
            return "未知水果"
    def __new__(cls,*args,**kwargs):
        if cls.__hanjia == None:
            cls.__hanjia = object.__new__(cls)
            return cls.__hanjia
    def __init__(self):
        if vocation.__shujia:
            print('..init...')
            vocation.__shujia=False
    
class banana:
    pass
class apple:
    pass
class pear:
    pass

a = vocation()
b1 = a.fruit("香蕉")
b2 = a.fruit("苹果")
b3 = a.fruit("梨")
print(b1)
print(b2)
print(b3)

b = vocation()
print(a)  #实例只能构建一个
print(b)  #返回None