python 面向对象 进阶篇
在上篇《python面向对象》中，简单介绍了python中面向对象的基本知识
在这篇博客中，详细介绍python类的成员，成员修饰符，类的特殊成员。
类的成员
类的成员分为三种：字段，方法和属性
所有成员中，只有普通字段的内容保存对象中，即：根据此类创建了多少对象，在内存中就有多少个普通字段。而其他的成员，则都是保存在类中，即：无论对象的多少，在内存中只创建一份。
字段
字段包括普通字段和静态字段。静态字段，保存在类中。普通字段，保存在对象中。
class FOO：
country = “中国” #静态字段
def __init__(self):
self.name.= 'alex' #普通字段
>>>
obj = FOO()
print(obj.name)
FOO.cointry
方法
class Proviced: @staticmethod def f1(): print('这是一个静态方法') def __init__(self,name): self.name = name def f2(self): print(self.name) print('这是一个普通方法') Proviced.f1() obj = Proviced('zhang') obj.f2()
class Proviced: @staticmethod def f1(): print('这是一个静态方法') def __init__(self,name): self.name = name def f2(self): print(self.name) print('这是一个普通方法') @classmethod def f3(cls): obj2 = cls('wang') #cls即当前的类名，cls() 即为创建对象 obj2.f2() print(cls) Proviced.f1() obj = Proviced('zhang') obj.f2() Proviced.f3() >>> 这是一个静态方法 zhang 这是一个普通方法 wang 这是一个普通方法 <class '__main__.Proviced'>
属性
具有方法的表现形式，也有字段的访问形式。也就是说我们访问的时候可以采用不伦不类的方式。。。。
class pager: def __init__(self,page): self.all_count = page @property def all_page(self): a1,a2 = divmod(self.all_count,10) if a2 == 0: return a1 else: return a1+1 p = pager(101) ret = p.all_page print(ret)
属性可以看做一个特殊的方法，通过字段修饰的方法。。。
class Pager: def f1(self): return 'get' def f2(self,value): print(value) return 'set' def f3(self): print('del') return 'del' foo = property(fget=f1,fset=f2,fdel=f3) p = Pager() result = p.foo print(result) p.foo = 'zhang' del p.foo
注意：属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象
属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能。
实例：对于主机列表页面，每次请求不可能把数据库中的所有内容都显示到页面上，而是通过分页的功能局部显示，所以在向数据库中请求数据时就要显示的指定获取从第m条到第n条的所有数据（即：limit m,n），这个分页的功能包括：
- 根据用户请求的当前页和总数据条数计算出 m 和 n
- 根据m 和 n 去数据库中请求数据
class Pager: def __init__(self, current_page): # 用户当前请求的页码（第一页、第二页...） self.current_page = current_page # 每页默认显示10条数据 self.per_items = 10 @property def start(self): val = (self.current_page - 1) * self.per_items return val @property def end(self): val = self.current_page * self.per_items return val # ############### 调用 ############### p = Pager(1) p.start 就是起始值，即：m p.end 就是结束值，即：n
在继承了object的新式类中，属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法，分别是获取，修改和删除。当然这些操作都是基于对象的，不是直接在类上做修改。
class Goods(object): def __init__(self): # 原价 self.original_price = 100 # 折扣 self.discount = 0.8 @property def price(self): # 实际价格 = 原价 * 折扣 new_price = self.original_price * self.discount return new_price @price.setter def price(self, value): self.original_price = value @price.deltter def price(self, value): del self.original_price obj = Goods() obj.price # 获取商品价格 obj.price = 200 # 修改商品原价 del obj.price # 删除商品原价
我们也可以使用静态字段的方式创建属性：
class Foo： def get_bar(self): return 'wupeiqi' # *必须两个参数 def set_bar(self, value): return return 'set value' + value def del_bar(self): return 'wupeiqi' BAR ＝ property(get_bar, set_bar, del_bar, 'description...') obj = Foo() obj.BAR # 自动调用第一个参数中定义的方法：get_bar obj.BAR = "alex" # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入 del Foo.BAR # 自动调用第三个参数中定义的方法：del_bar方法 obj.BAE.__doc__ # 自动获取第四个参数中设置的值：description...
类成员修饰符
类具有三个成员，而每个成员都可以具有两种身份：公有成员和私有成员。公有成员在任何地方都可以访问，而私有成员只能在类的内部才能访问。
公有字段和私有字段
当在字段前面加两个“__”下划线的时候，字段变成私有字段，只能在类本身内部执行，而且不能继承。
class Foo: __cc = 123 def __init__(self,name,value): self.__name = name #将字段变为私有字段 self.value = value def f1(self): print(self.__name) print(self.value) def f2(self): print(Foo.__cc) class Ge(Foo): def f3(self): print(self.__name) obj = Foo('zhang','20') obj.f1() print(obj.value) # obj.f2() #print(Foo.__cc) #外部调用私有的静态字段会报错 #print(obj.__name) #外部调用私有的普通字段时会出现报错 obj1 = Ge('wang','30') obj1.f3()
zhang 20 20 Traceback (most recent call last): File "C:/Users/Administrator/PycharmProjects/s13/day8/成员修饰符.py", line 16, in <module> print(obj.__name) AttributeError: 'Foo' object has no attribute '__name'
实际上，Python也可以在外部访问私有对象，方法是_类名__私有对象名。但强烈不建议这么做。
特殊成员
除了上面介绍的外，类还有一些特殊成员，提供特殊的功能。
1.__doc__
表示类的描述信息
2. __module__ 和 __class__
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
3.__init__
构造方法，通过类创建对象时，自动触发执行。
4. __del__
析构方法，当对象在内存中被释放时，自动触发执行。
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
5. __call__
对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
6、__getitem__、__setitem__、__delitem__
用于索引操作，如字典。以上分别表示获取、设置、删除数据
class Foo: def __getitem__(self, item): print('getitem') print(item) def __setitem__(self, key, value): print('set item') print(key,value) def __delitem__(self, key): print('del item') print(key) obj = Foo('zhang',20) obj['zhang'] = 10 #__setitem__ ret = obj['zhang'] #__getitem__ del obj['zhang'] #__delitem__
set item zhang 10 getitem zhang del item zhang
def __getitem__(self, item): print('getitem') #print(item) print(item.start) #输出切片的起始位置 print(item.stop) #输出切片的结束位置 print(item.step) #输出切片步长 def __setitem__(self, key, value): print('set item') print(key,value) print(key.start) #输出赋值的起始位置 print(key.stop) #输出赋值的结束位置 print(key.step) #输出赋值的步长 def __delitem__(self, key): print('del item') #print(key) print(key.start) #删除的起始位置 print(key.stop) #删除的结束位置 print(key.step) #删除的步长 ret = obj[1:3] obj[1:3:2] = [2,5,5] del obj[2:5]
同样的，可以使用__getslice__、__setslice__、__delslice__进行分片操作
class Foo(object): def __getslice__(self, i, j): print '__getslice__',i,j def __setslice__(self, i, j, sequence): print '__setslice__',i,j def __delslice__(self, i, j): print '__delslice__',i,j obj = Foo() obj[-1:1] # 自动触发执行 __getslice__ obj[0:1] = [11,22,33,44] # 自动触发执行 __setslice__ del obj[0:2] # 自动触发执行 __delslice__
7. __iter__
用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__
面向对象其他
class C1: def f1(self): print('c1.f1') class C2(C1): def f1(self): #print('c2.f1') #主动执行父类的f1方法。 super(C2,self).f1() print('c2.f1') obj = C2() obj.f1()
