python面向对象--类的特殊成员&&如何调用其他类的成员

1     主动调用其他类的成员

若子类和父类有相同的方法，那么该如何都调用呢？

1.1   方式一  ：类.方法（self）

class Base(object):

    def f1(self):
        print('5个功能')

class Foo(object):

    def f1(self):
        print('3个功能')
        Base.f1(self)

obj = Foo()
obj.f1()

注意：类.方法（self）----需要自己写参数

 

1.2   方式二：按照类的继承顺序，找下一个

class Foo(object):

    def f1(self):

        super().f1()

        print('3个功能')


class Bar(object):

    def f1(self):

        print('6个功能')

 

class Info(Foo,Bar):

    pass

 

obj = Info()

obj.f1()

注意：按照类的继承顺序，找下一个。而不是按照继承关系找

super().f1()和self.f1()方式不同，self每次得回Info去寻找，而super直接按照Info--->Foo--->Bar顺序执行

 

2     类的特殊成员

这些特殊成员并没有特殊的功能，仅仅是某些外部的操作触发了特定的特殊成员

2.1   __init__()  &&  __new__()    构造方法

类名() -------》自动执行__new__/ __init__

 

class Foo:

    def __init__(self,a1,a2):       #初始化方法
        #为空对象进行数据初始化
        self.a1 = a1
        self.a2 = a2
        print(2)

    def __new__(cls, *args, **kwargs):   #构造方法
        #创建一个空对象
        print(1,args,kwargs)
        return object.__new__(cls)      #python内部创建一个当前类的对象（初创时内部是空的）

obj = Foo(3,4)
#1 (3, 4) {}
#2

注意：1:__new__()必须要有返回值，返回一个对象，因此传给__init__的self就是一个对象

2:先执行__new__()后执行__init__()

3:所有的对象的创建都是由object创建的

      4：注意：并不是__new__()就是构造函数的意思，是因为obj = Foo(3,4)触发了__new__()的自动执行

 

2.2   __call__()

对象（） -------》自动执行__call__

class Foo:
    def __init__(self,a1,a2):       #初始化方法
        #为空对象进行数据初始化
        self.a1 = a1
        self.a2 = a2
        print(2)

    def __call__(self, *args, **kwargs):
        print(111,args,kwargs)

obj = Foo(3,4)
ret = obj()

 

2.3   __getitem__()

对象['xx'] ------》 自动执行 __getitem__

 

class Foo:

    def __init__(self,a1,a2):       #初始化方法
        #为空对象进行数据初始化
        self.a1 = a1
        self.a2 = a2
        print(2)

    def __getitem__(self, item):
        print(item)

obj = Foo(3,4)
ret = obj[5]

 

 

2.4   __setitem__()   

对象['xx'] = xxx     自动执行 __setitem__

class Foo:

    def __init__(self,a1,a2):       #初始化方法
        #为空对象进行数据初始化
        self.a1 = a1
        self.a2 = a2
        print(2)
    def __setitem__(self, key, value):
        print(key,value)
        return 1

obj = Foo(1,2)
obj['k1'] = 123

# k1 123

注意：没有返回值

 

2.5   __delitem__() 

del 对象[xx]     自动执行 __delitem__

class Foo:
    def __init__(self,a1,a2):       #初始化方法
        #为空对象进行数据初始化
        self.a1 = a1
        self.a2 = a2
        print(2)

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

obj = Foo(1,2)
del obj['uuu']

注意：无返回值

 

2.6   __add__() 

对象+对象     自动执行 __add__

class Foo(object):

    def __init__(self, a1, a2):
        self.a1 = a1
        self.a2 = a2

    def __add__(self, other):
        return self.a1 + other.a2

obj1 = Foo(1,2)
obj2 = Foo(3,4)
ret = obj1 + obj2
print(ret)

注意：obj1，obj2  与  self, other两两对应

 

2.7   __enter__() && __exit__()

with 对象        自动执行 __enter__ / __exit__

 

class Foo(object):
    def __init__(self, a1, a2):
        self.a1 = a1
        self.a2 = a2

    def __enter__(self):
        print('1111')
        return 999

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('22222')

obj = Foo(1,2)
with obj as f:
    print(f)
    print('内部代码')

 

答案：

'''
1111
999
内部代码
22222
'''

 

2.8   __str__()

 作用：

把打印的对象变成字符串

 

 用法举例：

class Foo(object):
    def __init__(self):
        pass
    def func(self):
        pass
    def __str__(self):
        return 'F1'

obj = Foo()
print(obj)

 

2.9   __iter__()

 作用：

如果想要把不可迭代对象 -> 可迭代对象

1. 在类中定义__iter__方法

2. iter内部返回一个迭代器(生成器也是一种特殊迭代器)

 

 用法举例：

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

    def func(self):
        pass
    def __iter__(self):
        # return  iter([1,2])     #用法一
        yield 1                   #用法二
        yield 2

obj1 = Foo('刘we',99)
for item in obj1:
    print(item)

注意：iter()相当于for  xx in ,这个可以实验一下

return  iter()------->就是把可迭代对象转化成迭代器返回

 

 

2.10   __dcit__

作用：

把对象封装的所有值以字典拿到

 用法举例：

class Foo(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.s = None

    def func(self):
        pass

obj1 = Foo('liu',99)
obj2 = Foo('op',89)

print(obj1.__dict__)
print(obj2.__dict__)
# {'name': 'liu', 'age': 99, 's': None}
# {'name': 'op', 'age': 89, 's': None}

 

2.11  __doc__

作用：获取注释信息

 用法举例：

class Foo:
    '''
    asfffgfg
    '''
    def __init__(self,name):
        self.name = name
    def func(self):
        pass

obj  = Foo(1)
print(obj.__doc__)      #asfffgfg

2.12 __getattr__（）

作用：对象.x

class Local(object):
    def __getattr__(self, item):
        return 333

obj = Local()
print(obj.x)    #333

 2.13 __setattr__（）

作用：对象.x = 值

 

class Foo():
    def __init__(self):
        self.name = 'alex'  #默认自己类中执行__setattr__

    # def __setattr__(self, key, value):
    #     pass
    #     object.__setattr__(self, key, value)


obj = Foo()
print(obj.name)
#对象.x默认先执行自己类里面的__setattr__方法，自己类里面没有，则去父类里面找。
# 对象在实例化过程中默认先执行__new__方法，然后在执行__init__方法

 

 2.14 __eq__

 

 2.15 __hash__