Python学习整理记录之OPP面向对象(类)

OOP-Python面向对象

• Python的面向对象
• 面向对象编程
  • 基础
    -公有私有
  • 继承
  • 组合，Minxi
• 魔法函数
  • 魔法函数概述
  • 构造类魔法函数
  • 运算类魔法函数

1 面向对象概述（Object Oriented，OO）

• OOP思想
  • 接触到任意一个任务，首先想到的是任务这个世界的构成，是由模型构成的
• 几个名词
  • OO —面向对象
  • OOA—面向对象的分析
  • OOD—面向对象的设计
  • OOI—面向对象的实现
  • OOP—面向对象的编程
  • OOA-》OOD－》OOI—面向对象的实现过程
• 类和对象的概念
  • 类：抽象名词，代表一个集合，共性的事务
  • 对象：具象的事物，单个个体
  • 类跟对象的关系
    • 一个具象，代表一类事物的某一个个体
    • 一个是抽象，待变的是一大类事物
• 类中的内容，应该具有两个内容
  • 表明事物的特征，叫做属性（变量）
  • 表明事物功能或者动作，成为成员方法（函数）

2 类的基本实现

• 类的命名
  • 遵守变量命名的规范
  • 大驼峰（由一个或者多个单词构成，每个单词首字母大写，单词跟单词直接相连）
  • 尽量避开跟系统命名的相似命名
• 如何声明一个类
  • 必须用class关键字
  • 类由属性和方法构成，其他不允许出现
  • 成员属性定义可以直接使用变量赋值，如果没有值，允许使用None
  • 案例1

class Student():
    name = "dana"
    age = 19    
    def say(self):
        self.name = "aa"
        self.age = 20
        print("my name is {0}".format(self.name))
        print("my age is {0}".format(self.age))

#类实例的属性和其对象的实例的属性，在不对对象的实例属性进行赋值的情况下，指向同一个变量        
#Student是一个类实例
print(Student.name)
print(Student.age)        
    def sayAgain(s):
        s.name = "bb"
        s.age = 21
        print("my name is {0}".format(s.name))
        print("my age is {0}".format(s.age))                
    def saySomething():
        print("my name is {0}".format(__class__.name))
        print("my age is {0}".format(__class__.age))                
        print("Say Something Again!")    
t = Student()
t.say()
t.sayAgain()
# 调用绑定类函数必须使用类名
Student.saySomething()

my name is aa
my age is 20
my name is bb
my age is 21
Say Something Again!

• 实例化类
  变量 = 类名（）
• 访问对象成员
  • 使用点 “.” 操作符
    obj.成员属性名称
    obj.成员方法
• 可以通过默认内置变量检查类和对象的所有成员
  • 对象所有成员检查
    • obj.dict
  • 类所有的成员
    • class_name.dict

3 anaconda基本使用

• anaconda主要是一个虚拟环境管理器
• 还是一个安装包管理器
• conda list:显示anaconda安装的包
• conda env list:显示anaconda的虚拟环境列表
• conda create -n xxx python=3.8

4 类和对象的成员分析

• 类和对象都可以存储成员，成员可以归类所有，可以归对象所有
• 类存储成员时使用的是与类关联的一个对象
• 独享存储成员是存储在当前对象中
• 对象访问一个成员时，
  • 如果对象中没有该成员，则尝试访问类中的同名成员
  • 如果对象中存在该成员，则必定使用对象中的成员
• 创建对象的时候，类中的成员不会放入对象当中，而是得到一个空对象，没有成员
• 通过对象对类中成员重新赋值或者通过对象添加成员时，对应成员会保存在对应对象中，而不会修改类成员

5 关于self

• self在对象的方法中表示当前对象本身，如果通过对象调用一个方法，那么该对象会自动传入到当前方法的第一个参数中
• self并不是关键字，只是一个用于接受对象的普通参数，理论上可以用任何一个普通变量名代替
• 方法中有self形参的方法成为非绑定类的方法，可以通过对象访问；没有self形参的绑定类的方法，只能通过类访问
• 使用类访问绑定类的方法时，如果类方法中需要访问当前类的成员，可以通过__class__.对象名来访问

class A():
    name = "liuying"
    age = 18
# 私有    
    def __init__(self):
        self.name = "bde"
        self.age = 390
    def say(self):
        print(self.name)
        print(self.age)
class B():
    name = "ccccc"
    age = 89    
a = A()
# 系统会默认把a作为第一个参数传入函数
a.say()
# 此时，self被a替换
A.say(a)
# 同样可以把A作为参数传入
A.say(A)
#此时，把B作为参数传入，条件是B具有与A相同的属性，所以不会报错
A.say(B)
A.__dict__

bde
390
bde
390
liuying
18
ccccc
89
mappingproxy({‘module’: ‘main’,
‘name’: ‘liuying’,
‘age’: 18,
‘init’: <function main.A.init(self)>,
‘say’: <function main.A.say(self)>,
‘dict’: <attribute ‘dict’ of ‘A’ objects>,
‘weakref’: <attribute ‘weakref’ of ‘A’ objects>,
‘doc’: None})

6 面向对象的三大特性

• 封装
• 继承
• 多态

6.1 封装

• 封装就是对对象的成员进行访问限制
• 封装的三个级别：
  • 公开：public
  • 受保护的：protected
  • 私有的：private
  • public、private、protected不是关键字
• 判别对象的位置
  • 对象内部
  • 对象外部
  • 子类中
• 私有
  • 私有成员是*别的封装，只能在当前类或对象中访问
  • 在成员前面添加**两个下划线“__”**即可
    class Person():
    # name是共有成员
    name = “liuyun”
    # __age是私有成员
    __age = 18
  • Python的私有不是真的私有独占，可以使用（对象._类__age）来进行访问
• 受保护的封装 Protected
  • 受保护的封装时将对象成员进行一定级别的封装，然后在类中或者子类中都可以进行访问，单在外部不可以
  • 封装方法：在成员名称前添加一个“_”下划线即可
• 公共的public
  • 公共的封装实际对成员没有任何操作，任何地方都可以访问

# 私有变量案例
class Person():
# name是共有成员
    name = "liuyun"
 # __age是私有成员
    __age = 18    
P = Person()
print(P.name)
# 注意报错信息 AttributeError: 'Person' object has no attribute '__age'
print(P.__age)

AttributeError Traceback (most recent call last)
in
8 P = Person()
9 print(P.name)
—> 10 print(P.__age)

AttributeError: ‘Person’ object has no attribute '__age

6.2 继承

• 继承就是一个类可以获得另外一个类中成员属性和方法
• 作用：减少代码，增加代码复用功能，设置类与类之间的关系
• 继承和被继承的概念：
  • 被继承的类叫父类，也叫基类，超类
  • 用于继承的类叫子类，也叫派生类
  • 继承与被继承一定存在一个 Is-a 的关系

继承的语法

# 继承的语法
# 在python中，任何类都有一个共同的父类叫做object
class Person():
    name = "NoName"
    age = 19
    __score = 99     # 分数是秘密，私有不可访问
    _petname = "ABC" # 小名受保护，子类可以访问，
    def sleep(self):
        print("Sleeping.....")
# 父类 写在括号内
class Teacher(Person):
    teacher_id = '8956'
    name = 'dadna'
    def make_test(self):
        print("attention")
t = Teacher()
# 子类和父类定义同一个名称变量，则优先使用子类本身
print(t.name)
# 子类访问父类受保护成员
print(t._petname)
# 子类不允许访问父类的私有成员
print(t.__score)

dadna
ABC

AttributeError Traceback (most recent call last)
in
26
27 # 子类不允许访问父类的私有成员
—> 28 print(t.__score)
29
30

AttributeError: ‘Teacher’ object has no attribute '__score

继承的特征

• 所有的类都继承自object类，即所有的类都是object类的子类
• 子类一旦继承父类，则可以使用父类中除了私有成员外的所有内容
• 子类继承父类后并没有将父类成员完全赋值到子类中，而是通过引用关系访问调用
• 子类中可以定义独有的成员属性和方法
• 子类中定义的成员和父类成员如果相同，则优先使用子类成员
• 子类如果想扩充父类的方法，可以在定义新方法的同时访问父类成员来进行代码重用，
  • <1> 可以使用 [父类名.父类成员] 的格式来调用父类成员
  • <2> 也可以使用 [super().父类成员] 的格式来调用
• 继承变量函数的查找顺序问题
  • 优先查找自己的变量
  • 没有则查找父类
  • 构造函数如果本类中没有定义，则自动查找调用父类构造函数
  • 如果本来有定义，则不再继续向上查找

# 子类扩充父类功能的案例
# 父类有工作的函数，子类也有工作的函数，
class Person():
    name = "NoName"
    age = 19
    __score = 99     # 分数是秘密，私有不可访问
    _petname = "ABC" # 小名受保护，子类可以访问，
    def sleep(self):
        print("Sleeping.....")
    def work(self):
        print("Make some money !")
# 父类 写在括号内
class Teacher(Person):
    teacher_id = '8956'
    name = 'dadna'
    def make_test(self):
        print("attention")   
    def work(self):
        # 扩充父类的功能只需要调用父类相应的函数
        # Person.work(self)
        # 另一种方法
        super().work()
        self.make_test()
t = Teacher()
t.work()

• 构造函数
  • 概念：
    • 在对象进行实例化的时候，系统自动调用的一个函数叫做构造函数，通常此函数用来对实例对象进行初始化
    • 构造函数一定要有，如果没有，则自动向上查找，按照MRO顺序只到找到为止
  • 是一类特殊的函数，在类进行实例化之前进行调用
  • 如果定义了构造函数，则实例化使用构造函数，不查找父类的构造函数
  • 如果没有定义，则自动向上查找构造函数
  • 如果子类没有定义，父类的构造函数带参数，则构造对象的参数应该按父类参数构造

# 构造函数的概念
class Person():
    # __init__就是构造函数
    # 每次实例化的时候，第一个被调用
    # 因为主要工作是进行初始化，所以得名
    def __init__(self): # self参数必须有，可以是其他命名        
        # 以下是初始化数据。
        self.name = "Wava"
        self.age = 19
        self.address = "Guangdong,China"
        print("{0} is initing and {1}years old，live in {2}".format(self.name,self.age,self.address))
p = Person()
Person()

• super
  • super不是关键字，而是一个类
  • super的作用是获取MRO（Method Resolution Order）列表中的第一个类
  • super于父类之间没任何实质性关系，但通过super可以调用到父类
  • super的两个使用方法。参见在构造函数中调用父类的构造函数

# 构造函数的调用顺序 1
# 如果子类没有写构造函数，则自动向上查找父类，只到找到构造函数
class A():
    pass
class B(A):
    pass
class C(B):
    # __init__就是构造函数
    # 每次实例化的时候，第一个被调用
    # 因为主要工作是进行初始化，所以得名
    def __init__(self):  # self参数必须有，可以是其他命名
        print("I am initing.....in C")
# 实例化的时候，首先查找C的构造函数，找到就停止查找
c = C()


# 构造函数调用顺序 2
class A():
    def __init___(self):
        print("I am initing...in A")
class B(A):
    def __init__(self):
        print("I am initing....in B")
class C(B):
    pass
# 在C类找不到构造函数，则向上按照MRO顺序查找B父类的构造函数
c = C()


# 构造函数调用顺序 3
class A():
    def __init___(self):
        print("I am initing...in A")
class B(A):
    def __init__(self,name):
        print("I am initing....in B")
        print(name)
class C(B):
    pass
# 此时如果C()没有参数，则会出现参数结构不对应的错误
# <TypeError: __init__() missing 1 required positional argument: 'name'>
#c = C()
# 当C()存在参数时，则运行正常
c = C("NONO")


# 继承中的构造函数 4
class Animal():
    pass
class Reptile(Animal):
    def __init__(self, name):
        self.name = name
        print("{0} are Reptile".format(self.name))
class dog(Reptile):
    # __init__就是构造函数
    # 每次实例化的时候，第一个被调用
    # 因为主要工作是进行初始化，所以得名
    def __init__(self):  # self参数必须有，可以是其他命名
        print("I am initing.....in dog")
class cat(Reptile):
    pass
# 实例化的时候，自动调用dog的构造函数 
# 在本类找到构造函数，则不再查找父类的构造函数
kaka = dog() 
# 在本类中没有找到构造函数，则向上父类进行查找，当在父类中找到构造函数，则查找停止
mimi = cat("mimi")


# 构造函数调用顺序 5
class A():
    def __init___(self):
        print("I am initing...in A")

class B(A):
    def __init__(self,name):
        print("I am initing....in B")
        print(name)
class C(B):
    # 扩展构造函数
    # 有两种方式 
    # 1
    """
    def __init__(self, name):
        # 首先调用父类构造函数
        B.__init__(self, name)
        # 再添加本类功能
        print("附加C功能")
    """    
    # 2
    def __init__(self, name):
        # 首先调用父类构造函数
         super(C, self).__init__(name)
        # 再添加本类功能
         print("附加C功能")        
c = C("C 本C")

• 单继承和多继承
  • 单继承：每个类只能继承一个类
    • 优点：传承有序，逻辑清晰，语法简单
    • 缺点：功能不能无限扩展，只能在当前唯一的继承链中扩展
  • 多继承：每个类允许继承多个类
    • 优点：类的功能扩展方便
    • 缺点：继承关系混乱

# 单继承和多继承的案例
class Fish():
    def __init__(self,name):
        self.name = name
    def swim(self):
        print("{0} is swimming....".format(self.name))        
class Bird():
    def __init__(self,name):
        self.name = name
    def fly(self):
        print("{0} is flying...".format(self.name))
class Person():
    def __init__(self,name):
        self.name = name
    def work(self):
        print("{0} is working....".format(self.name))
# 多继承的例子        
class SuperMan(Person, Fish, Bird):
    def __init__(self,name):
        self.name = name        
# 单继承的例子        
class Student(Person):
    def __init__(self,name):
        self.name = name        
s = SuperMan("yueyue")
s.fly()
s.swim()
s.work()
x = Student("nana")
x.work()

• 菱形继承和钻石继承的问题

  • 多个子类继承同一个父类，这些子类被同一个类继承，于是继承关系图形成一个菱形图形

     class A():
        pass
     class B(A):
        pass
     class C(A):
        pass
     class D(B,C):
        pass
    

  • 关于多继承的MRO

    • MRO就是多继承中，用于保存继承顺序的一个列表
    • Python本身采用C3算法来对多继承的菱形继承进行计算
    • MRO列表的计算原则：
      • 子类永远在父类前面
      • 如果多个父类，则根据继承语法中括号内的书写顺序存放
      • 如果多个类继承了同一个父类，孙子类中指挥选取继承语法括号中第一个父类的父类

6.3 多态

• 多态就是同个对象不同情况下有不同的状态出现

• 多态不是语法，是一种设计思想

• 多态性：一种调用方式，不同执行效果

• 多态：同一事物的多种形态，动物分为人类狗类N类

• Mixin设计模式
  - 主要采用多继承方式对类功能进行扩展

• 我们使用多继承语法来实现Mixin

• 使用Mixin实现多继承的注意事项
  - 首先必须表示某一单一功能，而不是某个物品
  - 职责必须单一，如果有多个功能，则写多个Mixin
  - Mixin不能依赖于子类的实现
  - 子类即使没有继承这个Mixin类，也能照样工作，只是缺少了某个功能

• 优点
  - 使用Mixin可以再不对类进行任何修改的情况下，扩充功能
  - 可以方便的组织和维护不同功能组件的划分
  - 可以根据需要任意调整功能类的组合
  - 可以避免创建很多新的类，导致类的继承混乱

# Mixin 案例
class  Person():
    """
    def __init__(self,name):
        self.name = name
    """
    name = "liuyang"
    age = 18
    
    def eat(self):
        print("Eating...")
    
    def drink(self):
        print("Drinking...")
    
    def sleep(self):
        print("Sleeping...")
        
    def work(self):
        print("Working....")
class Teacher(Person):
    def teach(self):
        print("Teaching...")        
class Student(Person):
    def study(self):
        print("Studing...")        
class tutor (Teacher, Student):
    pass

t = tutor()
print(tutor.__mro__)
print(t.__dict__)
print(tutor.__dict__)
print("---" * 20)

class TeacherMixin():
    def teach(self):
        print("Teaching...")
class StudentMixin():
    def study(self):
        print("Studing...")   
class TutorMixin (Person, TeacherMixin, StudentMixin):
    pass   
 
tt = TutorMixin()
print(TutorMixin.__mro__)
print(tt.__dict__)
print(TutorMixin.__dict__)

(<class ‘main.tutor’>, <class ‘main.Teacher’>, <class ‘main.Student’>, <class ‘main.Person’>, <class ‘object’>)
{}
{‘module’: ‘main’, ‘doc’: None}

(<class ‘main.TutorMixin’>, <class ‘main.Person’>, <class ‘main.TeacherMixin’>, <class ‘main.StudentMixin’>, <class ‘object’>)
{}
{‘module’: ‘main’, ‘doc’: None}

7.类相关函数

• issubclass：检测一个类是否是另一个类的子类
• isinstance：检测一个对象是否是一个类的实例
• hasattr：检测一个对象是否存在类的成员
• getattr：
• setattr：
• delattr：
• dir：获取对象的成员列表

8.类的成员描述符

• 类的成员描述符是为了再类中对类的成员属性进行相关操作而创建的一种方式
  • get: 获取属性的操作
  • set： 修改或者添加属性操作
  • delete：删除属性的操作
• 如果想使用类的成员描述符，有三种方式
  • 使用类实现描述器
  • 使用属性修饰符
  • 使用property函数
    • property（fget, fset, fdel, doc）
• 无论哪种修饰符都是为了对成员属性进行相应的控制
  • 类的方式： 适合多个类中的多个属性共用一个描述符
  • property: 适合当前类中使用，可以控制一个类中多个属性
  • 属性修饰符：适合当前类中使用，控制一个类中的一个属性

# 属性案例 1
# 创建Student类，描述学生类
# 学生具有Student.name属性
# 但name格式并不统一
class Student():
    def __init__(self, name, age):
        self.name = name
        self.age = age       
        # 如果不想修改代码
        self.setName(name)        
    # 自我介绍函数
    def intro(self): # 此处不需要添加name,age作为参数
        print("Hi, my name is {0} and {1} years old。".format(self.name, self.age))    
    def setName(self, name):
        self.name = name.upper()        
s1 = Student("livermore", 234)
s2 = Student("wangfeng", 45)
s1.intro()
s2.intro()


# 属性案例 2
# 使用property函数
# 定义一个Person类，具有name,age属性
# 对于任意输入的名字，都用大写保存
# 年龄统一整型格式
# x = property(fget, fset, fdel, doc)
class Person():
    def fget(self):
        return self._name    
    def fset(self,name):
        # 对任意姓名都用大写保存
        self._name = name.upper()
        # 对年龄取整型保存
    #    self._age = age.int()       
    def fdel(self):
        self._name = "NOName"
        self._age = "NoAge"
    name = property(fget, fset, fdel, "对Name进行以下操作")    
 #   age = property(fget, fset, fdel, "对Age进行以下操作")     
p1 = Person()
p1.name = "calfornere "
# p1.age = 78.2
print(p1.name)
# print(p1.age)


# 类属性 property
# 应用场景
# 对变量除了普通的三种操作，还想增加一些附加的操作，那么可以通过Property完成
class A():
    def __init__(self):
        self.name = "hhaha"
        self.age = 18
    # 此功能，是对类标量进行读取操作的时候调用执行
    def fget(self):
        print("读在前面的话....")
        return self.name
    # 此功能对变量进行写操作的时候调用执行
    def fset(self,name):
        print("写在前面的话....")
        self.name = "前缀： " + name
    # 对变量进行删除操作的时候调用执行
    def fdel(self):
        pass
    
    # property 的四个参数顺序是固定的
    na = property(fget, fset, fdel, "无题")   
a = A()
print(a.name)
print(a.na

9.类的内置属性

     __dict__: 以字典的方式显示类的成员组成
     __doc__:  获取类的文档信息
     __name__: 获取类的名称，如果在模块中使用，获取模块的名称
     __bases__:获取某个类的所有父类，以元组的方式显示

# 类的内置属性 案例
print(Person.__dict__)
print(Person.__doc__)
print(Person.__name__)
print(Person.__bases__)

{‘module’: ‘main’, ‘fget’: <function Person.fget at 0x00000276CF9F7F70>, ‘fset’: <function Person.fset at 0x00000276CFA1A040>, ‘fdel’: <function Person.fdel at 0x00000276CFA1A0D0>, > > > > ‘name’: <property object at 0x00000276CFA13220>, ‘age’: <property object at 0x00000276CFA06E00>, ‘dict’: <attribute ‘dict’ of ‘Person’ objects>, ‘weakref’: <attribute ‘weakref’ > > of ‘Person’ objects>, ‘doc’: None}
None
Person
(<class ‘object’>,)

10. 类的常用魔术方法

• 魔术方法就是不需要认为调用的方法，基本是在特定的时刻自动触发

• 魔术方法的统一特征：方法名被前后各两个下划线
  ####操作类

     __init__ ：构造函数
     __new__ ： 对象实例化方法，此函数较特殊，一般不需要使用
     __call__:  对象当函数使用的时候触发 
     __str__  : 当对象被当作字符串使用的时候触发    
     __repl__ : 返回字符串
  

# 操作类魔术方法
# __new__ ：对象实例化方法，此函数较特殊，一般不需要使用
# __init__
# __call__ : 对象当做函数使用的时候触发
# __str__  : 当对象被当作字符串使用的时候触发
class A():
    def __init__(self):
        print("AAAAAAAAA")        
    # 当对象当作函数使用时，触发    
    def __call__(self):
        print("BBBBBBBBB")    
    # 
    def __str__(self):
        return "CCCCCCCCC"
a = A()
a()
print(a)

####描述符相关

     __set__ ：构造函数
     __get__ ： 对象实例化方法，此函数较特殊，一般不需要使用
     __delete__:  对象当函数使用的时候触发 

####属性操作相关

     __getattr__ ：访问一个不存在的属性时候触发
     __setattr__ ：对成员属性进行修改设置的时候触发
           - 参数: __setattr__(self, name, value)
                - self  用来获当前对象
                - name  被设置的属性名称，以字符串形式出现
                - value 需要对属性名称设置的值
           - 作用：进行属性设置的时候进行验证或修改
           - 注意：在该方法中不能对属性直接进行赋值操作，否则会死循环

# 属性操作相关魔术方法
# __getattr__
class A():
    name ="NoName"
    age = 19
    def __getattr__(self,name):
        print("查不到！")       
a = A()
print(a.name)
print(a.add)

# 为什么输出会有None？？？


# __setattr__ 
class P():
    def __init__(self):
        pass
    # 对Name进行修改时候触发调用
""" 
               - 参数: __setattr__(self, name, value)
                    - self  用来获当前对象
                    - name  被设置的属性名称，以字符串形式出现
                    - value 需要对属性名称设置的值
"""
    def __setattr__(self, name, value):
        print("设置属性{0}".format(value))
        # 下面语句会导致死循环
        # self.name = value \ self.name = "Noen"  
        # 为避免这种情况，规定统一调用父类魔法函数
        super().__setattr__(name,value)
p = P()        
p.name = "ddada" 

####运算分类相关

     __gt__ ：进行大于判断的时候触发
            - 参数
                - self
                - 第二个参数是第二个对象
                - 返回值可以任意，推荐使用布尔值 

# __gt__ 判断第一个对象是否大于第二个对象
class student():
    def __init__(self, name):
        self.name = name
     # self和obj分别代表第一个对象和第二个对象   
    def __gt__(self, obj):
        print("{0} 比 {1} 大么？".format(self.name, obj.name))
        return self.name > obj.name    
s1 = student("dididi")
s2 = student("NMNMNM")
print(s1 > s2)

# 字符串的比较大小是按照什么规则？？

11. 类和对象的三种方法

• 实例方法
  • 需要实例化对象才能使用的方法，使用过程中可能需要接着对象的其他对象的方法完成
• 静态方法
  • 不需要实例化，通过类直接访问
• 类方法
  • 不需要实例化

# 三种方法的案例
class Person():
    # 实例方法
    def eat(self):
        print(self)
        print("Eating....") 
   
    # 类方法
    # 类方的第一个参数，一般命名为cls,区别于self
    @classmethod
    def play(cls):
        print(cls)
        print("Playing....")
        
    # 静态方法
    # 不需要用第一个参数表示自身或类
    @staticmethod
    def say():
        print("Saying...")

Dana = Person()

# 实例方法
#erson.eat()
Dana.eat()

# 类方法
Dana.play()
Dana.play()

# 静态方法
Person.say()
Dana.say()

#  关于三种方法内存使用方面的区别

# 变量的三种用法
class A():
    def __init__(self):
        self.name = "hhaha"
        self.age = 18
a = A()
# 属性的三种用法
# 赋值、读取、删除
a.name = "ouou"
a.age = 20
del a.age

12. 抽象类

• 抽象方法：没有具体实现内容的方法

• 抽象方法的主要意义是规范了子类的行为和接口

• 抽象的使用需要借助abc模块

•                 import abc
                  @abc.abstractmethod | @abc.abstractclassmethod |@abc.abstractstaticmethod
  

• 抽象类：包括抽象方法的类叫做抽象类，

• 使用：

  • 抽象类可以包含抽象方法，也可以包含具体方法
  • 可以有方法也可以有属性
  • 抽象类不允许实例化。必须继承才可以使用，且继承的子类必须实现所有继承来的抽象方法
  • 假定子类没有实现所有继承的抽象方法，则子类也不能实例化
  • 抽象类的主要作用是设定类的标准，以便于开发的时候具有统一规范

# 抽象类 实例
class animal():
    # 父类定义一个函数，但没有具体的方法
    def SayHello(self):
        pass
class Dog(animal):
    # 在子类继承的时候，重新定义函数的具体方法
    def SayHello(self):
        print("闻一下")
class Person(animal):
    # 不同的子类，有不同的方法
    def SayHello(self):
        print("握一下")


# 抽象类的实现
import abc
# 声明一个类并且指定当前类的元类
class Human(metaclass=abc.ABCMeta):    
    # 定义一个抽象的方法
    @abc.abstractmethod
    def somking(self):
        pass    
    # 定义类抽象方法
    @abc.abstractclassmethod
    def drink():
        pass    
    # 定义静态抽象方法
    @abc.abstractstaticmethod
    def play():
        pass

13. 自定义类

• 是一个普通类定义和各种方法的*组合
• 可以先定义类和函数，然后通过“类名可以当变量”直接进行赋值
• 可以借助于MethodType实现
• 借助于type实现
• 利用元类实现 - MetaClass

# 组装类 实例1
class A():
    pass
def say(self):
    print("Saying....")    
say(9)
A.say = say
a = A()
a.say()


# 实例2
from types import MethodType
class B():
    pass
def talk(self):
    print("Talking....")    
b = B()
# MethodType(函数，类名)
b.talk = MethodType(talk, B)
b.talk()


# 利用type创建一个类
# 先定义类的成员函数
def say(self):
    print("Saying......")
    
def talk(self):
    print("Talking......")        
# 创建一个类
A = type("A",(object,), {"class_say":say, "class_talk":talk})
# 然后可以像正常访问一样使用类
a = A()
a.class_say()
a.class_talk()

元类演示

# 元类写法是固定的，必须继承自type
# 元类一半命名以MetaClass结尾
class TLsMetaClass(type):
    
    def __new__(cls, name, bases, attrs):
        # 方法
        print("hello......")
        attrs["id"] = "000000"
        attrs["addr"] = "北京海淀区"
        return type.__new__(cls, name, bases, attrs)    
class Teacher(object, metaclass=TLsMetaClass):
    pass
t = Teacher()
print(t.id)
print(t.addr)

类的总结：

• 类是整个Python的根本，或者说是编程语言的根本，一个程序就是由N个类和main()构成，而每个类有包含N个函数
• 定义一个函数一个类不难，定义很多函数和类也不难，难的在于，搭建类内函数之间的关系，类与类之间的关系
• 所以，必须务必只有吃透这一章的内容，才有继续下去的可能