Python复习(六)-面对对象

0. OOP-Python面向对象

  • Python的面向对象
  • 面向对象编程

    • 基础
    • 公有私有
    • 继承
    • 组合,Mixin
  • 魔法函数

    • 魔法函数概述
    • 构造类魔法函数
    • 运算类魔法函数

1. 面向对象概述(ObjectOriented,OO)

  • OOP思想

    • 接触到任意一个任务,首先想到的是任务这个世界的构成,是由模型构成的
  • 类和对象的概念

    • 类:抽象名词,代表一个集合,共性的事物
    • 对象:具象的事物,单个个体
    • 类跟对象的关系

      • 一个具象,代表一类事物的某一个个体
      • 一个是抽象,代表的是一大类事物
  • 类中的内容,应该具有两个内容

    • 表明事物的特征,叫做属性(变量)
    • 表明事物功能或动作, 称为成员方法(函数)

2. 类的基本实现

  • 类的命名

    • 遵守变量命名的规范
    • 大驼峰(由一个或者多个单词构成,每个单词首字母大写,单词跟单词直接相连)
    • 尽量避开跟系统命名相似的命名
  • 你如何声明一个类

    • 必须用class关键字
    • 类由属性和方法构成,其他不允许出现
    • 成员属性定义可以直接使用变量赋值,如果没有纸,许使用None
  • 实例化类

    变量 = 类名() #实例化了一个对象
  • 访问对象成员

    • 使用点操作符

           obj.成员属性名称
           obj.成员方法 
  • 可以通过默认内置变量检查类和对象的所有成员

    • 对象所有成员检查

          # dict前后各有两个下划线
          obj.__dict__ 
    • 类所有的成员

          # dict前后各有两个下划线
      
         class_name.__dict__
      
class Tao():
    name = "Taoy"
Tao.__dict__

# 实例化
Taoy = Tao()
Taoy.__dict__
print(Taoy.name)
Taoy

4. 类和对象的成员分析

  • 类和对象都可以存储成员,成员可以归类所有,也可以归对象所有
  • 类存储成员时使用的是与类关联的一个对象
  • 独享存储成员是是存储在当前对象中
  • 对象访问一个成员时,如果对象中没有该成员,尝试访问类中的同名成员,

    如果对象中有此成员,一定使用对象中的成员
  • 创建对象的时候,类中的成员不会放入对象当中,而是得到一个空对象,没有成员
  • 通过对象对类中成员重新赋值或者通过对象添加成员时,对应成员会保存在对象中,而不会修改类成员

5. 关于self

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

    def say(self):     # 类方法
        self.name = "SA" 
print(A.name)
# 实例化的类属性和 类实例的属性都是指向同一个内存地址
print(id(A.name))
print("- " * 15)
a = A()
print(id(a.name))
Taoy
2971927025904
- - - - - - - - - - - - - - - 
2971927025904
# 查看 A类的所有属性
print(A.__dict__)
a = A()
a.name = "Taoy"
print(a.__dict__)
{'__module__': '__main__', 'name': 'Taoy', 'say': <function A.say at 0x000002B3F6433048>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
{'name': 'Taoy'}
# 类中方法的调用
class A():
    name = "A"
    def say(self):
        self.name = "Taoy"
        print("{0}, hello!".format(self.name))
a = A()
a.say()
Taoy, hello!
class A():
    name = "A"
    def say(self):
        self.name = "Taoy"
        print("{0}, hello!".format(self.name))
        # 调用类成员变量需要用 __class__
        print("{0}, hello!".format(__class__.name))
a = A()
a.say()
Taoy, hello!
A, hello!
# 关于self 的分析
class A():
    name = "A"
    
    def __init__(self):
        self.name = "Taoy"
    def say(self):
        print(self.name)
class B():
    name = "B"
a = A()
# 此时,系统会默认把a作为第一个参数传入函数
a.say()

# 此时, self 被a替换
A.say(a)
# 同时,可以把A作为参数传入
A.say(A)

# 传入的类实例B,因为B具有name属性,所以不会报错
A.say(B)

# 此代码利用的鸭子模型,可参考:https://www.cnblogs.com/dengl/p/11164662.html
Taoy
Taoy
A
B

6. 面向对象的三大特性

  • 封装
  • 继承
  • 多态

6.1 封装

  • 封装就是对对象的成员进行访问限制
  • 封装的三个级别:

    • 公开,public
    • 受保护的,protected
    • 私有的,private
    • public,private,protected不是关键字
  • 判别对象的位置

    • 对象内部
    • 对象外部
    • 子类中
  • python中下划线使用
  • 私有

    • 私有成员是最高级别的封装,只能在当前类或对象中访问
    • 在成员前面添加两个两个下划线即可
      class A():

      # name 是共有成员
      name = "A"
      # __age 就是私有成员
      __age = 19
  • Python的私有不是真私有,是一种成为name mangling的改名策略
    可以使用对象._classname_attributename访问
  • 受保护的封装 protected

    • 受保护的封装是将对象成员进行一定级别的封装,然后,在类中或者子类中都
      可以进行访问,但是在外部不可以
    • 封装方法: 在成员名称前天机爱一个下划线即可
  • 公开的,公共的 public

    • 公共的封装实际对成员没有任何操作,任何地方都可以访问
# 私有变量
class A():
    name = "A"
    __age = 19

a = A()
print(a.name)
print(a.__age)
A
---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-27-edbbbb4fbfe2> in <module>
      6 a = A()
      7 print(a.name)
----> 8 print(a.__age)
AttributeError: 'A' object has no attribute '__age'
# 私有变量 命名技术
print(A.__dict__)
print(a._A__age)
{'__module__': '__main__', 'name': 'A', '_A__age': 19, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
19
a._A__age = 18
print(a._A__age)
18

7 继承

  • 继承就是一个类可以获得另外一个类中的成员属性和成员方法
  • 作用: 减少代码,增加代码的复用功能, 同时可以设置类与类直接的关系
  • 继承与被继承的概念:

    • 被继承的类叫父类,也叫基类,也叫超类
    • 用于继承的类,叫子类,也叫派生类
    • 继承与被继承一定存在一个 is-a 关系
## 继承的语法
class Persion():
    name = "Noname"
    __score = 59
    _pet = "dog"
    
    def say(self):
        print("balabala...")

class Taoy(Persion):
    age = 19
    def sleep(self):
        print("Sleep...")
t = Taoy()
print(t.name)
print(t._pet) # 受保护的类可以在子类中进行访问

t.say()
print(t.age)
t.sleep()
Noname
dog
balabala...
19
Sleep...

继承的特征

  • 特性

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

    • 优先查找自己的变量
    • 没有则查找父类
    • 构造函数如果本类中没有定义,则自动查找调用父类构造函数
    • 如果本类有定义,则不在继续向上查找
  • 构造函数

    • 是一类特殊的函数,在类进行实例化之前进行调用
    • 如果定义了构造函数,则实例化时使用构造函数,不查找父类构造函数
    • 如果没定义,则自动查找父类构造函数
    • 如果子类没定义,父类的构造函数带参数,则构造对象时的参数应该按父类参数构造
  • super

    • super不是关键字, 而是一个类
    • super的作用是获取MRO(MethodResolustionOrder)列表中的第一个类
    • super于父类直接没任何实质性关系,但通过super可以调用到父类
    • super使用两个方,参见在构造函数中调用父类的构造函数
# 子类和父类定义同一个名称的变量,则优先使用子类本身
class Persion():
    name = "Noname"
    __score = 59
    _pet = "dog"
    
    def say(self):
        print("balabala...")

class Taoy(Persion):
    name = "Tao"
    age = 19
    def sleep(self):
        print("Sleep...")
t = Taoy()
print(t.name)
Tao
# 子类扩充父类方法1  - 父类调用相应函数
class Persion():
    name = "Noname"
    __score = 59
    _pet = "dog"
    
    def say(self):
        print("balabala...")
    def study(self):
        print("Study c")
        
class Taoy(Persion):
    name = "Tao"
    def sleep(self):
        print("Sleep....")
    def making_exam(self):
        print("Making exam") # 这个是扩充的内容
        
    def study(self):
        # 扩充父类的功能只需要调用父类相应的函数
        # Persion.study(self)
        # 扩充父类的另外一种方法
        # super 代表得到父类
        Persion.study(self)
        self.making_exam()
t = Taoy()
t.study()
Study c
Making exam
# 子类扩充父类方法2 - super()
class Persion():
    name = "Noname"
    __score = 59
    _pet = "dog"
    
    def say(self):
        print("balabala...")
    def study(self):
        print("Study c")
        
class Taoy(Persion):
    name = "Tao"
    def sleep(self):
        print("Sleep....")
    def making_exam(self):
        print("Making exam") # 这个是扩充的内容
        
    def study(self):
        # 扩充父类的功能只需要调用父类相应的函数
        # Persion.study(self)
        # 扩充父类的另外一种方法
        # super 代表得到父类
        super().study()
        self.making_exam()
t = Taoy()
t.study()
Study c
Making exam
  • 构造函数

    • 是一类特殊的函数,在类进行实例化之前进行调用
    • 如果定义了构造函数,则实例化时使用构造函数,不查找父类构造函数
    • 如果没定义,则自动查找父类构造函数
    • 如果子类没定义,父类的构造函数带参数,则构造对象时的参数应该按父类参数构造
# 构造函数的概念
class A():
    # __init__就是构造函数
    # 每次实例化的时候,第一个被自动的调用
    # 主要功能就是:初始化
    def __init__(self):
        print("My name is A")
a = A() # 实例化的时候会自动调用
My name is A
# 继承中的构造函数 - 1
class A():
    def __init__(self):
        print("A")
        
class B(A):
    def __init__(self):
        print("B")
        
class C(B):
    def __init__(self):
        print("C")
# 实例化的时候,自动调用了C的构造函数
# 因为找到了构造函数,所以不再查找父类的构造函数
c = C()

# 自身没有构造函数, 调用父类B的构造函数
class D(B):
    pass
d = D()
C
B
# 继承中的构造函数 - 2 

class A():
    def __init__(self):
        print("A")
        
class B(A):
    def __init__(self, name):  # 两个参数
        print("B")
        
class C(B):
    def __init__(self):
        print("C")
# 实例化的时候,自动调用了C的构造函数
# 因为找到了构造函数,所以不再查找父类的构造函数
c = C()

# 自身没有构造函数, 调用父类B的构造函数
class D(B):
    pass
d = D() # 此时因为父类 B 的构造函数需要两个参数,实例化只给了一个,所以报错
C
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-44-2dc7f0ba696c> in <module>
     19 class D(B):
     20     pass
---> 21 d = D() # 此时因为父类 B 的构造函数需要两个参数,实例化只给了一个,所以报错
TypeError: __init__() missing 1 required positional argument: 'name'
# 继承中的构造函数 - 3
class A():
    def __init__(self):
        print("A")

class B(A):
    pass

class C(B):
    pass

c = C()  # 找->B无构造方法->因为B是继承与A->找A调用A的构造方法
A
  • super

    • super不是关键字, 而是一个类
    • super的作用是获取MRO(MethodResolustionOrder)列表中的第一个类
    • super于父类直接没任何实质性关系,但通过super可以调用到父类
    • super使用两个方,参见在构造函数中调用父类的构造函数
print(type(super))
help(super)
<class 'type'>
Help on class super in module builtins:

class super(object)
 |  super() -> same as super(__class__, <first argument>)
 |  super(type) -> unbound super object
 |  super(type, obj) -> bound super object; requires isinstance(obj, type)
 |  super(type, type2) -> bound super object; requires issubclass(type2, type)
 |  Typical use to call a cooperative superclass method:
 |  class C(B):
 |      def meth(self, arg):
 |          super().meth(arg)
 |  This works for class methods too:
 |  class C(B):
 |      @classmethod
 |      def cmeth(cls, arg):
 |          super().cmeth(arg)
 |  
 |  Methods defined here:
 |  
 |  __get__(self, instance, owner, /)
 |      Return an attribute of instance, which is of type owner.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __self__
 |      the instance invoking super(); may be None
 |  
 |  __self_class__
 |      the type of the instance invoking super(); may be None
 |  
 |  __thisclass__
 |      the class invoking super()
  • 单继承和多继承

    • 单继承:每个类只能继承一个类
    • 多继承,每个类允许继承多个类
  • 单继承和多继承的优缺点

    • 单继承:

      • 传承有序逻辑清晰语法简单隐患少呀
      • 功能不能无限扩展,只能在当前唯一的继承链中扩展
    • 多继承:

      • 优点:类的功能扩展方便
      • 缺点:继承关系混乱
  • 菱形继承/钻石继承问题

    • 多个子类继承自同一个父类,这些子类由被同一个类继承,于是继承关系图形成一个菱形图谱
    • MRO
    • 关于多继承的MRO

      • MRO就是多继承中,用于保存继承顺序的一个列表
      • python本身采用C3算法来多多继承的菱形继承进行计算的结果
      • MRO列表的计算原则:

        • 子类永远在父类前面
        • 如果多个父类,则根据继承语法中括号内类的书写顺序存放
        • 如果多个类继承了同一个父类,孙子类中只会选取继承语法括号中第一个父类的父类
  • 构造函数

    • 在对象进行实例化的时候,系统自动调用的一个函数叫构造函数,通常此函数用来对实例对象进行初始化,顾名
    • 构造函数一定要有,如果没有,则自动向上查找,按照MRO顺序,直到找到为止
# 多继承的例子
# 子类可以直接拥有父类的属性和方法,私有属性和方法除外

class A():
    def __init__(self, name):
        self.name = name
    def a(self):
        print("A")
        
class B():
    def __init__(self, name):
        self.name = name
    def b(self):
        print("B")

class C():
    def __init__(self, name):
        self.name = name
    def c(self):
        print("C")

# 单继承的例子
class D(C):
    def __init__(self, name):
        self.name = name
d = D('d')
d.c()
print("- " * 15)

# 多继承的例子
class F(C, B, A):
    def __init__(self, name):
        self.name = name

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


f = F("f")
f.a()
f.b()
f.c()
print("- " * 15)

g = G("g")
g.b()
g.c()
    
C
- - - - - - - - - - - - - - - 
A
B
C
- - - - - - - - - - - - - - - 
B
C
# 菱形继承问题
class A():
    pass
class B(A):
    pass
class C(A):
    pass
class D(B, C):
    pass
# 构造函数的例子
class Info():
    def __init__(self):
        self.name = "Taoy"
        self.age = 19
        self.score = 59
        print("I am very happy!")
t = Info()
I am very happy!
# 构造函数的调用顺序 - 1
# 如果子类中没有写构造函数,则会自动向上(父类)寻找, 直到找到

class A():
    def __init__(self):
        print("A")
class B(A):
    def __init__(self):
        print("B")
    
class C(B):
    pass
# 首先,查找自身有无构造函数, 如果没有,则向上父类寻找,直到找到
c = C()
        
B
# 构造函数的调用顺序 - 2
# 如果子类中没有写构造函数,则会自动向上(父类)寻找, 直到找到

class A():
    def __init__(self):
        print("A")
class B(A):
    def __init__(self, name):
        print("B")
        print(name)
    
class C(B):
    pass
# 首先,查找自身有无构造函数, 如果没有,则向上父类寻找,直到找到
# 这里遇到参数结构不对应错误
c = C()     
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-64-7848e010e947> in <module>
     13     pass
     14 # 首先,查找自身有无构造函数, 如果没有,则向上父类寻找,直到找到
---> 15 c = C()
TypeError: __init__() missing 1 required positional argument: 'name'
## 构造函数的调用顺序 - 3
class A():
    def __init__(self):
        print("A")
class B(A):
    def __init__(self, name):
        print("B")
        print(name)
    
class C(B):
    # C中想扩展B的构造函数,
    # 即调用B的构造函数后在添加一些功能
    # 由两种方法实现
    
    '''
    # 第一种是通过父类名调用
    def __init__(self, name):
        # 首先调用父类构造函数
        B.__init__(self, name)
        # 其次,再增加自己的功能
        print("+other thing!")
    '''  
    # 第二种,直接使用Super 调用:
    def __init__(self, name):
        # 首先调用父类构造函数
        super(C, self).__init__(name)
         # 其次,再增加自己的功能
        print("+other thing!")
c = C("My name is C")
B
My name is C
+other thing!

7.1 多态

  • 多态就是同一个对象在不同情况下有不同的状态出现
  • 多态不是语法,是一种设计思想
  • 多态性: 一种调用方式,不同的执行效果
  • 多态: 同一事物的多种形态,动物分为人类,狗类,猪类
  • 多态和多态性
  • Mixin设计模式

  • 我们使用多继承语法来实现Minxin
  • 使用Mixin实现多继承的时候非常小心

    • 首先他必须表示某一单一功能,而不是某个物品
    • 职责必须单一,如果由多个功能,则写多个Mixin
    • Mixin不能依赖于子类的实现
    • 子类及时没有继承这个Mixin类, 也能照样工作,只是缺少了某个功能
  • 优点

    • 使用Mixin可以在不对类进行任何修改的情况下,扩充功能
    • 可以方便的组织和维护不同功能组件的划分
    • 可以根据需要任意调整功能类的组合
    • 可以避免创建很多新的类,导致类的继承混乱
# Mixin 案例
class Persion():
    name = "Taoy"
    age = 18
    
    def eat(self):
        print("Eating....")
    def sleep(self):
        print("Sleep.....")
    
class Teacher(Persion):
    def work(self):
        print("working....")

class Student(Persion):
    def study(self):
        print("Study....")
        
class Tutor(Teacher, Student):
    pass

t = Tutor()
print(Tutor.__mro__)
print(t.__dict__)
print(Tutor.__dict__)

class TeacherMixin():
    def work(self):
        print("working...")
class StudentMixin():
    def study(self):
        print("Study....")
        
class Tutorm(Persion, TeacherMixin, StudentMixin):
    pass
tt = Tutorm()
print(Tutorm.__mro__)
print(tt.__dict__)
print(Tutorm.__dict__)
(<class '__main__.Tutor'>, <class '__main__.Teacher'>, <class '__main__.Student'>, <class '__main__.Persion'>, <class 'object'>)
{}
{'__module__': '__main__', '__doc__': None}
(<class '__main__.Tutorm'>, <class '__main__.Persion'>, <class '__main__.TeacherMixin'>, <class '__main__.StudentMixin'>, <class 'object'>)
{}
{'__module__': '__main__', '__doc__': None}

8 类相关函数

  • issubclass:检测一个类是否是另一个类的子类
  • isinstance:检测一个对象是否是一个类的实例
  • hasattr:检测一个对象是否由成员xxx
  • getattr: get attribute
  • setattr: set attribute
  • delattr: delete attribute
  • dir: 获取对象的成员列表
# issubclass 检测一个类是否是另一个类的子类
class A():
    pass
class B(A):
    pass
class C():
    pass

print(issubclass(B, A))
print(issubclass(C, A))
print(issubclass(A, object))

# isinstance 检测一个类是否是另一个类的子类
print("- " * 6)
a = A()
print(isinstance(a, A))
print(isinstance(A, A))

# hasattr 检测一个对象是否由成员xxx
print("- " * 6)
class D():
    name = "Taoy"
d = D()
print(hasattr(d, "name"))
print(hasattr(d, "hhh"))

# getattr: get attribute
print("- " * 6)
print(getattr(d, "name")) # 获取

# setattr: set attribute
setattr(a, "age", 19)
print(getattr(a, "age"))
True
False
True
- - - - - - 
True
False
- - - - - - 
True
False
- - - - - - 
Taoy
19
- - - - - - 
# dir 
print("- " * 6)
class A():
    pass
a = A()
print(dir(a))
- - - - - - 
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']

9. 类的成员描述符(属性)

  • 类的成员描述符是为了在类中对类的成员属性进行相关操作而创建的一种方式

    • get: 获取属性的操作
    • set:修改或者添加属性操作
    • delete: 删除属性的操作
  • 如果想使用类的成员描述符,大概有三种方法

    • 使用类实现描述器
    • 使用属性修饰符
    • 使用property函数

      • property函数很简单
      • property(fget, fset, fdel, doc)
  • 无论哪种修饰符都是为了对成员属性进行相应的控制

    • 类的方式: 适合多个类中的多个属性共用用一个描述符
    • property:使用当前类中使用,可以控制一个类中多个属性
    • 属性修饰符: 使用于当前类中使用,控制一个类中的一个属性
# 属性例子
# 创建 Student 类,描述学生, 
# 学生具有 name, age
# name格式使用大写
# 可以增加一个函数,然后自动调用,但是很笨
class Student():
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
        # 不想修改代码
        self.setname(name)
    def say_hello(self):
        print("Hi, My name is {0}".format(self.name))
    def setname(self, name):
        self.name = name.upper()
s = Student("Taoy", 19)
s.say_hello()
Hi, My name is TAOY
# peroperty 案例
# 创建 Student 类,描述学生, 
# 学生具有 name, age
# name格式使用大写
# x = property(fget, fset, fdel, doc)

class Student():
    
    def fget(self):
        return self._name * 2
    def fset(self, name):
        self._name = name.upper()
    def fdel(self):
        self._name = "Noname"
    name = property(fget, fset, fdel, "Change name")

s = Student()
s.name = "Taoy"
print(s.name)

# 也可以参考: https://www.cnblogs.com/happyyangyanghappy/p/10917139.html
TAOYTAOY

类的内置属性

  • __dict__:以字典的方式显示类的成员组成
  • __doc__: 获取类的文档信息
  • __name__:获取类的名称,如果在模块中使用,获取模块的名称
  • __bases__: 获取某个类的所有父类,以元组的方式显示
class Student():
    '''
    Students kind
    '''
    
    def fget(self):
        return self._name * 2
    def fset(self, name):
        self._name = name.upper()
    def fdel(self):
        self._name = "Noname"
    name = property(fget, fset, fdel, "Change name")

s = Student()
s.name = "Taoy"
# print(s.name)
print(Student.__dict__)
print(Student.__doc__)
print(Student.__name__)
print(Student.__bases__)
{'__module__': '__main__', '__doc__': '\n    Students kind\n    ', 'fget': <function Student.fget at 0x000001BE64F6F488>, 'fset': <function Student.fset at 0x000001BE64F6F598>, 'fdel': <function Student.fdel at 0x000001BE64F6F0D0>, 'name': <property object at 0x000001BE650084A8>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>}

    Students kind
    
Student
(<class 'object'>,)

10. 类的常用魔术方法

  • 魔术方法就是不需要人为调用的方法,基本是在特定的时刻自动触发
  • 魔术方法的统一的特征,方法名被前后各两个下滑线包裹
  • 操作类

    • __init__: 构造函数
    • __new__: 对象实例化方法,此函数较特殊,一般不需要使用
    • __call__: 对象当函数使用的时候触发
    • __str__: 当对象被当做字符串使用的时候调用
    • __repr__: 返回字符串,跟__str__具体区别请百度
  • 描述符相关

    • __set__
    • __get__
    • __delete__
  • 属性操作相关

    • __getattr__: 访问一个不存在的属性时触发
    • __setattr__: 对成员属性进行设置的时候触发

      • 参数:

        • self用来获取当前对象
        • 被设置的属性名称,以字符串形式出现
        • 需要对属性名称设置的值
      • 作用:进行属性设置的时候进行验证或者修改
      • 注意: 在该方法中不能对属性直接进行赋值操作,否则死循环
  • 运算分类相关魔术方法

    • __gt__: 进行大于判断的时候触发的函数

      • 参数:

        • self
        • 第二个参数是第二个对象
        • 返回值可以是任意值,推荐返回布尔值
# init  构造函数
class A():
    def __init__(self):
        print("一开始就被调用了")
a = A()
一开始就被调用了
# __call__ 对象当函数使用的时候触发
class A():
    def __init__(self):
        print("一开始就被调用")
    def __call__(self):
        print("我被当做函数调用了")
a = A()
a()
一开始就被调用
我被当做函数调用了
# __str__ 当对象被当做字符串使用的时候调用
class A():
    def __init__(self):
        print("一开始就被调用")
    def __call__(self):
        print("我被当做函数调用了")
    def __str__(self):
        return "可能我被打印了"
a = A()
print(a)
一开始就被调用
可能我被打印了
# __getattr__ 访问一个不存在的属性时触发
class A():
    name = "Noname"
    
    def __getattr__(self, name):
        print("{0} 这个啥玩意,没找到呀".format(name))
a = A()
print(a.name)
print(a.betao)
Noname
betao 这个啥玩意,没找到呀
None
# __setattr__: 对成员属性进行设置的时候触发
class A():
    def __init__(self):
        pass
    def __setattr__(self, name, value):
        print("设置的属性:{0}.".format(name))
        # 下面语句会导致问题,死循环
        #self.name = value
        # 此种情况,为了避免死循环,规定统一调用父类魔法函数
        super().__setattr__(name, value)
a = A()
print(a.__dict__)
a.name = "taoy"
print(a.__dict__)
{}
设置的属性:name.
{'name': 'taoy'}
# __gt__: 进行大于判断的时候触发的函数
class A():
    def __init__(self, name):
        self._name = name
    def __gt__(self, obj):
        print("hh, {0} 比 {1} 大?".format(self, obj))
        return self._name > obj._name
a = A("one")
b = A("Two")
print(a > b)
hh, <__main__.A object at 0x000001BE65508898> 比 <__main__.A object at 0x000001BE655088D0> 大?
True

11.类和对象的三种方法

  • 实例方法

    • 需要实例化对象才能使用的方法,使用过程中可能需要截止对象的其他对象的方法完成
  • 静态方法

    • 不需要实例化,通过类直接访问
  • 类方法

    • 不需要实例化
  • 三个方法具体区别

    • 1.实例方法只能由实例调用,并且一般使用self作为实例本身在类实例化的时候进行传参;
    • 2.普通方法只能由类调用,不能由实例调用,可以在类内部被其他函数调用;
    • 3.静态方法和类方法都可以由类和实例调用。
class Person:
    def sleep(self):
        print(self)
        print("Sleep....")
    # 类方法
    # 类方法的第一个参数,一般命名为 cls, 区别于 self
    @classmethod
    def play(cls):
        print(cls)
        print("Playing....")
    
    # 静态方法
    # 无需第一个参数表示自身或者类
    @staticmethod
    def say():
        print("Saying...")

p = Person()

# 实例方法
p.sleep()
# 类方法
Person.play()
p.play()
# 静态方法
Person.say()
p.say()
<__main__.Person object at 0x000001BE64F74DD8>
Sleep....
<class '__main__.Person'>
Playing....
<class '__main__.Person'>
Playing....
Saying...
Saying...

抽象类

待更...

自定义类

待更...

本文链接:

https://www.betao.cn/archives/python-review06.html
1 + 6 =
1 评论
    绅士福利Chrome 65Windows 10
    1月22日 回复

    专业哈!!!