学习记录_python面向对象

学习记录
日期：2021年9月6日

特殊方法和运算符的重载

class Person:
    def __init__(self,name):
        self.name = name
    def __add__(self, other):
        if isinstance(other,Person):
            return '{0}-{1}'.format(self.name,other.name)
        else:
            print('不是同类对象，不能相加')

    def __mul__(self, other):
        if isinstance(other,int):
            return self.name*other
        else:
            print('不是同类对象，不能相乘')


p1 = Person('james')
p2 = Person('peter')

x = p1 + p2
print(x)
print(x*5)

特殊属性

class A:
    pass

class B:
    pass
class C(B,A):
    def __init__(self,nm):
        self.nm = nm
    def cc(self):
        print('cc')

c = C(23)

print(dir(c))
print(c.__dict__)
print(c.__class__)
print(C.__base__)
print(C.mro())
print(A.__subclasses__())

对象的浅拷贝和深拷贝

#测试对象的浅拷贝和深拷贝
import copy

class  MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu = cpu
        self.screen = screen


class CPU:
    def calc(self):
        print('算尼玛')
        print('cpu对象:',self)

class Screen:
    def show(self):
        print('显示一个好看的画面，亮瞎你的狗眼')
        print('screen对象：',self)

#测试变量赋值
print('测试赋值')
c1 = CPU()
c2 = c1
print(c1)
print(c2)

#测试浅拷贝
print('测试浅拷贝')
s1 = Screen()
m1 = MobilePhone(c1,s1)
m2 = copy.copy(m1)
print(m1,m1.cpu,m1.screen)
print(m2,m2.cpu,m2.screen)

#测试深拷贝
print('测试深拷贝')
m3 = copy.deepcopy(m1)
print(m1,m1.cpu,m1.screen)
print(m3,m3.cpu,m3.screen)

组合

#测试is-a关系

#使用继承实现代码
class A1:

    def say_a1(self):
        print('a1,a1,a1')

class B1(A1):
    pass

b1 = B1()
b1.say_a1()

#使用组合，实现同样的效果
class A2:
    def say_a2(self):
        print('a2,a2,a2')
class B2:
    def __init__(self,a):
        self.a = a

a2 = A2()
b2 = B2(a2)
b2.a.say_a2()

组合2

#测试has-a关系，使用组合

class  MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu = cpu
        self.screen = screen


class CPU:
    def calc(self):
        print('算尼玛')
        print('cpu对象:',self)

class Screen:
    def show(self):
        print('显示一个好看的画面，亮瞎你的狗眼')
        print('screen对象：',self)

m = MobilePhone(CPU(),Screen())
m.cpu.calc()
m.screen.show()

工厂模式

#测试工厂模式

class CarFactory:
    def creat_car(self,brand):
        if brand == '奔驰':
            return Benz()
        elif brand == '宝马':
            return BMW()
        elif brand == '比亚迪':
            return BYD()
        else:
            return '未知品牌，无法创建'

class Benz:
    pass

class BMW:
    pass

class BYD:
    pass

factory = CarFactory()
c1 = factory.creat_car('奔驰')
c2 = factory.creat_car('比亚迪')
print(c1)
print(c2)

单例模式

#测试单例模式

class MySingleton:

    _obj = None  #类属性
    _init_flag = True

    def __new__(cls, *args, **kwargs):
        if cls._obj == None:
            cls._obj = object.__new__(cls)

        return cls._obj

    def __init__(self,name):
        if MySingleton._init_flag:

            print('init....')
            self.name = name
            MySingleton._init_flag = False

a = MySingleton('aa')
b = MySingleton('bb')
print(a)
print(b)
c = MySingleton('cc')
print(c)

单例模式和工厂模式整和

#测试工厂模式和单例模式的整合
class CarFactory:

    _obj = None  # 类属性
    _init_flag = True

    def creat_car(self,brand):
        if brand == '奔驰':
            return Benz()
        elif brand == '宝马':
            return BMW()
        elif brand == '比亚迪':
            return BYD()
        else:
            return '未知品牌，无法创建'
    def __new__(cls, *args, **kwargs):
        if cls._obj == None:
            cls._obj = object.__new__(cls)

        return cls._obj

    def __init__(self):
        if CarFactory._init_flag:

            print('init CarFactory....')

            CarFactory._init_flag = False

class Benz:
    pass

class BMW:
    pass

class BYD:
    pass

factory = CarFactory()
c1 = factory.creat_car('奔驰')
c2 = factory.creat_car('比亚迪')
print(c1)
print(c2)


factory2 = CarFactory()
print(factory)
print(factory2)