周五，晴，记录生活分享点滴
参考博客：https://www.cnblogs.com/wupeiqi/p/4766801.html
Pyhton版本：3.5
面向对象（进阶）
类的成员
字段
普通字段
保存在对象中，执行只能通过对象访问
class Province: country = '中国' # 静态字段，属于类 def __init__(self, name): self.name = name # 普通字段，属于对象 henan = Province('河南') # 访问河南，需要通过对象访问字段 henan.name henan.name = "河南南" # 把内部的对象修改了
静态字段
保存在类中， 执行可以通过对象访问，也可以通过类访问
class Province: country = '中国' # 静态字段，属于类 def __init__(self, name): self.name = name # 普通字段，属于对象 hebei = Province('河北') hebei.name # 静态对象可以通过对象访问， print(hebei.country) # 静态对象也可以通过类访问
存储方式
小结：
- 静态字段在内存中只保存一份
- 普通字段在每个对象中都要保存一份
应用场景：
- 通过类创建对象时，如果每个对象都具有相同的字段，那么就使用静态字段
方法
种类
普通方法，保存在类中，由对象来调用；至少一个self参数：将对象赋值给参数self
类方法，保存在类中，由类直接调用；至少一个cls参数：将当前类赋值给cls
静态方法，保存在类中，由类直接调用；无默认参数
class Foo: def __init__(self, name): self.name = name def ord_func(self): """ 定义普通方法，至少有一个self参数 """ # print self.name print '普通方法' @classmethod def class_func(cls): """ 定义类方法，至少有一个cls参数 """ print '类方法' @staticmethod def static_func(): """ 定义静态方法 ，无默认参数""" print '静态方法' # 调用普通方法 f = Foo() f.ord_func() # 调用类方法 Foo.class_func() # 调用静态方法 Foo.static_func()
相同点：对于所有的方法而言，均属于类（非对象）中，所以，在内存中也只保存一份。
不同点：方法调用者不同、调用方法时自动传入的参数不同。
应用场景
如果对象中需要保存一些值，执行某功能时，需要使用对象中的值 ---> 普通方法
不需要任何对象中的值 ---> 静态方法
属性
属性是普通方法的变种
属性的基本使用
# ############### 定义 ############### class Foo: def func(self): pass # 定义属性 @property def prop(self): pass # ############### 调用 ############### foo_obj = Foo() foo_obj.func() foo_obj.prop #调用属性
小结：
定义时，在普通方法的基础上添加 @property 装饰器；
定义时，属性仅有一个self参数
调用时，无需括号
方法：foo_obj.func()
属性：foo_obj.prop
实例
对于主机列表页面，每次请求不可能把数据库中的所有内容都显示到页面上，而是通过分页的功能局部显示，所以在向数据库中请求数据时就要显示的指定获取从第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
类成员的修饰符
公有成员，在任何地方能访问
私有成员，在类的内部能访问
私有成员和公有成员的定义不同
私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：__init__、__call__、__dict__等）
class C: def __init__(self): self.name = '公有字段' self.__foo = "私有字段"
私有成员和公有成员的访问限制不同
静态字段
公有静态字段：类可以访问；类内部可以访问；派生类中可以访问
class C: name = "公有静态字段" def func(self): print C.name class D(C): def show(self): print C.name C.name # 类访问 obj = C() obj.func() # 类内部可以访问 obj_son = D() obj_son.show() # 派生类中可以访问
私有静态字段：仅类内部可以访问
class C: __name = "私有静态字段" def func(self): print C.__name class D(C): def show(self): print C.__name C.__name # 类访问 ==> 错误 obj = C() obj.func() # 类内部可以访问 ==> 正确 obj_son = D() obj_son.show() # 派生类中可以访问 ==> 错误
普通字段
公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问
class C: def __init__(self): self.foo = "公有字段" def func(self): print self.foo # 类内部访问 class D(C): def show(self): print self.foo ＃ 派生类中访问 obj = C() obj.foo # 通过对象访问 obj.func() # 类内部访问 obj_son = D(); obj_son.show() # 派生类中访问
私有普通字段：仅类内部可以访问
class C: def __init__(self): self.__foo = "私有字段" def func(self): print self.foo # 类内部访问 class D(C): def show(self): print self.foo ＃ 派生类中访问 obj = C() obj.__foo # 通过对象访问 ==> 错误 obj.func() # 类内部访问 ==> 正确 obj_son = D(); obj_son.show() # 派生类中访问 ==> 错误
不推荐：强制访问私有字段，可以通过 【对象._类名__私有字段名 】访问（如：obj._C__foo）
类的特殊成员
__init__
条件：类() 自动执行
class Foo: def __init__(self, name): self.name = name self.age = 23 obj = Foo('chung') # 自动执行类中的 __init__ 方法
__call__
条件：对象() or 类()() 自动执行
class Foo: def __init__(self): pass def __call__(self, *args, **kwargs): print '__call__' obj = Foo() # 执行 __init__ obj() # 执行 __call__
__int__
条件：int(对象) 获取返回值并赋值给这个对象
class Foo: def __init__(self): pass def __int__(self): return 1111 obj = Foo() r = int(obj) # int,对象，自动执行对象的 __int__方法，并将返回值赋值给int对象 print(r) # 输出：1111
__str__
条件：str() 执行str时调用的
class Foo: def __str__(self): return 'chung' obj = Foo() print obj # 输出：chung
__add__、__del__
class Foo: def __init__(self, name, age): self.name = name self.age = age def __add__(self, other):# self = obj1(alex,19); other = obj2(eric,66) # return self.age + other.age # (1)自定义返回obj1的19和obj2的66 # return Foo('tt',99) # (2)自定义返回'tt',99的对象 return Foo(obj1.name, other.age) # (3)自定义返回obj1的名字和obj2的年龄 def __del__(self): print('析构方法') # 当建立对象被销毁时，自动执行 obj1 = Foo('alex', 19) obj2 = Foo('eirc', 66) r = obj1 + obj2 # 两个对象相加时，自动执行第一个对象的__add__方法，并且将第二个对象当作参数传递进入 print(r, type(r))
__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'}
__getitem__、__setitem__、__delitem__
用于索引操作，如字典。分别表示获取、设置、删除数据
class Foo(object): def __getitem__(self, key): print '__getitem__',key def __setitem__(self, key, value): print '__setitem__',key,value def __delitem__(self, key): print '__delitem__',key obj = Foo() result = obj['k1'] # 自动触发执行obj对象的类中的 __getitem__方法，k1当作参数传给key obj['k2'] = 'chung' # 自动触发执行 __setitem__ del obj['k1'] # 自动触发执行 __delitem__
class Foo: def __init__(self, name,age): self.name = name self.age = age def __getitem__(self, item): # return item+10 # 如果item是基本类型：int，str，索引获取 # slice对象的话，切片 if type(item) == slice: print('调用者希望内部做切片处理') else: print(item.start) print(item.stop) print(item.step) print('调用者希望内部做索引处理') def __setitem__(self, key, value): print(key,value) def __delitem__(self, key): print(key) li = Foo('chung', 18) li[123] # 索引处理 # 如果是单独的值，传递的参数是int或string类型 li[1:4:2] # 切片处理 # 如果是[1:]格式，传递的参数是slice类型 li[1:3] = [11,22] # 调用的是__setitem__ del li[1:3] # 调用的是__delitem__
__iter__
用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__
class Foo: def __init__(self, name,age): self.name = name self.age = age def __iter__(self): return iter([11,22,33]) # 1、执行li对象的类中的 __iter__方法，并获取其返回值 li = Foo('alex', 18) for i in li: # 2、循环上一步中返回的对象（对象iter的返回值） print(i) # 关于迭代器的几点： # 如果类中有 __iter__ 方法，创建的对象叫可迭代对象 # 可迭代对象.__iter__() 方法的返回值是迭代器 # for 循环，遇到迭代器，执行next # for 循环，遇到可迭代对象，可迭代对象.__iter__()方法，获取迭代器，执行next
__metaclass__、__new__
1. Python中一切事物都是对象
2. class Foo:
pass
obj = Foo()
# obj是对象，Foo类
# Foo类也是一个对象，type的对象
3. 类都是type类的对象 type(..)
“对象”都是类的对象 类()
# 注释解析版 class MyType(type): def __init__(self, what, bases = None, dice = None): # self=Foo super(MyType, self).__init__(what, bases, dict) def __call__(self, *args, **kwargs): # self=Foo类 obj = self.__new__(self, *args, **kwargs) # 第二阶段第二步：执行Foo的__new__方法 # obj因为下面的__new__返回，所以obj是Foo的对象 self.__init__(obj) # 第二阶段第三步：self是Foo，把obj传过来 class Foo(object, metaclass = MyType): # 第一阶段：执行MyType的__init__方法 def __init__(self, name): self.name = name def __new__(cls, *args, **kwargs): return object.__new__(cls, *args, **kwargs) # 真正创建对象的是这一句 # cls指创建了Foo的对象 obj = Foo() # 第二阶段第一步：执行MyType的__call__方法