类的组合和其他特殊成员

Posted 2021-01-02 --kai

类的组合

1.1

class Foo(object):

    def __init__(self,age):
        self.age = age      # 封存了 8 和 9 

    def display(self):
        print(self.age)      # 没有参数传入 所以是None

data_list = [Foo(8),Foo(9)]
for item in data_list:
    print(item.age,item.display())

‘‘‘输出结果:
8
8 None
9
9 None
‘‘‘

1.2

类的特殊成员

1. __doc__

表示类的描述信息

class Foo:
    """描述一个类的信息,这是一个用于听音乐的"""
    
    def func(self):
        pass



print(Foo.__doc__)

# 输出结果: 描述一个类的信息,这是一个用于听音乐的

View Code

2. __module__ 和 __class__

__module__ 表示当前操作的对象在哪个模块

__class__ 表示当前操作的对象的类是什么

# E:
e_1.py   建立了个py文件

class C:
    def __init__(self):
        self.name = ‘jay‘

View Code

# E:xx.py

from re_1 import C # 引入自定义模块

obj = C()
print(obj.__module__)
print(obj.__class__)


#输出结果:
re_1   
<class ‘re_1.C‘>

View Code

3. __init__

对象中数据的初始化,通过类创建对象时,自动触发执行

class Foo:

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


obj = Foo(‘jay‘) # 自动执行类中的 __init__ 方法

View Code

4. __del__

析构方法,当对象在内存中被释放时,自动触发执行

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

class Foo:

    def __del__(self):
        pass

View Code

5. __call__

对象后面加上括号,触发执行

注:初始化对象的执行是由创建对象触发的,即:对象 = 类名();而对于__call__方法的执行是由对象后加括号触发的,即:对象()或类()()

class Foo:

    def __init__(self):
        print(5)
        pass

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


obj = Foo()  # 执行 __init__
obj()  # 执行 __call__
"""
输出结果:

5
__call__

"""

View Code

6. __dict__

类或对象中的所有成员

类的普通字段属于对象;类中的静态字段和方法等属于类,即:

class Province:

    country = ‘China‘

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

    def func(self, *args, **kwargs):
        print(‘func‘)

# 获取类的成员，即：静态字段、方法、
print(Province.__dict__)
# 输出：{‘country‘: ‘China‘, ‘__module__‘: ‘__main__‘, ‘func‘: <function func at 0x10be30f50>, ‘__init__‘: <function __init__ at 0x10be30ed8>, ‘__doc__‘: None}

obj1 = Province(‘HeBei‘,10000)
print(obj1.__dict__)
# 获取 对象obj1 的成员
# 输出：{‘count‘: 10000, ‘name‘: ‘HeBei‘}

obj2 = Province(‘HeNan‘, 3888)
print(obj2.__dict__)
# 获取 对象obj1 的成员
# 输出：{‘count‘: 3888, ‘name‘: ‘HeNan‘}

View Code

7. __str__

如果一个类中定义了__str__方法,那么在打印对象时,默认输出该方法的返回值

class Foo:

    def __str__(self):
        return ‘666‘
        pass
obj = Foo()
print(obj)

# 输出: ‘‘666‘‘

View Code

8. __getitem__,__setitem__,__delitem__

用于索引操作,如字典,以上分别为获取,设置,删除数据

class Foo(object):
    def __getitem__(self, item):
        print(‘__getitem__‘,item)

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

obj = Foo()
result = obj[‘k1‘]   # 自动触发执行 __getitem__
obj[‘k2‘] = ‘jay‘    # 自动触发执行 __setitem__
del obj[‘k1‘]        # 自动触发执行 __delitem__


"""
输出:

__getitem__ k1
__setitem__ k2 jay
__delitem__ k1



"""

View Code

9. __add__

对象 + 对象

class Foo(object):
    def __init__(self,a,a1):
        self.a = a
        self.a1 = a1
    def __add__(self, other):
        return self.a + other.a1
obj1 = Foo(88,99)
obj2 = Foo(12,10)
ret = obj1 + obj2  # 自动执行 __add__
print(ret)
# 结果: 98

View Code

10. with 对象

自动执行__enter__/__exit__

__enter __ 相当于入口,__exit__相当于出口

class Foo(object):
    def __enter__(self):
        print(‘1111‘)
        return 999
        
    def __exit__(self, exc_type, exc_val, exc_tb):
        print(‘22222‘)
obj = Foo()
with obj as f:
    print(f)

# 输出结果:
 1111
 999
 22222

View Code

11. __new__

构造方法,__init__之前python内部会自动执行__new__,在内部创建一个当前类的对象

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

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

obj1 = Foo(1,2)
print(obj1)

obj2 = Foo(11,12)
print(obj2)

View Code