类的继承和设计模式

1、方法没有重载：即在一个类中，定义多个同名函数，在调用时只调用最新定义的方法。
2、Person 可以动态新增方法，还可以动态替换方法。

私有属性和私有方法(实现封装)

Python 对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。关于私有属性和私有方法，有如下要点：
1. 通常我们约定，两个下划线开头的属性是私有的(private)。其他为公共的(public)。
2. 类内部可以访问私有属性(方法)
3. 类外部不能直接访问私有属性(方法)
4. 类外部可以通过“_类名__私有属性(方法)名”访问私有属性(方法)

【注】方法本质上也是属性！只不过是可以通过()执行而已。所以，此处讲的私有属性和公有属性，也同时讲解了私有方法和公有方法的用法。如下测试中，同时也包含了私有方法和公有方法的例子。

class Employee:
        __company = "百战程序员" #私有类属性. 通过dir 可以查到_Employee__company
        def __init__(self,name,age):
                self.name = name
                self.__age = age #私有实例属性
        def say_company(self):
                print("我的公司是：",Employee.__company) #类内部可以直接访问私有属性
                print(self.name,"的年龄是：",self.__age)
        self.__work()
                def __work(self): #私有实例方法通过dir 可以查到_Employee__work
                print("工作！好好工作，好好赚钱，娶个媳妇！")
p1 = Employee("高淇",32)
print(p1.name)
print(dir(p1)) #
p1.say_company()
print(p1._Employee__age) #通过这种方式可以直接访问到私有属
性。通过dir 可以查到属性：_Employee__age
#print(p1.__age) #直接访问私有属性，报错
#p1.__sleep() #直接访问私有方法，报错

@property 装饰器：@property 可以将一个方法的调用方式变成“属性调用”。下面是一个简单例，让大家体会一下这种转变：

class Employee:
        @property
        def salary(self):
                return 3000
emp1=Employee()
print(emp1.salary)

也就是说，在使用该方法时可以不用加（）调用方法，和属性调用一致

@property 主要用于帮助我们处理属性的读操作、写操作。对于某一个属性，我们可以直接通过：
emp1.salary = 30000
如上的操作读操作、写操作。但是，这种做法不安全。比如，我需要限制薪水必须为1-10000的数字。这时候，我们就需要通过getter、setter 方法来处理。

def __init__(self,name,salary):
        self.name = name
        self.__salary = salary

@property #相当于salary 属性的getter 方法
def salary(self):
        print("月薪为{0},年薪为
        {1}".format(self.__salary,(12*self.__salary)))
        return self.__salary;
@salary.setter
def salary(self,salary):  #相当于salary 属性的setter 方法，在属性赋值的时候输出，不赋值无作用
        if(0<salary<1000000):
                self.__salary = salary
        else:
                print("薪水录入错误！只能在0-1000000 之间")
emp1 = Employee("高淇",100)
print(emp1.salary)
emp1.salary = -200

总结：1、@property相当于把某个函数转化为了属性，在调用时相当于在调用函数的属性，也就是说要有返回值，调用的是返回值

2、在面向对象编程中，setter 方法用于设置类的属性值。它是一个方法，用于接收新值并将其分配给相应的属性。通过使用 setter 方法，我们可以在属性赋值时执行一些额外的操作，例如进行输入验证、触发其他操作或更新相关的属性。

属性和方法的命名总结：

· _xxx：保护成员，不能用“from module import * ”导入，只有类对象和子类对象能访问这些成员。
· __xxx__：系统定义的特殊成员
· __xxx： 类中的私有成员，只有类对象自己能访问，子类对象也不能访问。（但，在类外部可以通过“对象名. _类名__xxx”这种特殊方式访问。Python 不存在严格意义的私有成员）
注：再次强调，方法和属性都遵循上面的规则。

类编码风格
1. 类名首字母大写，多个单词之间采用驼峰原则。
2. 实例名、模块名采用小写，多个单词之间采用下划线隔开。
3. 每个类，应紧跟“文档字符串”，说明这个类的作用。
4. 可以用空行组织代码，但不能滥用。在类中，使用一个空行隔开方法；模块中，使用两个空行隔开多个类。

2. 设计一个名为MyRectangle 的矩形类来表示矩形。这个类包含：
(1) 左上角顶点的坐标：x，y
(2) 宽度和高度：width、height
(3) 构造方法：传入x，y，width，height。如果（x，y）不传则默认是0，如果width
和height 不传，则默认是100.
(4) 定义一个getArea() 计算面积的方法
(5) 定义一个getPerimeter()，计算周长的方法
(6) 定义一个draw()方法，使用海龟绘图绘制出这个矩形

import turtle
class MyRectangle:
        def __init__(self,x=0,y=0,width=100,height=100):
                self.x=x
                self.y=y
                self.width=width
                self.height=height

        def getArea(self):
                print(f'该矩形的面积是：{self.width*self.height}')
                return self.width*self.height

        def getPerimeter(self):
                print(f'该矩形的周长为{2*(self.width+self.height)}')

        def draw(self):
                turtle.speed(5)
                turtle.penup()
                turtle.goto(self.x,self.y)
                turtle.pendown()
                turtle.goto(self.x+self.width, self.y)
                turtle.goto(self.x + self.width, self.y+self.height)
                turtle.goto(self.x, self.y + self.height)
                turtle.goto(self.x, self.y)
                turtle.done()

MR=MyRectangle(2,3,190,180)
print(MR.getPerimeter())

面向对象三大特征介绍：

Python 是面向对象的语言，也支持面向对象编程的三大特性：继承、封装（隐藏）、多态。

继承：

语法格式
Python 支持多重继承，一个子类可以继承多个父类。继承的语法格式如下：
class 子类类名(父类1[，父类2，...])：
        类体

如果在类定义中没有指定父类，则默认父类是object 类。也就是说，object 是所有类的父类，里面定义了一些所有类共有的默认实现，比如：__new__()。

class Person:
        def __init__(self,name,age):
                self.name = name
                self.__age = age
        def say_age(self):
                print(self.name,"的年龄是：",self.__age)

class Student(Person):
         def __init__(self,name,age,score):
                self.score = score
                Person.__init__(self,name,age) #构造函数中包含调用父类构造函数。根据需要，不是必须。子类并不会自动调用父类的__init__()，我们必须显式的调用它。
s1 = Student("张三",15,85)
s1.say_age()
print(dir(s1))

类成员的继承和重写

1. 成员继承：子类继承了父类除构造方法之外的所有成员。
2. 方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为“重写”

查看类的继承层次结构

通过类的方法mro()或者类的属性__mro__可以输出这个类的继承层次结构。

查看类的继承层次结构

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

执行结果：
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

object 根类
object 类是所有类的父类，因此所有的类都有object 类的属性和方法。我们显然有必要深入研究一下object 类的结构。对于我们继续深入学习Python 很有好处。

dir()查看对象属性
内置函数dir()，他可以让我们方便的看到指定对象所有的属性。
 

重写__str__()方法：object 有一个__str__()方法，用于返回一个对于“对象的描述”，对应于内置数str()经常用于print()方法，帮助我们查看对象的信息。__str__()可以重写。

'''将对象转化成一个字符串，一般用于print 方法'''

class Person:
        def __init__(self,name,age):
                self.name=name
                self.age=age

        def __str__(self):
                return f'{self.name}的年龄是{self.age}'

p=Person('高崎',19)
print(p)

多重继承：Python 支持多重继承，一个子类可以有多个“直接父类”。这样，就具备了“多个父类”的特点。但是由于，这样会被“类的整体层次”搞的异常复杂，尽量避免使用。

MRO()：Python 支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将“从左向右”按顺序搜索。

MRO（Method Resolution Order）：方法解析顺序。我们可以通过mro()方法获得“类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找的。

super()获得父类定义：在子类中，如果想要获得父类的方法时，我们可以通过super()来做。

class Person:
        def __init__(self,name,age):
                self.name=name
                self.age=age

        def say_name(self):
                print(f'{self.name}的年龄是{self.age}')

class Animal(Person):

        def say_name(self):
                super().say_name()
                print(f'{self.name}我爱你')

p=Animal('高崎',19)
print(p.say_name())

多态：

多态（polymorphism）是指同一个方法调用由于对象不同可能会产生不同的行为。在现实生活中，我们有很多例子。比如：同样是调用人的休息方法，张三的休息是睡觉，李四的休息是玩游戏，高淇老师是敲代码。同样是吃饭的方法，中国人用筷子吃饭，英国人用刀叉吃饭，印度人用手吃饭。
关于多态要注意以下2 点：
1. 多态是方法的多态，属性没有多态。
2. 多态的存在有2 个必要条件：继承、方法重写。（底层原理就是方法重写）

class Animal:
        def shout(self):
                print("动物叫了一声")
class Dog(Animal):
        def shout(self):
                print("小狗，汪汪汪")
class Cat(Animal):
        def shout(self):
                print("小猫，喵喵喵")
def animalShout(a):
        if isinstance(a,Animal):
                a.shout() #传入的对象不同，shout 方法对应的实际行为也不同。
animalShout(Dog())
animalShout(Cat())
运行结果：
小狗，汪汪汪
小猫，喵喵喵

特殊方法和运算符重载

 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:
                        return "不是同类对象，不能相加"
        def __mul__(self, other):
                if isinstance(other,int):
                        return self.name*other
                else:
                        return "不是同类对象，不能相乘"
p1 = Person("高淇")
p2 = Person("高希希")
x = p1 + p2
print(x)
print(p1*3)
运算结果：
高淇--高希希
高淇高淇高淇

特殊属性：

Python 对象中包含了很多双下划线开始和结束的属性，这些是特殊属性，有特殊用法。这里我们列出常见的特殊属性：

class A:
        pass
class B:
        pass
class C(A,B):
        def __init__(self,name):
                self.name=name

        def say_name(self):
                print(f'他的名字叫{self.name}')

m=C('大傻子')

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

对象的浅拷贝和深拷贝：

·变量的赋值操作
只是形成两个变量，实际还是指向同一个对象。
·浅拷贝
Python 拷贝一般都是浅拷贝。拷贝时，对象包含的子对象内容不拷贝。因此，源对象和拷贝对象会引用同一个子对象。
·深拷贝
使用copy 模块的deepcopy 函数，递归拷贝对象中包含的子对象。源对象和拷贝对象所有的子对象也不同。

组合

“is-a”关系，我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。“is-a”关系指的是类似这样的关系：狗是动物，dog is animal。狗类就应该继承动物类。
“has-a”关系，我们可以使用“组合”，也能实现一个类拥有另一个类的方法和属性。”has-a”关系指的是这样的关系：手机拥有CPU。MobilePhone has a CPU。

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

class CPU:
        def calculate(self):
                print('计算，计算个12345')

class Screen:
        def show(self):
                print('显示一个好看的图案')

c=CPU()#c拥有了cpu的方法
s=Screen()#s拥有了screen的方法
m=Mobilephone(c,s)#c和s分别赋值给cpu及screen
print(m.cpu.calculate())#调用时调用cpu的方法calculate
print(m.screen.show())

 设计模式_工厂模式实现

 设计模式是面向对象语言特有的内容，是我们在面临某一类问题时候固定的做法，设计模式有很多种，比较流行的是：GOF（Goup Of Four）23 种设计模式。当然，我们没有必要全部学习，学习几个常用的即可。
对于初学者，我们学习两个最常用的模式：工厂模式和单例模式。工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。

class Carfactory:
        def carbrand(self,brand):
                if brand=='Benzi':
                return Benzi()
        elif brand=='BMW':
                return BMW()
        elif brand == 'BYD':
                return BYD()
        else:
                print('无该品牌，无法创建')

class Benzi:
        pass
class BMW:
        pass
class BYD:
        pass

factory=Carfactory()
print(factory.carbrand('BMW'))
print(factory.carbrand('haif'))

<__main__.BMW object at 0x000001D0E57606D0>
无该品牌，无法创建
None

总结：由一个类判断能否创建，如果可以，则创建该类返回对应的类

设计模式_单例模式实现

单例模式（Singleton Pattern）的核心作用是确保一个类只有一个实例，并且提供一个访问该实例的全局访问点。
单例模式只生成一个实例对象，减少了对系统资源的开销。当一个对象的产生需要比较多的资源，如读取配置文件、产生其他依赖对象时，可以产生一个“单例对象”，然后永久驻留内存中，从而极大的降低开销。
单例模式有多种实现的方式，我们这里推荐重写__new__()的方法。

class Mysingleton:
        __obj = None
        __init_flag = True
        def __new__(cls, *args, **kwargs):  #利用new（）创建新对象
                if cls.__obj ==None:           #仅在obj是None的时候创建新的对象
                        cls.__obj=object.__new__(cls)
                return cls.__obj                 #当创建一次对象后不再通过if函数直接返回首次创建的对象
        def __init__(self,name):
                if Mysingleton.__init_flag:     #首次实例化过程
                        print('int.....')
                        self.name=name         
                        Mysingleton.__init_flag=False  #之后出现新的值不再创建新的实例，永久驻留系统

S=Mysingleton('高崎')
print(S)
k=Mysingleton('张三')
print(k)

int.....
<__main__.Mysingleton object at 0x0000022E839C0850>
<__main__.Mysingleton object at 0x0000022E839C0850>

class Computerfactory:
    __obj=None
    __init_flag=True

    def computers(self,brand):
        if brand=='联想':
            return Lenvon()
        elif brand=='华硕':
            return Ausu()
        elif brand=='神舟':
            return Sz()
        else:
            return '输入有误，无法生产'
    def __new__(cls, *args, **kwargs):
        if cls.__obj==None:
            cls.__obj=object.__new__(cls)
        return cls.__obj
    def __init__(self):
        if Computerfactory.__init_flag:
            print('.......')
            Computerfactory.__init_flag = False

class computer:
    def calculate(self):
        print('计算完毕母亲')


class Lenvon(computer):
    def calculate(self):
        print('计算完毕Lenvon')

class Ausu(computer):
    def calculate(self):
        super().calculate()
        print('计算完毕Ausu')
class Sz(computer):
    def calculate(self):
        print('计算完毕Sz')

factory=Computerfactory()
print(factory.computers('联想').calculate())
print(id(factory.computers('神舟').calculate()))
factory2=Computerfactory()
print(factory)
print(factory2)
print(id(factory2.computers('华硕').calculate()))

class Car:
    def __init__(self,workm,works,workc):
        self.workm=workm
        self.works=works
        self.workc=workc

    def run(self):
        return f'{self.workm}是发动机,{self.works}是座椅,{self.workc}是底盘'

class Motor:
    def work(self):
        return 'Motor'

class Seat:
    def work(self):
        return 'Seat'

class Chassis:
    def work(self):
        return 'Chassis'

a=Motor()
b=Seat()
e=Chassis()

p=Car(a.work(),b.work(),e.work())
print(p.run())

class Employee:
    id=1000
    def __init__(self,name,salary):
        self.name=name
        self._salary=salary
        Employee.id+=1
    def __add__(self, other):
        if isinstance(other,int):
            return self+other
    @property
    def salary(self):
        return f'{self.name}的薪水是{self._salary}'
    @salary.setter
    def salary(self,salary):
        if 1000<salary<50000:
            print(f'{self.name}的薪水Wie{self._salary}')
        else:
            print('薪水输入有误')

s=Employee('高崎',5000)
print(s.salary)
s.salary=8000