Python面向对象类成员特性

特性的存在就是将方法伪装成字段。


property

把类方法当做普通字段去调用，即用对象调用的时候后面不用加括号

  1. #!/usr/bin/env python
  2. # _*_coding:utf-8 _*_
  4. class Foo:
  6.    @property
  7.    def Characteristic(self):
  8.        print("类方法的特性")
  10. # 创建一个对象
  11. obj = Foo()
  12. # 调用类方法的时候方法后面不用加括号
  13. obj.Characteristic

输出

  1. /usr/bin/python3.5 /home/yangwen/文档/Python_code/sublime/Week06/Day04/s2.py
  2. 类方法的特性
  4. Process finished with exit code 0

setter

设置类方法的值

  1. #!/usr/bin/env python
  2. # _*_coding:utf-8 _*_
  4. class Foo:
  6.    # 获取Characteristic值
  7.    @property
  8.    def Characteristic(self):
  9.        return "获取Characteristic值"
  11.    # 意思是下面的Characteristic函数用来给上面的Characteristic函数设置值
  12.    @Characteristic.setter
  13.    def Characteristic(self, value):
  14.        return "设置Characteristic的值"
  16. # 创建一个对象
  17. obj = Foo()
  19. # 获取Characteristic的值
  20. print(obj.Characteristic)
  22. # 设置Characteristic的值
  23. obj.Characteristic = 123

输出

  1. /usr/bin/python3.5 /home/yangwen/文档/Python_code/sublime/Week06/Day04/s2.py
  2. 获取Characteristic值
  4. Process finished with exit code 0

deleter

  1. class Foo:
  3.    # 特殊字段
  4.    @property
  5.    def pp(self):
  6.        # 调用特殊字段的时候输出aaa
  7.        print("property")
  9.    @pp.setter
  10.    def pp(self, value):
  11.        # 调用设置方法的时候输出value的值
  12.        print(value)
  14.    @pp.deleter
  15.    def pp(self):
  16.        # 调用删除方法的时候输出del
  17.        print("deleter")
  19. # 创建一个对象obj
  20. obj = Foo()
  22. # 自动执行@property
  23. obj.pp
  25. # 自动执行@pp.setter
  26. obj.pp = 999
  28. # 自动执行@pp.deleter
  29. del obj.pp

输出

  1. [email protected]:~$ python3 /home/yangwen/文档/Python_code/sublime/Week07/s1.py
  2. property
  3. 999
  4. delete

另一种调用特殊属性的方法

  1. class Foo:
  3.    def f1(self):
  4.        print("f1")
  6.    def f2(self, value):
  7.        print("f2")
  9.    def f3(self):
  10.        print("f3")
  12.    SpecialFields = property(fget=f1, fset=f2, fdel=f3, doc="我是注释")
  14. # 创建一个对象
  15. obj = Foo()
  17. # 调用类的f1方法
  18. obj.SpecialFields
  20. # 调用类的f2方法
  21. obj.SpecialFields = 123
  23. # 调用类的发方法
  24. del obj.SpecialFields
  26. # 调用类的doc，这里只能通过类去访问，对象无法访问
  27. print(Foo.SpecialFields.__doc__)

输出结果

  1. [email protected]:~$ python3 /home/yangwen/文档/Python_code/sublime/Week07/s1.py
  2. f1
  3. f2
  4. f3
  5. 我是注释
时间： 2024-08-25 06:50:08

Python面向对象类成员特性的相关文章

Python面向对象-类成员

类的成员可以分为三大类:字段.方法和属性: 注:所有成员中,只有普通字段的内容保存对象中,即:根据此类创建了多少对象,在内存中就有多少个普通字段.而其他的成员,则都是保存在类中,即:无论对象的多少,在内存中只创建一份. (一)字段 字段包括:普通字段和静态字段,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同 1 class Province: 2 # 静态字段 3 country = "China" 4 5 def __init__(self, name): 6 #

Python面向对象编程高级特性

***这里还是根据网上资料,主要是廖雪峰老师的教程学习的笔记,主要介绍python面向对象的高级特性,笔记不全,只是记录自己觉得容易出错的地方*** 1.python作为一种动态语言,他的动态绑定机制允许在运行过程中动态的给class或者对象实例添加方法和属性,这个在静态语言中比如java是很难做到的: 1)动态绑定属性: 2)动态绑定方法 给一个实例绑定的方法对于其他实例和类都是不可见的:(这里也说明给一个实例动态绑定方法必须用MethodType(func, instance)) 但是给类绑

面向对象类成员

面向对象类成员:字段,方法,属性 一.字段: 举个例子: class Foo: def __init__(self, name): self.name = name 其中的self.name就是字段,不过这是一个普通的字段,保存在对象中,可以通过对象去访问例如: 1 obj = Foo("DJC") 2 print(self.name) 3 4 >>>DJC 除了普通字段还有静态字段来看以下代码: class Foo: s = 123 def __init__(sel

python面向对象之类成员

一.概述 上篇<python面向对象OOP>介绍了python面向对象的基础初级入门部分,提到了类的定义,使用,类的三大特性;经典类,新式类在查找时的区别等,有了前面的基础,本文接着描述面向对象中类成员;先整体描述下,类中的成员分以下几部分: #类成员  #字段(属性):      普通字段  属于对象,保存在对象中,只能通过对象访问      静态字段  属于类,保存(一份)在类中(所有对象共享的字段属性),执行时可以是类访问也可以是对象访问  #方法:      普通方法  保存在类中,又

python——面向对象的三大特性

继承 什么是继承 继承是一种创建新类的方式,在python中,新建的类可以继承一个或多个父类,父类又可称为基类或超类,新建的类称为派生类或子类 python中类的继承分为:单继承和多继承 class ParentClass1: #定义父类 pass class ParentClass2: #定义父类 pass class SubClass1(ParentClass1): #单继承,基类是ParentClass1,派生类是SubClass pass class SubClass2(ParentCl

Python 面向对象的三大特性：封装，继承，多态

# 面向对象的三大特性:封装,继承,多态 # 继承的影响:资源的继承,资源的使用,资源的覆盖,资源的累加 # 资源的继承,在Python中的继承是指能使用父类的资源,而不是说在子类也复制一份父类代码到子类中 class Animate: a = 1 # 公有的资源 _b = 2 # 受保护的资源 __c = 3 # 私有的资源 def t1(self): print("t1") def _t2(self): print("t2") def __t3(self): p

C++ 面向对象 类成员函数this指针

每个类成员函数都只涉及一个对象, 即调用它的对象. 但有时候方法可能涉及到两个对象, 在这种情况下需要使用C++ 的 this 指针 假设将方法命名为topval(), 则函数调用stock1.topval()将访问stock1的对象数据:stock2.topval()将访问stock2的对象数据: 如果希望该方法的两个对象进行对比, 则必须将第二个对象作为参数传递给它.这时候涉及到隐式和显式: top = stock1.topval(stock2); 隐式的访问了stock1, 显示的访问了s

Python的类成员变量默认初始值的坑

问题发现:一个循环内,缺省值初始化同名变量,其中的list成员不是空,会延续之前同名变量的值. 示例代码: # Define class class Variant(): # use def __init__(self, price = 500, description = 'default description', values = ['', '', '']): self.price = price self.description = description self.values = v

python面向对象的成员、属性等

#类成员: #字段 self.xy =qq . xy=qq #普通字段 (保存在对象里面) #直接通过点(.)+ 字段 进行调用 #静态字段 (保存在类里面) #静态字段属于类,在内存只保留一份 . 把公共的字段 放到类中 ,节省内存等好处 #代码从上到下解释到类就创建了 #可以通过 类.静态字段 进行访问 #方法 def xx() # (保存在类里面) #通过点(.) + 方法名 + 括号 进行调研 #通过 类 点(.) 方法名也可以调用 . 还是要在前面先实例化一个对象 #静态字段class