码迷,mamicode.com
首页 > 其他好文 > 详细

面向对象相关知识及常用操作(二)

时间:2016-11-09 22:03:04      阅读:209      评论:0      收藏:0      [点我收藏+]

标签:property   参数   size   括号   sel   pre   成员   count   方法   

本篇将详细介绍Python 类的成员、成员修饰符、类的特殊成员

类的成员分为字段、方法和属性

字段:分为普通字段和静态字段,普通字段在每个对象的内存中均保存一份,静态字段仅在类的内存中保存一份

方法:分为普通方法、类方法和静态方法,

  • 普通方法:由对象调用;至少一个self参数;执行普通方法时,自动将调用该方法的对象赋值给self
  • 类方法:由调用; 至少一个cls参数;执行类方法时,自动将调用该方法的复制给cls
  • 静态方法:由调用;无默认参数;

字段和方法常见使用见下面例子:

 1 #类的成员分为字段、方法和属性
 2 #字段,分为普通字段和静态字段,普通字段属于对象,静态字段属于类
 3 #方法:分为普通方法、静态方法和类方法
 4 #普通方法:由对象调用,至少有一个self参数,执行普通方法时,自动将该方法调用的对象赋值给self
 5 #类方法:由类调用,至少又一个cls参数,执行类方法时,自动将调用该方法的类复制给cls
 6 #静态方法:由类调用,无默认参数
 7 class FOO:
 8     func="我是静态字段"
 9     def __init__(self,name):
10         self.name=name   #普通字段
11 
12     def ord_fun(self):
13         print("普通方法,至少有一个self字段",self.name)
14     @classmethod
15     def class_fun(cls):
16         print("类方法,至少有一个cls参数")
17     @staticmethod
18     def static_fun():
19         print("静态方法,无参数")
20 
21     @property
22     def prop(self):
23         print("属性调用")
24 
25 #普通字段的调用:
26 f=FOO("Eric")
27 print(f.name)
28 #静态字段的调用
29 print(FOO.func)
30 
31 #普通方法的调用
32 f.ord_fun()
33 #类方法的调用
34 FOO.class_fun()
35 #静态方法的调用
36 FOO.static_fun()
37 #属性调用,与普通方法的调用一致,定义时仅有一个self参数,调用时无需括号
38 #访问属性时可以制造出和访问字段完全一致的假象
39 #属性由方法变种而来,若没有属性,方法完全可以替代
40 f.prop

属性

1、属性的基本使用

  • 定义时,在普通方法的基础上添加 @property 装饰器;
  • 定义时,属性仅有一个self参数
  • 调用时,无需括号
  •            方法:foo_obj.func()
  •            属性:foo_obj.prop
  • python属性的功能:属性内部进行一系列的逻辑运算,最终将计算结果返回
 1 class Pager(object):
 2     def __init__(self,current_page):
 3         #用户当前请求的页码
 4         self.current_page=current_page
 5         #每页默认显示的条数
 6         self.per_items=10
 7 
 8     @property
 9     def start(self):
10         val=(self.current_page-1)*self.per_items+1
11         return val
12     @property
13     def end(self):
14         val=self.current_page*self.per_items
15         return val
16 #
17 p=Pager(2)
18 print("第二页开始:",p.start)
19 print("第二页结束:",p.end)

2、属性的两种定义方法:

  1、装饰器,即在方法上使用装饰器

  2、静态字段,即在类中定义值为property的字段

装饰器:经典类:如上述例子所示,定义属性的方法  @property

    新式类:新式类的属性比经典类的属性丰富

 1 #新式类,具有三种@property装饰器
 2 class Goods(object):
 3     def __init__(self,name):
 4         self.name=name
 5         #原价
 6         self.original_price=100
 7         #折扣价
 8         self.discount=0.8
 9 
10     @property
11     def price(self):
12         #实际价格
13         new_price=self.original_price*self.discount
14         return new_price
15 
16     @price.setter
17     def price(self,value):
18         #修改商品原价
19         self.original_price=value
20 
21     @price.deleter
22     def price(self):
23         #删除商品原价
24         del self.original_price
25 
26 obj=Goods("apple")
27 print(obj.price)
28 obj.price=200
29 print(obj.price)
30 del obj.price

静态字段方式:使用静态字段创建属性时,经典类和新式类无区别

静态字段方式创建属性具有三种访问方式,我们可以根据他们几个属性的访问特点,分别将三个方法定义为对同一个属性:获取、修改、删除

 1 class Goods(object):
 2 
 3     def __init__(self):
 4         # 原价
 5         self.original_price = 100
 6         # 折扣
 7         self.discount = 0.8
 8 
 9     def get_price(self):
10         # 实际价格 = 原价 * 折扣
11         new_price = self.original_price * self.discount
12         return new_price
13 
14     def set_price(self, value):
15         self.original_price = value
16 
17     def del_price(self, value):
18         del self.original_price
19 
20     PRICE = property(get_price, set_price, del_price, 价格属性描述...)
21 
22 obj = Goods()
23 obj.PRICE         # 获取商品价格
24 obj.PRICE = 200   # 修改商品原价
25 del obj.PRICE     # 删除商品原价

二、类成员的修饰符

类成员分为:公有成员:在任何地方都能方位

私有成员:只有在类的内部才能访问,私有成员命名时前两个字符是下划线 __name,特殊成员除外(__init__)

 1 #公有成员:在任何地方都能访问。静态:类的对象可以访问,类内部可以访问,派生类可以访问
 2 #私有成员:只有在类的内部才能访问,仅在类内部可以访问
 3 class C(object):
 4     name="公有静态字段"
 5     __na="私有静态字段"
 6     def __init__(self):
 7         self.foo="公有普通字段"
 8         self.__fox="私有普通字段"
 9 
10     def func(self):     #类内部访问
11         print(self.foo)
12         print(self.__fox)
13         print(C.name)
14         print(C.__na)
15 class D(C):     #只能访问公有静态字段和公有普通字段
16     def show(self):
17         print(C.name)
18         # print(C.__na)   无法正常访问
19         print(self.foo)
20         # print(self.__fox)    无法正常访问私有字段
21 print("类访问:",C.name)    #类访问
22 # print("类访问私有字段:",C.__na)   #报错,无法访问
23 obj2=C()
24 obj2.func()   #全部可以正常访问,打印四个
25 
26 
27 obj_d=D()
28 obj_d.show()

类的特殊成员在实际使用中知道即可,故不一一列举

 

面向对象相关知识及常用操作(二)

标签:property   参数   size   括号   sel   pre   成员   count   方法   

原文地址:http://www.cnblogs.com/eric8899/p/6048400.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!