Python入门（二十）——复习面向对象编程进阶知识——类特殊成员

1. 构造方法(__init__)和析构方法(__del__)

构造方法在前节讲过，在创建对象（类加括号）时候调用

对象被销毁时自动调用

'''上述两个方法举例'''
class MyClass:
    def __init__(self):
        print('创建对象', self)

    def __del__(self):
        print('销毁对象', self)

    def wait(self):
        for i in range(100000):
            pass
        print('等待结束')

obj = MyClass()
obj.wait()

执行结果：

2. __call__ 方法：对象加括号调用

'''__call__方法'''
class MyClass:
    def __call__(self, *args, **kwargs):
        print('调用call方法')


obj  = MyClass()
print('创建对象')
obj()

运行结果：

3. __str__ 方法：str（）或print（）会调用

'''__str__方法'''
class MyClass:
    def __str__(self):
        print('调用str方法')
        return 'you want'

obj  = MyClass()
print(obj)
s = str(obj)
print(s)

运行结果：

4. 加减乘除（用__add __举例）

'''加减乘除'''
class MyClass:
    def __add__(self, other):
        print('调用__add__方法', self)
        return 'you want __add__'

    def __sub__(self, other):
        print('调用__sub__方法', self)
        return 'you want __sub__'

    def __mul__(self, other):
        print('调用__mul__方法', self)
        return 'you want __mul__'

    def __divmod__(self, other):
        print('调用__divmod__方法', self)
        return 'you want __divmod__'

obj1  = MyClass()
obj2 = MyClass()

ret = obj1 + obj2
print(ret)


ret = obj1 - obj2
print(ret)


ret = obj1 * obj2
print(ret)


ret = obj1 // obj2
print(ret)

不知道除法咋写

5. 字典方法（__dict __）

返回对象中的所有内容，一般就是存入对象内存的字段的值
类调用的话会返回类中所有内容，这个一般用的比较多

'''字典方法'''
class MyClass:
    '''这是类的注释'''
    country = 'china'
    def __init__(self, age):
        self.name = 'zhao'
        self.age = age

    def myfoo(self):
        print(self.name)
        pass


obj = MyClass(24)
print(obj.__dict__)
print(MyClass.__dict__)

执行结果：

6. 列表方法 [ ]（__getitem __、__setitem __、__delitem __）

'''列表方法（__getitem __、__setitem __、__delitem __）'''
class MyClass:
    def __init__(self, lst):
        self.mylist = lst

    def __getitem__(self, item):
        print('调用getitem')
        return self.mylist[item]

    def __setitem__(self, key, value):
        self.mylist[key] = value

    def __delitem__(self, key):
        del self.mylist[key]

obj = MyClass([1, 2, 3, 4, 'zhao'])
print(obj[1])
obj[1] = 'ren'
print(obj[1])
del obj[1]
print(obj[1])

运行结果：

7. 列表切片[a: b: c] （还是getitem方法）

相当于传入的参数item变为slice（切片），加入type（item）==slice判断即可完成

'''列表切片[a: b: c] （还是getitem方法）'''
class MyClass:
    def __init__(self):
        self.list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    def __getitem__(self, item):
        if type(item) == slice:
            start = item.start
            stop = item.stop
            step = item.step
            print(start, stop, step)
            return self.list[start:stop:step]

obj = MyClass()
print(obj[-1::-2])
print(obj[0:6])
print(obj[0:6:2])

运行结果

8. 迭代方法（__iter(self) __)

'''迭代方法（__iter(self) __)'''
class MyClass:
    def __init__(self):
        self.list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    def __iter__(self):
        return iter(self.list)

obj = MyClass()
for i in obj:
    print(i)

运行结果，不报错，自动进行next()方法迭代

9. __new __ 和 __metaclass __（知道过程即可）

第一阶段：解释器从上到下执行代码创建Foo类
对于type类，Foo相当于是对象，因此先执行MyType类中的__init__方法

第二阶段：通过Foo类创建obj对象
当Foo()加括号时相当于对象加括号，调用MyType类中的__call__方法
__call__方法用Foo新建对象，并调用新建对象的__init__方法

class MyType(type):
    def __init__(self, what, bases=None, dict=None):
        print('MyType.__init__')
        super(MyType, self).__init__(what, bases, dict)

    def __call__(self, *args, **kwargs):
        obj = self.__new__(self, *args, **kwargs)
        self.__init__(obj)


class Foo(object):
    __metaclass__ = MyType
    def __init__(self, name):
        self.name = name

    def __new__(cls, *args, **kwargs):
        return object.__new__(cls, *args, **kwargs)
# 第一阶段：解释器从上到下执行代码创建Foo类
#          对于type类，Foo相当于是对象，因此先执行MyType类中的__init__方法
#
# 第二阶段：通过Foo类创建obj对象
#          当Foo()加括号时相当于对象加括号，调用MyType类中的__call__方法
#          __call__方法用Foo新建对象，并调用新建对象的__init__方法
obj = Foo('zhao')
print(obj.name