Python基础知识（9）

Python基础知识（9）

面向对象三大特征

• 封装（隐藏）
• 继承
• • 语法格式
  • 查看类的继承层次结构
  • object根类
  • • dir()查看对象属性
    • 重写__str__()方法
  • 多重继承
  • super()获得父类定义
• 多态
• 特殊方法和运算符重载
• 特殊属性
• 对象的浅拷贝和深拷贝
• 组合
• 设计模式_工厂模式实现
• 设计模式_单例模式实现

封装（隐藏）

-隐藏对象的属性和实现细节，只提供对外提供必要的方法，即将细节封装起来，只对外暴露相关调用方法。
-通过“私有属性/私有方法”的方式，可以实现“封装”。Python追求简洁的语法，没有严格的语法级别的“访问控制符”，更多的是依靠程序员自觉实现

继承

-继承可以让子类具有父类的特性，提高了代码的重用性。
-从设计上是一个增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法。

继承是面向对象程序设计的重要特征，也是实现“代码复用的重要手段。
如果一个新类继承自一个设计好的类，就直接具备了已有类的特征，大大降低了工作难度。已有的类，我们称为”父类“或“基类”，新的类被称为”子类“或”派生类“。

语法格式

Python支持多重继承，一个子类可以继承多个负累：

class 子类类名(父类1[,父类2,...]):
	类体

• 如果在类定义中没有指定父类，则默认父类是object类，即，object是所有类的父类，里面定义了一些所有类共有的默认实现。如：new()
• 定义子类时，必须在其构造函数中调用父类的构造函数，调用格式如下：

父类名.__init__(self,参数列表)

#测试继承的基本使用
class Person:
    pass
class Student(Person):
    pass
#Studnt-->Person-->object类
print(Student.mro())

#测试继承的使用
class Person:
    def __init__(self,name,age):
        self.name=name
        self.__age=age  #私有属性
    def say_age(self):
        print("年龄，年龄")

class Student(Person):
    def __init__(self,name,age,score):
        Person.__init__(self,name,age)   #必须显式地调用父类初始化方法，不然解释器不会去调用
        self.score=score

#Studnt-->Person-->object类
print(Student.mro())

s=Student("高崎",18,60)
s.say_age()
print(s.name)
#print(s.age)

print(dir(s))
print(s._Person__age)

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

#测试方法的重写

class Person:

    def __init__(self,name,age):
        self.name=name
        self.__age=age #私有属性

    def say_age(self):
        print("我的年龄：",self.__age)
    def say_introduce(self):
        print("我的名字是{0}".format(self.name))

class Student(Person):

    def __init__(self,name,age,score):
        Person.__init__(self,name,age) #必须显示地调用父类初始化方法，不然解释器不会去调用
        self.score=score

    def say_introduce(self):
        '''重写了父类的方法'''
        print("报告老师，我的名字是：{0}".format(self.name))

s=Student("高崎",18,80)
s.say_age()
s.say_introduce()

查看类的继承层次结构

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

object根类

object类是所有类的父类，因此所有类都有object类的属性和方法。

dir()查看对象属性

内置函数，可以方便查看指定对象所有的属性。

重写__str__()方法

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

多重继承

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

如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将‘从左向右’按顺序搜索。

MRO(method resolution order):方法解析顺序，我们可以通过mro（）方法获得‘类的层次结构’，方法解析顺序也是按照这个‘类的层次结构’寻找的。

super()获得父类定义

在子类中，如果想要获得父类的方法，可以通过super()来做，super()代表父类的定义，不是父类对象。

#测试super（），代表父类的定义，而不是父类的对象
class A:
    def say(self):
        print('A:',self)
class B(A):
    def say(self):
        #A.say(self)
        super().say()
        print('B:',self)
B().say()

多态

多态指同一个方法调用由于对象不同会产生不同的行为。

1. 多态是方法的多态，属性没有多态。
2. 多态的存在有2个必要条件：继承/方法重写

#多态
class Man:
    def eat(self):
        print('饿了，吃饭啦！')
        
class Chinese(Man):
    def eat(self):
        print('中国人用筷子吃饭')
        
class English(Man):
    def eat(self):
        print('英国人用叉子吃饭')
        
class Indian(Man):
    def eat(self):
        print('印度人用右手吃饭')

def manEat(m):
    if isinstance(m,Man):
        m.eat()     #多态，一个方法使用，根据对象不同调用不同的方法
    else:
        print('不能吃饭')

manEat(Chinese())
manEat(English())

特殊方法和运算符重载

Python的运算实际上是通过调用对象的特殊方法实现的。

#测试运算符的重载
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对象中包含了很多双下划线开始和结束的属性，这些是特殊属性，有特殊用法。

对象的浅拷贝和深拷贝

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

组合

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

设计模式_工厂模式实现

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

# 工厂模式

class CarFactory:
    def create_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.create_Car('奔驰')
c2=factory.create_Car('比亚迪')
print(c1)
print(c2)

设计模式_单例模式实现

单例模式(Singleton Pattern)的核心作用是确保一个类只有一个实例，并且提供一个访问该实例的全局访问点。
单例模式只生成一个实例对象，减少了对系统资源的开销，当一个对象的产生需要比较多的资源，如读取配置文件，产生其他依赖对象时，可以产生一个‘单例对象’，然后永久驻留内存中，从而极大地降低开销。

# 测试单例模式
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)