类的组合
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__) # 输出结果: 描述一个类的信息,这是一个用于听音乐的
2. __module__ 和 __class__
__module__ 表示当前操作的对象在哪个模块
__class__ 表示当前操作的对象的类是什么
# E: e_1.py 建立了个py文件 class C: def __init__(self): self.name = 'jay'
# E:xx.py from re_1 import C # 引入自定义模块 obj = C() print(obj.__module__) print(obj.__class__) #输出结果: re_1 <class 're_1.C'>
3. __init__
对象中数据的初始化,通过类创建对象时,自动触发执行
class Foo: def __init__(self, name): self.name = name self.age = 18 obj = Foo('jay') # 自动执行类中的 __init__ 方法
4. __del__
析构方法,当对象在内存中被释放时,自动触发执行
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
class Foo: def __del__(self): pass
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__ """
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'}
7. __str__
如果一个类中定义了__str__方法,那么在打印对象时,默认输出该方法的返回值
class Foo: def __str__(self): return '666' pass obj = Foo() print(obj) # 输出: ''666''
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 """
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
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
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)
12. __iter__
类中定义__iter__方法返回一个迭代器
class Foo(object): def __init__(self,name,age): self.name = name self.age = age def func(self): pass # obj1是Foo类的一个对象，不可迭代对象 obj1 = Foo('jay',666) for item in obj1: print(item) # 报错,是不可迭代的 # 加了__iter__方法 class Foo(object): def __init__(self,name,age): self.name = name self.age = age def func(self): pass def __iter__(self): return iter([self.age,self.name]) obj1 = Foo('jay',666) for item in obj1: print(item) #返回指定的返回值 #输出结果: 666 jay