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__。