一、类的成员

类的成员可以分为三大类:字段、方法和属性

注:所有成员中,只有普通字段的内容保存对象中,即:根据此类创建了多少对象,在内存中就有多少个普通字段。而其他的成员,则都是保存在类中,即:无论对象的多少,在内存中只创建一份。

1. 字段

字段包括:普通字段和静态字段,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同,

  • 普通字段属于对象
  • 静态字段属于
class Province:

    # 静态字段
country = '中国' def __init__(self, name): # 普通字段
self.name = name # 直接访问普通字段
obj = Province('河北省')
print obj.name # 直接访问静态字段
Province.country

字段的定义和使用

由上述代码可以看出【普通字段需要通过对象来访问】【静态字段通过类访问】,在使用上可以看出普通字段和静态字段的归属是不同的。其在内容的存储方式类似如下图:

由上图可是:

  • 静态字段在内存中只保存一份
  • 普通字段在每个对象中都要保存一份

应用场景: 通过类创建对象时,如果每个对象都具有相同的字段,那么就使用静态字段

2. 方法

方法包括:普通方法、静态方法和类方法,三种方法在内存中都归属于类,区别在于调用方式不同。

  • 普通方法:由对象调用;至少一个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()

方法的定义和使用

相同点:对于所有的方法而言,均属于类(非对象)中,所以,在内存中也只保存一份。

不同点:方法调用者不同、调用方法时自动传入的参数不同。

3.属性

如果你已经了解Python类中的方法,那么属性就非常简单了,因为Python中的属性其实是普通方法的变种。

对于属性,有以下两个知识点:

  • 属性的基本使用
  • 属性的两种定义方式

1、属性的基本使用

# ############### 定义 ###############
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

注意:属性存在意义是:访问属性时可以制造出和访问字段完全相同的假象

属性由方法变种而来,如果Python中没有属性,方法完全可以代替其功能。

装饰器方式 创建属性的get set delete

# ############### 定义 ###############
class Goods(object): @property
def price(self):
print '@property' @price.setter #定义设置属性方法(方法名称需要与property装饰器配置方法相同)
def price(self, value):
print '@price.setter' @price.deleter #定义删除属性方法(方法名称需要与property装饰器配置方法相同)
def price(self):
print '@price.deleter' # ############### 调用 ###############
obj = Goods() obj.price # 自动执行 @property 修饰的 price 方法,并获取方法的返回值 obj.price = 123 # 自动执行 @price.setter 修饰的 price 方法,并将 123 赋值给方法的参数 del obj.price # 自动执行 @price.deleter 修饰的 price 方法

property 对象 创建属性的get set delete

property的构造方法中有个四个参数

  • 第一个参数是方法名,调用 对象.属性 时自动触发执行方法
  • 第二个参数是方法名,调用 对象.属性 = XXX 时自动触发执行方法
  • 第三个参数是方法名,调用 del 对象.属性 时自动触发执行方法
  • 第四个参数是字符串,调用 对象.属性.__doc__ ,此参数是该属性的描述信息
class Goods(object):

    def __init__(self):
# 原价
self.original_price = 100
# 折扣
self.discount = 0.8 def get_price(self):
# 实际价格 = 原价 * 折扣
new_price = self.original_price * self.discount
return new_price def set_price(self, value):
self.original_price = value def del_price(self, value):
del self.original_price PRICE = property(get_price, set_price, del_price, '价格属性描述...') obj = Goods()
obj.PRICE # 获取商品价格
obj.PRICE = 200 # 修改商品原价
del obj.PRICE # 删除商品原价

实例

类成员的修饰符

  • 公有成员,在任何地方都能访问
  • 私有成员,只有在类的内部才能方法

私有成员和公有成员的定义不同:私有成员命名时,前两个字符是下划线。(特殊成员除外,例如:__init__、__call__、__dict__等)

class C:

    def __init__(self):
self.name = '公有字段'
self.__foo = "私有字段"

静态字段

  • 公有静态字段:类可以访问;类内部可以访问;派生类中可以访问
  • 私有静态字段:仅类内部可以访问;

普通字段

  • 公有普通字段:对象可以访问;类内部可以访问;派生类中可以访问
  • 私有普通字段:仅类内部可以访问;

ps:非要访问私有属性的话,可以通过 对象._类__属性名

类的特殊成员

1. __doc__

  表示类的描述信息

2. __module__ 和  __class__ 

  __module__ 表示当前操作的对象在那个模块

  __class__     表示当前操作的对象的类是什么

3. __init__

  构造方法,通过类创建对象时,自动触发执行。

4. __del__

  析构方法,当对象在内存中被释放时,自动触发执行。

5. __call__

  对象后面加括号,触发执行。

注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()

class Foo:

    def __init__(self):
pass def __call__(self, *args, **kwargs): print '__call__' obj = Foo() # 执行 __init__
obj() # 执行 __call__

  

 6. __str__

  如果一个类中定义了__str__方法,那么在打印 对象 时,默认输出该方法的返回值。

class Foo:

    def __str__(self):
return 'tubie' obj = Foo()
print obj
# 输出:tubie

  

7. __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'}

8、__getitem__、__setitem__、__delitem__

用于索引操作,如字典。以上分别表示获取、设置、删除数据

#!/usr/bin/env python
# -*- coding:utf-8 -*- 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'] # 自动触发执行 __getitem__
obj['k2'] = 'wupeiqi' # 自动触发执行 __setitem__
del obj['k1'] # 自动触发执行 __delitem__

  

该三个方法用于分片操作,如:列表

#!/usr/bin/env python
# -*- coding:utf-8 -*- class Foo(object): def __getitem__(self, key):
print '__getslice__',key
print(key.start) #切片起始值
print(key.stop) #切片终止值
print(key.step) #切片步长 def __setitem__(self, key, value):
print '__setslice__',key,value def __delitem__(self, key):
print '__delslice__',key obj = Foo() obj[-1:1] # 自动触发执行 __getitem__
obj[0:1] = [11,22,33,44] # 自动触发执行 __setitem__
del obj[0:2] # 自动触发执行 __delitem__

  

9. __iter__ 

用于迭代器,之所以列表、字典、元组可以进行for循环,是因为类型内部定义了 __iter__

#!/usr/bin/env python
# -*- coding:utf-8 -*- class Foo(object): def __init__(self, sq):
self.sq = sq def __iter__(self): #首先必须包含__iter__方法
return iter(self.sq) #其次返回值已定要是可迭代的值iter()迭代器 obj = Foo([11,22,33,44]) for i in obj:
print i

  

python 学习 [day8]class成员的更多相关文章

  1. python 学习 [day6]

    递归阶乘: 函数自己调用自己循环操作的模式称之为递归 def func(num): if num == 1: return 1 return num * func(num - 1) print(fun ...

  2. python 学习 [day7]面向对象

    编程模式概念 面向过程:根据业务逻辑从上到下写垒代码 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可 面向对象:对函数进行分类和封装,让开发“更快更好更强...” 面向对象的三大 ...

  3. Python学习记录day8

    目录 Python学习记录day8 1. 静态方法 2. 类方法 3. 属性方法 4. 类的特殊成员方法 4.1 __doc__表示类的描述信息 4.2 __module__ 和 __class__ ...

  4. Python学习路程day8

    Socket语法及相关 socket概念 A network socket is an endpoint of a connection across a computer network. Toda ...

  5. python异常处理[转]

    #!/usr/bin/python import tracebacktry: 1/0#except Exception,e:# print traceback.format_exc()  except ...

  6. python学习 day016打卡 面向对象--成员

    本节主要内容: 1.类的成员 2.类的成员-变量 3.类的成员-方法 4.类的成员-属性 5.私有 一.类的成员: 能在类中写的内容就是类的成员. class 类名: #方法 def __init__ ...

  7. python学习day20 面向对象(二)类成员&成员修饰符

    1.成员 类成员 类变量 绑定方法 类方法 静态方法 属性 实例成员(对象) 实例变量 1.1实例变量 类实例化后的对象内部的变量 1.2类变量 类中的变量,写在类的下一级和方法同一级. 访问方法: ...

  8. 【坚持】Selenium+Python学习记录 DAY8

    2018/05/ 28 [来源:菜鸟教程](http://www.runoob.com/python3/python3-examples.html) 继续敲类相关的代码 #No.1 class peo ...

  9. Python学习 :面向对象 -- 类的成员

    类的成员 一.字段 - 字段可以分为'普通字段'和'静态字段'两种 - 普通字段(保存在对象中,执行时只能通过对象来进行访问) - 静态字段(保存在类中,在内存中只保存一份数据(可以有效地节约内存的空 ...

随机推荐

  1. Android分渠道打包(Python 3.4 实现)

    Android批量打包实现有很多方式你可以用Ant,Maven或者Gradle.在处理多个Library和NDK编译的时候配置有些麻烦,且每个渠道都编译一次效率较低.如果没有复杂的分渠道编译需求,我们 ...

  2. Google photos -- reverse thinking

    As a hacker, do the hacking. Here I mean the [hacker](http://en.wikipedia.org/wiki/Hacker_(term) ) . ...

  3. 导入excle数据

    导入excle数据 1.if (File.Exists(strFileName)) // 当文件存在时             {                 m_fileName = strFi ...

  4. windows下练习linux shell

    <---开始学习linux---记录一下---路漫漫其修远兮---加油吧---萌萌达> 使用软件:Cygwin  下载地址(免安装版):链接: http://pan.baidu.com/s ...

  5. python基础4

    内容概要: 一.递归 递归就是函数本身调用自己,直到满足指定条件之后一层层退出函数 递归特性: 必须有一个明确的结束条件 每次进入更深一层递归时,问题规模相比上次递归都应有所减少 递归效率不高,递归层 ...

  6. shell编程其实真的很简单(二)

    上篇我们学会了如何使用及定义变量.按照尿性,一般接下来就该学基本数据类型的运算了. 没错,本篇就仍是这么俗套的来讲讲这无聊但又必学的基本数据类型的运算了. 基本数据类型运算 操作符 符号 语义 描述 ...

  7. AsyncTask兼容性

    简介 AsyncTask是Android系统提供的异步方式,其优点在于在子线程执行任务,并将结果传递给主线程. 实现方式 AsyncTask封装了Executor和Handler. 基本使用 通过As ...

  8. OpenCV入门教程

    OpenCV入门教程 作者:于仕琪 OpenCV入门教程.pdf

  9. hdu 1564 Play a game(博弈找规律)

    题目:一个n*n的棋盘,每一次从角落出发,每次移动到相邻的,而且没有经过的格子上. 谁不能操作了谁输. 思路:看起来就跟奇偶性有关 走两步就知道了 #include <iostream> ...

  10. xml动态修改 dom4j修改

    xml的动态修改需要传入的参数 xml的位置(tomcat中的发布位置).修改后的xml需要保存的位置(因为动态修改,所以建议和xml未修改前的位置相同).添加的节点的信息.或者修改的节点的信息 SA ...