Python面向对象-三大特性

一三大特性-封装

面向对象思想有三大特性：封装、继承、多态。

封装：将属性和方法放到一起做为一个整体，然后通过实例化对象来处理，这样隐藏内部实现细节，只需要和对象及其属性和方法交互就可以了。

为了更好的封装，还可以对类的属性和方法增加访问权限控制：

# 在属性名和方法名 前面 加上两个下划线 __ 即成为私有权限
class Master(object):def __init__(self):self.kongfu = "古法煎饼果子配方" def make_cake(self):          print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)class School(object):def __init__(self):self.kongfu = "现代煎饼果子配方"def make_cake(self):print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)class Prentice(School, Master):def __init__(self):self.kongfu = "猫氏煎饼果子配方"# 私有属性，可以在类内部通过self调用，但不能通过对象访问self.__money = 10000  # 私有方法，可以在类内部通过self调用，但不能通过对象访问def __print_info(self):print(self.kongfu)print(self.__money)def make_cake(self):self.__init__()print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)def make_old_cake(self):Master.__init__(self) Master.make_cake(self)def make_new_cake(self):School.__init__(self) School.make_cake(self)class PrenticePrentice(Prentice):passdamao = Prentice()
# 对象不能访问私有权限的属性和方法
# print(damao.__money)
# damao.__print_info()pp = PrenticePrentice()
# 子类不能继承父类私有权限的属性和方法
print(pp.__money) 
pp.__print_info()

私有属性不能直接访问，所以无法通过第一种方式修改，一般的通过第二种方式修改私有属性的值：定义一个可以调用的公有方法，在这个公有方法内访问修改。

二三大特性-继承

2.1 继承概念

在程序中，继承描述的是多个类之间的所属关系。如果一个类A里面的属性和方法可以复用，则可以通过继承的方式，传递到类B里。

那么类A就是基类，也叫做父类；类B就是派生类，也叫做子类：

# 父类
class A(object):def __init__(self):self.num = 10def print_num(self):print(self.num + 10)
# 子类
class B(A):passb = B()
print(b.num) 
b.print_num()

2.2 单继承

虽然子类没有定义__init__方法初始化属性，也没有定义实例方法，但是父类有。所以只要创建子类的对象，就默认执行了那个继承过来的__init__方法。

# 定义一个Master类
class Master(object):def __init__(self):# 属性self.kongfu = "古法煎饼果子配方" # 实例方法def make_cake(self):print("按照 <%s> 制作了一份煎饼果子..." % self.kongfu)# 定义Prentice类，继承了 Master，则Prentice是子类，Master是父类。
class Prentice(Master): # 子类可以继承父类所有的属性和方法，哪怕子类没有自己的属性和方法，也可以使用父类的属性和方法。pass                # laoli = Master()
# print(laoli.kongfu)
# laoli.make_cake()damao = Prentice()  # 创建子类实例对象
print(damao.kongfu) # 子类对象可以直接使用父类的属性
damao.make_cake()   # 子类对象可以直接使用父类的方法

注意：子类在继承的时候，在定义类时，小括号()中为父类的名字。

2.3 多继承

多继承可以继承多个父类，也继承了所有父类的属性和方法，如果多个父类中有同名的属性和方法，则默认使用第一个父类的属性和方法（根据类的魔法属性mro的顺序来查找）。

class Master(object):def __init__(self):self.kongfu = "古法煎饼果子配方"  # 实例变量，属性def make_cake(self):                    # 实例方法，方法print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)def dayandai(self):print("师傅的大烟袋..")class School(object):def __init__(self):self.kongfu = "现代煎饼果子配方"def make_cake(self):print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)def xiaoyandai(self):print("学校的小烟袋..")# class Prentice(School, Master):  # 多继承，继承了多个父类（School在前）
#     pass# damao = Prentice()
# print(damao.kongfu)
# damao.make_cake()
# damao.dayandai()
# damao.xiaoyandai()class Prentice(Master, School):  # 多继承，继承了多个父类（Master在前）passdamao = Prentice()
print(damao.kongfu) # 执行Master的属性
damao.make_cake() # 执行Master的实例方法# 子类的魔法属性__mro__决定了属性和方法的查找顺序
print(Prentice.__mro__)damao.dayandai() # 不重名不受影响
damao.xiaoyandai()

2.4 子类重写父类的同名属性和方法

class Master(object):def __init__(self):self.kongfu = "古法煎饼果子配方" def make_cake(self): print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)class School(object):def __init__(self):self.kongfu = "现代煎饼果子配方"def make_cake(self):print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)class Prentice(School, Master):  # 多继承，继承了多个父类def __init__(self):self.kongfu = "猫氏煎饼果子配方"def make_cake(self):print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)# 如果子类和父类的方法名和属性名相同，则默认使用子类的
# 叫 子类重写父类的同名方法和属性
damao = Prentice()
print(damao.kongfu) # 子类和父类有同名属性，则默认使用子类的
damao.make_cake() # 子类和父类有同名方法，则默认使用子类的# 子类的魔法属性__mro__决定了属性和方法的查找顺序
print(Prentice.__mro__)

2.5 通过super()调用父类方法

class Master(object):def __init__(self):self.kongfu = "古法煎饼果子配方"  # 实例变量，属性def make_cake(self):  # 实例方法，方法print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)# 父类是 Master类
class School(Master):def __init__(self):self.kongfu = "现代煎饼果子配方"def make_cake(self):print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)super().__init__()  # 执行父类的构造方法super().make_cake()  # 执行父类的实例方法# 父类是 School 和 Master
class Prentice(School, Master):  # 多继承，继承了多个父类def __init__(self):self.kongfu = "猫氏煎饼果子配方"def make_cake(self):self.__init__()  # 执行本类的__init__方法，做属性初始化 self.kongfu = "猫氏...."print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)def make_all_cake(self):# 方式1. 指定执行父类的方法（代码臃肿）# School.__init__(self)# School.make_cake(self)## Master.__init__(self)# Master.make_cake(self)## self.__init__()# self.make_cake()# 方法2. super() 带参数版本，只支持新式类# super(Prentice, self).__init__() # 执行父类的 __init__方法 # super(Prentice, self).make_cake()# self.make_cake()# 方法3. super()的简化版，只支持新式类super().__init__()  # 执行父类的 __init__方法 super().make_cake()  # 执行父类的 实例方法self.make_cake()  # 执行本类的实例方法damao = Prentice()
damao.make_cake()
damao.make_all_cake()# print(Prentice.__mro__)

三三大特性-多态

所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。

鸭子类型：虽然我想要一只"鸭子"，但是你给了我一只鸟。但是只要这只鸟走路像鸭子，叫起来像鸭子，游泳也像鸭子，我就认为这是鸭子。

Python的多态，就是弱化类型，重点在于对象参数是否有指定的属性和方法，如果有就认定合适，而不关心对象的类型是否正确。

class F1(object):def show(self):print('F1.show')class S1(F1):def show(self):print('S1.show')class S2(F1):def show(self):print('S2.show')def Func(obj):  # python是弱类型，即无论传递过来的是什么，obj变量都能够指向它，这也就没有所谓的多态了（弱化了这个概念）print(obj.show())s1_obj = S1()
Func(s1_obj) s2_obj = S2()
Func(s2_obj)