类中的魔法方法

　　在python中有很多魔法方法，常见的__init__(self)就是魔法方法的一种，类绑定对象是自动触发。那就来聊一聊其他的魔法方法。

__str__方法

　　这中方法需要返回值，并且返回值为字符串类型。

# str 方法
class A:
    def __str__(self):        # 打印对象self触发。注销是结果1，未注销时结果2
        return '<class A>'
    pass
a = A()
print(a)    # 结果1：<__main__.A object at 0x0000026AF987D208> 结果2： <class A>

__del__方法

　　这种方法在删除对象时，程序结束时（类的对象消失）会自动触发

# del 方法
class A:
    def __del__(self):    # self删除时触发
        print('aaaa')
    pass
a = A()
print(a)

__call__方法

　　在类中定义此函数。对象调用此函数只需要对象名加()，即可调用此函数。

class A:
    def __call__(self, *args, **kwargs):
        print('aaa')
a = A()
a()     # 执行__call__函数 结果:aaa

__slots__方法

　　这方法形式不是一个函数形式(没有def)，它可给类划分适合大小的内存存储属性，但是也限制了类的扩展其他属性。

#  slots方法  
import sys
class A:
    __slots__ = ['name']          # 限制类的属性，在这设置，
    def __init__(self, name):
        self.name = name
a = A('meking')               # 不能添加其他属性，否则报错
print(sys.getsizeof(a))     # 查看类的内存大小  》》》48

点语法的实现

　　在实现点语法需要getattr，setatter， delattr这几个函数。getattr,在查找某个属性名，无此属性会触发。setattr，在给某个属性名赋值是会触发。delattr，在删除属性名会被触发。getattribute不可与setatter一起使用。它的用法是，已经有点属性值，调用时，它会被触发。

class A:
    age = 1     # 测试getattribute函数
    def __getattr__(self, key):
        return 'getattr', key

    def __setattr__(self, key, value):
        self.__dict__[key] = value   # 类内的属性值与名是以字典键值对的形式绑定
        print('setattr', key, value, self.__dict__[key])

    def __delattr__(self, key):
        del self.__dict__[key]
        print('delattr', key)

    def __getattribute__(self, key):  # 属性存在，使用.属性名称优先执行此函数

        return key, 'getattribute'
a = A()
print(a.age)    # 不存在的一个属性,执行getattr函数，并且此函数有返回值，不写为None
a.name = '值'   # .语法绑定值时 执行setattr函数。 无返回值
del a.name      # 删除属性时。执行delattr函数

[ ]语法的实现

　　这种语法需要关键字getitem, setitem, setitem, delitem。调用属性名对应的值，可以用调用字典的方式。

class A:
    def __getitem__(self, item):
        print('getitem')
        return 'getitem', item

    def __setitem__(self, key, value):
        self.__dict__[key] = value
        print('setitem')
        return self.__dict__[key], value

    def __delitem__(self, key):
        print('delitem')
        del self.__dict__[key]
a = A()
print(a['age'])   # 类中无此属性名，先执行getitem函数
a['age'] = 18    # 先执行setitem函数
del a['age']     # 执行delitem函数

运算符在对象中的应用

　　类之间，对象之间也可以比大小。比值需要依据比值的规则。在gt, lt , eq即可实现。

class A:
    def __init__(self,name, age):
        self.name = name
        self.age = age
    def __gt__(self, other):       # 对象与对象之间比较，
        if self.age > other.age:   # 比较的标准,依据年龄
            return True
        else:
            return False
a = A('MEKING', 20)
b = A('meking', 18)
print(a > b)

类中定义迭代器 

class A:
    def __init__(self, start, end, step):
        self.start = start
        self.end = end
        self.step = step

    def __iter__(self, ):
        return self  # 返回本身

    def __next__(self):
        a = self.start
        self.start += self.step
        if a < self.end:
            return a
        else:
            raise StopIteration            # 终止循环。不然会死循环


print(A(1, 10, 1).__iter__())  # __inter__方法

for i in A(1, 10, 1):         # 迭代取值
    print(i, end=', ')

类中的上下文管理

class A:
    def __init__(self, path):  # 传入文件路径
        self.file = open(path)  # 打开文件
    def __enter__(self):
        res = self.file.read()
        return res             # 返回对象本身
    def __exit__(self, exc_type, exc_val, exc_tb):  # exc_type,exc_cal，exc_tb已将捕获
        self.file.close()
        return True
with A('a.txt') as f:
    print(f)

多态

　　多态是一种概念，在python中满足能够相应同一方法，产生不同结果的都可以称之为多态。在计算字符串，列表，字典的长度都可以使用len()这个方法，但是结果不同，这种就可以成为多态的一种现象。

其他方法（也很重要）

　　isinstance(a, b):实质是判断a这个对象是不是b这个类型的。对象和类之间的判断

　　issubclass(a, a)，判断类与类之间是否有继承关系。 类与类之间判断