python——面向对象进阶(类的成员、成员修饰符、类的特殊成员)、反射、异常处理、断言
类的成员
一、字段
字段包括:普通字段和静态字段,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同,
- 普通字段属于对象
- 静态字段属于类
1 class Province(object): 2 3 # 静态字段 4 country = '中国' 5 6 def __init__(self, name): 7 8 # 普通字段 9 self.name = name 10 11 12 # 直接访问普通字段 13 obj = Province('河北省') 14 print(obj.name) 15 16 # 直接访问静态字段 17 Province.country
由上述代码可以看出【普通字段需要通过对象来访问】【静态字段通过类访问】,在使用上可以看出普通字段和静态字段的归属是不同的。
- 静态字段在内存中只保存一份
- 普通字段在每个对象中都要保存一份
应用场景: 通过类创建对象时,如果每个对象都具有相同的字段,那么就使用静态字段,不同的字段需要用户来传参的,就使用普通字段。
二、方法
方法包括:普通方法、静态方法和类方法,三种方法在内存中都归属于类,区别在于调用方式不同。
- 普通方法:由对象调用;至少一个self参数;执行普通方法时,自动将调用该方法的对象赋值给self;
- 类方法:由类调用; 至少一个cls参数;执行类方法时,自动将调用该方法的类复制给cls;
- 静态方法:由类调用;无默认参数;
1 class Foo: 2 3 def __init__(self,name): 4 self.name = name 5 6 def ord_func(self): 7 """ 定义普通方法,至少有一个self参数 """ 8 9 # print self.name 10 print ('普通方法') 11 12 @classmethod 13 def class_func(cls): 14 """ 定义类方法,至少有一个cls参数 """ 15 16 print ('类方法') 17 18 @staticmethod 19 def static_func(): 20 """ 定义属性方法 ,无默认参数""" 21 22 print ('静态方法') 31 32 # 调用普通方法 33 f = Foo('alex') 34 f.ord_func() 35 36 # 调用类方法(只能访问类变量,不能访问实例变量<self.name这种的>,可以使用类中的参数) 37 Foo.class_func() 38 39 # 调用静态方法(可以直接通过类名.所要调用的函数来调用 实际上已经与类没啥关系) 40 Foo.static_func()
相同点:对于所有的方法而言,均属于类(非对象)中,所以,在内存中也只保存一份。
不同点:方法调用者不同、调用方法时自动传入的参数不同。
三、属性
属性就是在普通方法上面加个个装饰器@property,仅有一个self参数,调用时不需要()
调用、修改、删除
1 class Goods(object): 2 3 def __init__(self): 4 # 原价 5 self.original_price = 100 6 # 折扣 7 self.discount = 0.8 8 9 @property 10 def price(self): 11 # 实际价格 = 原价 * 折扣 12 new_price = self.original_price * self.discount 13 return new_price 14 15 @price.setter 16 def price(self, value): 17 self.original_price = value 18 19 @price.deleter 20 def price(self): 21 del self.original_price 22 23 obj = Goods() 24 print(obj.price) # 获取商品价格 25 obj.price = 200 # 修改商品原价 26 print(obj.price) 27 del obj.price # 删除商品原价 28 print(obj.price)
29 print(obj.discount)
类成员的修饰符
对于每一个类的成员有两种形式:
- 公有成员,在任何地方都能访问
- 私有成员,只有在类的内部才能方法
私有成员命名时,前两个字符是下划线。(特殊成员除外,例如:__init__、__call__、__dict__等)
私有成员和公有成员的访问限制不同:
静态字段
- 公有静态字段:类可以访问;类内部可以访问;派生类中可以访问
- 私有静态字段:仅类内部可以访问;
公有字段:
class C(object): 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(object): __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() # 派生类中可以访问 ==> 错误
普通字段
- 公有普通字段:对象可以访问;类内部可以访问;派生类中可以访问
- 私有普通字段:仅类内部可以访问;
ps:如果想要强制访问私有字段,可以通过 【对象._类名__私有字段明 】访问(如:obj._C__foo),不建议强制访问私有成员。
公有字段:
class C(object): 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(object): 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() # 派生类中访问 ==> 错误
方法、属性的访问于上述方式相似,即:私有成员只能在类内部使用
ps:非要访问私有属性的话,可以通过 对象._类__属性名
类的特殊成员
1. __doc__ 表示类的描述信息
2. __module__ 和 __class__
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
3. __init__
构造方法,通过类创建对象时,自动触发执行。
4. __del__
析构方法,当对象在内存中被释放时,自动触发执行。
注:此方法一般无须定义,因为Python是一门高级语言,程序员在使用时无需关心内存的分配和释放,因为此工作都是交给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
5. __call__
对象后面加括号,触发执行。
注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()
6. __dict__
类或对象中的所有成员
上文中我们知道:类的普通字段属于对象;类中的静态字段和方法等属于类,即:
7. __str__
如果一个类中定义了__str__方法,那么在打印 对象 时,默认输出该方法的返回值。
8、__getitem__、__setitem__、__delitem__
用于索引操作,如字典。以上分别表示获取、设置、删除数据
9、__getslice__、__setslice__、__delslice__
该三个方法用于分片操作,如:列表
10. __iter__
用于迭代器,之所以列表、字典、元组可以进行for循环,是因为类型内部定义了 __iter__
for循环的迭代实际上是:
1 obj = iter([11,22,33,44])
2 for i in obj:
3 print(i)
4
5
6 obj = iter([11,22,33,44])
7 while True:
8 val = obj.next()
9 print(val)
反射
通过字符串映射或修改程序运行时的状态、属性、方法, 有以下4个方法
- hasattr(obj,name_str):判断一个对象obj里是否有对应的name_str字符串的方法
- getattr(obj,name_str):根据字符串去获取obj对象里的对应的方法的内存地址
- setattr(obj,y,z):obj.y=z
- delattr(obj,name_str):删除obj中的name_str
1 class Foo(object): 2 def __init__(self): 3 self.name = 'wupeiqi' 4 5 def func(self): 6 return 'func' 7 8 obj = Foo() 9 10 # #### 检查是否含有成员 #### 11 print(hasattr(obj, 'name')) 12 print(hasattr(obj, 'func')) 13 14 # #### 获取成员 #### 15 print(getattr(obj, 'name')) 16 print(getattr(obj, 'func')) # 执行函数getattr(obj,'func')() 17 18 19 # #### 设置成员 #### 20 setattr(obj, 'age', 18) 21 setattr(obj, 'show', lambda num: num + 1) 22 23 print(hasattr(obj, 'age')) 24 print(hasattr(obj, 'show')) 25 26 #### 删除成员 #### 27 delattr(obj, 'name') 28 print(hasattr(obj, 'name'))
异常处理:
try: # 主代码块 pass except KeyError,e: # 异常时,执行该块 pass else: # 主代码块执行完,执行该块 pass finally: # 无论异常与否,最终执行该块 pass
主动触发异常:
try: raise Exception('错误了。。。') except Exception,e: print e
断言:
# assert 条件 assert 1 == 1 assert 1 == 2
小Tips:
断言用于处理不应该在程序中出现的情况,出现的时候认为程序出错了,需要根据debug宏来在调试器开启,发布时去掉.
异常处理程序中可能出现的错误情况,出现了需要做处理,程序继续往下走,没有调试/发布版的区分.