类python中高级用法

1. __call__用法

class Foo:
    def __init__(self):
        print('init')

    def __call__(self, *args, **kwargs):
        print('call')

# obj = Foo()
# obj()
Foo()()

类对象后面加()是执行类中的__call__方法。用处稍后说

2. __int__和__str__方法

class Foo:

    def __init__(self):
        pass

    def __int__(self):
        return 1111

    def __str__(self):
        return 'hello world'

obj = Foo()
print(obj, type(obj))

# int,对象，自动执行对象的 __int__方法，并将返回值赋值给int对象
r = int(obj)
print(r)
i = str(obj)
print(i)

class Foo:

def __init__(self,n,a):
        self.name =n
        self.age =a

def __str__(self):
        return '%s-%s' %(self.name,self.age,)

obj = Foo('pis', 18)
print(obj) #print(str(obj)) str(obj)   obj中__str__，并获取其返回值

3. 运算符重载举例__add__，__del__析构方法

class Foo:

    def __init__(self, name,age):
        self.name = name
        self.age = age

    def __add__(self, other):
        return Foo(self.name, other.age)

    def __del__(self):
        print('析构方法') # 对象被销毁（）时，自动执行

obj1 = Foo('hello', 19)
obj2 = Foo('world', 66)

r = obj1 + obj2
# 两个对象相加时，自动执行第一个对象的的 __add__方法，并且将第二个对象当作参数传递进入
print(r,type(r))

4. __dict__方法查看封装内容

class Foo:
    def __init__(self, name,age):
        self.name = name
        self.age = age
        self.n = 123

# obj = Foo('pis', 18)
#
# d = obj.__dict__
# print(d)

# ret = Foo.__dict__
# print(ret)

5. __getitem__,__setitem__，__delitem__

class Foo:

    def __init__(self, name,age):
        self.name = name
        self.age = age

    def __getitem__(self, item):
        return item+10

    def __setitem__(self, key, value):
        print(key,value)

    def __delitem__(self, key):
        print(key)
li = Foo('pis', 18)
r= li[8] # 自动执行li对象的类中的 __getitem__方法，8当作参数传递给item
print(r)
li[100] = "asdf"
del li[999]

class Foo:

    def __init__(self, name,age):
        self.name = name
        self.age = age

    def __getitem__(self, item):
        # return item+10
        # 如果item是基本类型：int，str，索引获取
        # slice对象的话，切片
        if type(item) == slice:
            print('调用这希望内部做切片处理')
            print(item.start)
            print(item.stop)
            print(item.step)
        else:
            print('调用这希望内部做索引处理')

    def __setitem__(self, key, value):
        print(key,value)

    def __delitem__(self, key):
        print(key)

li = Foo('pis', 18)
li[123]
li[1:4]

6. __iter__方法

class Foo:

    def __init__(self, name,age):
        self.name = name
        self.age = age

    def __iter__(self):
        return iter([11,22,33])
li = Foo('pis', 18)
# 如果类中有 __iter__ 方法，将对象=》可迭代对象，没有则报错
# 对象.__iter__() 的返回值： 迭代器
# for 循环，迭代器，next
# for 循环，可迭代对象，对象.__iter__()，迭代器，next
# 1、执行li对象的类F类中的 __iter__方法，并获取其返回值
# 2、循环上一步中返回的对象
for i in li:
    print(i)
"""

7. metaclass 作用

class MyType(type):
    def __init__(self,*args, **kwargs):
        # self=Foo
        print(123)
        pass

    def __call__(self, *args, **kwargs):
        # self=Foo
        r = self.__new__()
        self.__init__()

#

class Foo(object,metaclass=MyType):
    def __init__(self):
        pass

    def __new__(cls, *args, **kwargs):
        return '对象'

    def func(self):
        print('hello world')

obj = Foo()

在创建类时，obj为Foo对象，而Foo为metaclass对象，默认为type，即metaclass=type，可以用自己创建的类为metaclass，继承type后加上自己的内容即可。

　　我们看到的是创建对象时直接执行__init__(),实际上Foo是type的对象，先执行type的__init__,

然后Foo(),由上面知道是执行type中的__call__方法。在__call__方法中创建的对象，也就是Foo类的__new__和__init__。