面向对象进阶：类成员、类成员的修饰符、类的特殊成员
类成员
类成员分为三大类：字段、方法、属性
一、字段
- 静态字段 （属于类）
- 普通字段（属于对象）
class City:
# 静态字段
country = "中国" def __init__(self,city_name):
# 普通字段
self.city_name = city_name def show(self):
print(self.city_name) obj1 = City("Harbin")
obj2 = City("Shanghai")
# 普通字段对象来访问
print(obj1.city_name,obj2.city_name)
# 静态字段通过类名访问
print(City.country)
字段
内存中分布：
- 静态字段在内存中只保存一份
- 普通字段在每个对象中都要保存一份
静态字段定义及应用：随着这个程序的执行产生，随着程序的结束而消失，这样和程序‘共存亡’的字段，我们就叫它静态字段。它就像是一个全局变量，不属于任何一个对象，我们可以直接使用类来调用，也可以在对象使用方法的时候使用它。它是对象共享的变量，存在类的内存里。
特殊：对象也可以访问静态字段。静态字段在代码加载时已经创建。
遵循规则：普通字段只能对象访问；静态字段用类访问。（万不得已用对象访问）
二、方法
- 静态方法：由类调用；无默认参数；
- 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
- 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
class Province:
country = "China"
def __init__(self,name):
self.name = name
# 普通方法 由对象调用。
def show(self):
print(self.name)
# 静态方法 ，无self参数；方法前边加上关键字@staticmethod 由类调用
@staticmethod
def display(a,b,c):
print(a,b,c)
# 类方法（相当于静态方法特殊形式），至少要有一个cls参数。由类调用
@classmethod
def listen(cls,b):
'''
cls:类名
'''
print(cls.country,b)
obj = Province("黑龙江")
obj.show() # 普通方法由对象调用
Province.display(1,2,3) # 静态方法由类调用执行
Province.listen(2) # cls是python自动传递
方法
三、属性
- 属性的基本使用
class Page:
def __init__(self,all_counts):
self.all_counts = all_counts
# 属性： 分页
@property
def divpages(self):
a,b = divmod(self.all_counts,10)
if b == 0:
return a
else:
return a+1
p = Page(101)
ret = p.divpages# 调用属性 直接返回
print(ret)
属性的定义和调用：
- 定义时，在普通方法的基础上添加 @property 装饰器；
- 定义时，属性仅有一个self参数
- 调用时，无需括号
属性：p.divpages
Python的属性的功能是：属性内部进行一系列的逻辑计算，最终将计算结果返回
注意：属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象
属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能。
class Page:
def __init__(self,all_counts):
self.all_counts = all_counts
# 属性： 分页
@property
def divpages(self):
a,b = divmod(self.all_counts,10)
if b == 0:
return a
else:
return a+1
# 设置属性：支持赋值操作
@divpages.setter
def divpages(self,value):
self.all_counts = value
# 删除
@divpages.deleter
def divpages(self):
print("del property")
p = Page(101)
p.divpages = 111 #自动执行 @divpages .setter 修饰的 divpages 方法，并将 123 赋值给方法的参数
ret = p.divpages # 自动执行 @property 修饰的 divpages方法，并获取方法的返回值
del p.divpages # 自动执行 @divpages.deleter 修饰的 divpages方法
print(ret)
属性操作：不同属性调用形式，触发不同装饰器的方法，见下图。
- 属性另一种表达方式
class Page:
def __init__(self,count):
self.count = count
def f1(self):
return 123
def f2(self):
print("fset:赋值")
def f3(self):
print("fdel:删除")
foo = property(fget=f1,fset=f2,fdel=f3)
p = Page(100)
ret = p.foo # 自动回找到fool，会找到fget对应函数f1并执行，并将返回值
p.foo =113 #会找到fset对应函数f2并执行
del p.foo # 会找到fdel并执行f3
类成员修饰符
- 公有：在类内和类外均可以访问
- 私有：仅在类的内部可以访问；私有成员命名时，前两个字符是下划线
- 公有字段和私有字段
class Person:
# 私有 静态字段
__school = "北大"
def __init__(self,name,sex):
# 普通字段，公有，name ；私有 sex
self.name = name
self.__sex = sex # 均可在类内调用
def f1(self):
print(self.name)
print(self__sex) def f2(self):
print(Person.__school) class ChianPerson(Person):
def f2(self):
print(self.__sex) obj = Person("lcy","man")
print(obj.name) # 类外访问公有普通字段
# print(obj.__sex) # 无法访问 报错 no attribute
#print(Person.__school) # 无法访问
obj.f3() # 打印 "北大"
# ----- 继承,派生类不能访问基类私有的普通字段-------
obj2 = ChinaPerson("alex","female")
#obj2.f2() # 执行 失败，只有Person类内方法可以访问
obj2.f1() # 可以执行f1是Person类中的方法
2. 公有方法和私有方法
（略）
这里公有方法和私有方法与上边字段访问限制是一样的。私有方法命名同私有字段命名相同。只要在函数名前加两个下划线，就表示私有方法。
类的特殊成员
- __init__:构造方法
- __del__:析构方法
- __doc__:注释类
- __module__:对象所在模块
- __class__:对象类名
- __call__: obj() 或类名()触发执行
- __str__:print(obj)自动调用
- 其他：__add__
class Person:
'''
这是一个人类
'''
def __init__(self,name):
self.name = name def __del__(self):
print("这是析构函数一般不自定义，python有自己的回收机制") def __call__(self, *args, **kwargs):
print("call") def __str__(self):
return ("__str__:%s"%self.name) def __add__(self, other):
print(self.name,other.name) # 创建对象，自动调用__init__
obj_p1 = Person("lcy")#
obj_p2 = Person("alex")
print(obj_p1.__doc__)
print(obj_p1.__module__)
print(obj_p1.__class__)
# 自动调用 __call__
obj_p1()
#Person("lcy")() 同 obj_p1()
# 触发__str__方法
print(obj_p1)
res = str(obj_p1)
print(res)
# 会触发 __add__ /同理会有其他的方法，加减乘除。。。
obj_p1+obj_p2
# 程序会自动调用__del__析构函数，对象在回收机制之前，这里会调用两次，因为创建了两次
- __dict__:重点 （默认已经存在类或者对象中）
获取类成员：静态字段，方法。
class Game:
Game_name = "SIM3"
def __init__(self):
pass
def show(self):
pass
print(Game.__dict__)
'''
{'__init__': <function Game.__init__ at 0x00503E88>,
'show': <function Game.show at 0x00503DF8>,
'__weakref__': <attribute '__weakref__' of 'Game' objects>,
'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Game' objects>,
'Game_name': 'SIM3', '__doc__': None}
'''
对象：获取对象的字段
class Game:
Game_name = "SIM3"
def __init__(self,level,money):
self.level = level
self.money = money
def show(self):
pass
obj = Game(12,199)
print(obj.__dict__)
'''
{'money': 199, 'level': 12}
'''
- __getitem__、__setitem__、__delitem__
对象用于索引，如字典相关操作。获取、设置以及删除操作
class Foo:
def __getitem__(self, item):
print(item)
def __setitem__(self, key, value):
print(key,value)
def __delitem__(self, key):
print(key)
obj = Foo()
obj["k1"] # 触发 __getitem__
obj[3] #触发 __getitem__
obj[2] = 234 # 触发__setitme
del obj[3] # 触发__delitem
支持对象切片操作。（python3 用触发上边的方法来实现）
class Foo:
def __getitem__(self, item):
print(type(item))
print(item.start)
print(item.stop)
print(item.step)
def __setitem__(self, key, value):
print(type(key))
print(key.start,key.stop,key.step,value)
def __delitem__(self, key):
print(type(key))
print(key.start,key.stop,key.step)
obj = Foo()
obj[1:3:2] # 触发 __getitem__
obj[1:3:2] = [11,22,44] #触发 __setitem__
del obj[1:3:2] # 触发__delitem__
输出：
<class 'slice'>
1
3
2
<class 'slice'>
1 3 2 [11, 22, 44]
<class 'slice'>
1 3 2
（待续，天冷，打字都动手啊）