一、类成员
1、字段（属性）
- 静态字段（类属性）
- 普通字段（实例属性）
静态字段可以被类直接调用，也可以被实例调用，在创建类的时候创建；
普通字段只能被实例调用，在对象实例化的的时候创建。
class Foo: city = 'Beijing' # 静态字段 def __init__(self): name = 'lilei' # 普通字段 age = 28 # 普通字段
>>>print(Foo.city) # 静态字段可以被类直接调用Beijing >>>f = Foo()>>>print(f.city) # 静态字段可以被实例调用Beijing>>>print(f.name) # 普通字段只能被实例调用lilei
2、方法
- 类中的函数称为方法
1、普通方法
class Foo: def __init__(self): self.name = 'lilei' self.age = 18 def print_name(self): ''' 普通方法 print_name 每个普通方法的第一个参数是 self, 代表实例化后的对象 ''' print(self.name)
>>> f = Foo() # 实例化对象>>> print(f.print_name) # 普通方法只有实例化后才能调用，执行普通方法lilei
2、静态方法
class Foo: county = 'China' def __init__(self, city): self.city = city @staticmethod # 静态方法装饰器 def bar(arg): # 静态方法没有固定的第一一个参数 ''' 静态方法不能调用静态字段和普通字段 静态方法一般直接被类调用 ''' print(arg)
>>>Foo.bar('test')test
3.类方法
class Foo: country = 'China' city = 'beijing' def __init__(self): self.name = 'lilei' self.age = 28 @classmethod # 类方法装饰器 def print_city(cls)： # 类方法的第一个参数是cls,代表类背身 ''' 类方法可以调用静态字段 ''' print(cls.city)
>>>Foo.print_city()'Beijing'
三、property
- 将类中的方法变为一个属性，该属性的调用方法和字段一样
class Pager: """ 计算分页的功能 """ def __init__(self, all_count): self.all_count = all_count @property def all_pager(self): """ 计算需要分几页,比如以每页10条为例子 :return: """ a1, a2 = divmod(self.all_count, 10) if a2 == 0: return a1 else: return a1 + 1 p = Pager(101)ret = p.all_pagerprint(ret)
class Pager:"""计算分页的功能"""def __init__(self, all_count): self.all_count = all_count@property # 将一个方法变为属性def all_pager(self): """ 计算需要分几页,比如以每页10条为例子 :return: """ a1, a2 = divmod(self.all_count, 10) if a2 == 0: return a1 else: return a1 + 1@all_pager.setter # 让all_pager属性具有赋值的方法，提供一个关联方式，具体的创建变量的代码还是需要自己去写的def all_pager(self, value): print(value) @all_pager.deleter # 让all_pager属性具有删除的方法, 将del和这个方法进行关联，具体的删除方法还是需要自己去写的def all_pager(self): print(“del all_pager”)p = Pager(101)ret = p.all_pagerprint(ret) p.all_pager = "100" # 给属性设置参数，会调用被装饰器@all_pager.setter装饰的方法del p.all_pager # 删除 会调用被装饰器all_pager.deleter 装饰的方法
- 以函数的方式调用property
class Pager: def __init__(self, all_count): self.all_count = all_count def f1(self): return 123 def f2(self, value): pass def f3(self): pass foo = property(fget=f1, fset=f2, fdel=f3) # 将foo实例化成一个属性，对foo进行调用的时候执行方法f1,对foo方法进行赋值的时候执行方法f2,对foo进行删除的时候调用方法f3p = Pager(100)result = p.fooprint(result)p.foo = "aaa"del p.foo
四、成员修饰符
- 私有修饰符，不能在任何外部访问的区域访问，包括子类中。
- 私有字段
只能在内部调用，不能在外部包括子类中调用
class Foo: def __init__(self, name): self.__name = name # 定义一个私有的普通字段 def f1(self): print(self.__name)class Bar(Foo): def f2(self): print(self.__name) # 调用不到私有普通字段obj = Foo("lilei")print(obj.__name) # 报错，私有字段只能够在本类中的方法进行调用obj.f1() # 这个就是正常的 - 私有静态字段 # 需要将一个方法变成静态方法，在静态方法中调用静态字段，然后在类外面通过调用类的静态方法，就可以访问类中的静态字段了.
class Foo: __cc = "123" # 定义一个私有的静态字段 def __init__(self, name): self.__name = name @staticmethod def f1(): print(Foo.__cc)# print(Foo.__cc) # 这样调用会报错Foo.f1() # 这样就可以了
- 私有方法
- 私有普通方法
class Foo: def __init__(self, name): self.name = name # 定义一个私有的普通字段 def __print(self): print(self.name) def f1(self): self.__print()obj = Foo("aaa")obj.f1() # 通过调用类中的公有方法来执行私有方法
- 私有静态方法
class Foo: def __init__(self, name): self.name = name # 定义一个私有的普通字段 @staticmethod def __f2(num): print(num) @staticmethod def f3(num): Foo.__f2(num)Foo.f3(10)
- 私有字段的访问方法
- 使用对象访问私有的字段或方法可以通过obj._类名私有方法 调用类中私有的字段和方法（算是后门吧）
class Foo: """ 这是一个测试类 """ def __init__(self, name): self.name = name self.__age = 10 def __print(self): print(self.name)obj = Foo("xx")print(obj._Foo__age)obj._Foo__print()
五、 特殊成员
- __init__ 构造方法 这个就不说了
- __del__ 析构方法，实例释放内存前要执行的动作
class C: def __init__(self, name,age): self.__name = name self.age = age def __del__(self): print('__del__ exec.') >>> c = C('lilei', 28)__del__ exec. # 在释放内存时，执行了析构方法
- __call__ 方法
对象在被调用时调用该方法
class C: def __init__(self, name, age): self.name = name self.age = age def __call__(self): print('__call__ function exec.') >>>c = C('tom', 18)>>>c() # 对象调用时，调用了__call__ 方法call function exec.
- __str__方法
print 对象时或者str(对象)时，调用该方法并将返回值赋值给对象。
class C: def __init__(self, name, age): self.name = name self.age = age def __str__(self): return self.name
# 调用方式1 print>>> c = c = C('lilei', 18)>>>print(c)lilei # 调用方式2 str函数>>> c = C('lilei', 18)>>> str(c)lilei
- __dict__ 输出对象的字段
class C: def __init__(self, name, age): self.name = name self.age = age def __str__(self): return self.name
>>>c = C('lilei', 18)>>>print(c.__dict__){ 'age': 18, 'name': 'lilei'}
- __getitem__ 方法
- 通过访问字典的方式访问, 调用该方法
- 通过切片的方法访问，调用该方法
# 通过访问字典的方式，访问对象class C: def __init__(self, name, age): self.name = name self.age = age def __getitem__(self, item): print('getitem')>>>c = C('lilei', 18)>>>c['xxx']getitem # 通过切片的方式访问对象class C: def __init__(self, name, age): self.name = name self.age = age def __getitem__(self, item): print('getitem') print(item.start) print(item.stop) print(item.step)>>>c = C('lilei', 18)>>>c[1:5:2]getitem152
- __setitem__ 方法
- 通过字典的方式赋值，调用该方法
- 通过切片的方式赋值，调用该方法
# 通过字典方式赋值class C: def __init__(self, name, age): self.name = name self.age = age def __setitem__(self, key, value): print('set {} = {}'.format(key, value))>>>c = C('lilei', 18)>>>c['xxx'] = 123set xxx = 123 # 通过切片的方式访问class C: def __init__(self, name, age): self.name = name self.age = age def __setitem__(self, key, value): print('set {} = {}'.format(key, value)) print(key.start) print(key.stop) print(key.step)>>>c = C('lilei', 18)>>>c[1:5:2] = 123set slice(1, 5, 2) = 123152
- __delitem__方法
- 通过del字典键的方式调用
- 通过del切片的方式调用
# 通过del字典的方式调用class C: def __init__(self, name, age): self.name = name self.age = age def __delitem__(self, key): print('del {}'.format(key))>>>c = C('lilei', 18)>>>del c[‘xxx’]del xxx # 通过del切片的方式访问class C: def __init__(self, name, age): self.name = name self.age = age def __delitem__(self, key): print('del {}'.format(key))>>>c = C('lilei', 18)>>>del c['1:5:2']del slice(1, 5, 2)
- __iter__ 对对象迭代时，调用该方法
class C: def __init__(self, name, age): self.name = name self.age = age def __iter__(self): yield 1 yield 2>>>c = C('tom', 28)>>>for i in c: print(i)12