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宏来在调试器开启,发布时去掉.

异常处理程序中可能出现的错误情况,出现了需要做处理,程序继续往下走,没有调试/发布版的区分.

 

posted @ 2017-10-18 21:20  想54256  阅读(323)  评论(0编辑  收藏  举报