标签：
类的成员可以分为三大类：字段、方法和属性
一、字段
字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同，
class foo:
# 字段（静态字段，保存在类里）
cc = ‘111‘
def __init__(self):
# 字段（普通的字段，保存在对象里）
self.name = ‘mxz‘
def f1(self):
print(self.name)
class Province:
# 静态字段
country = ‘中国‘
def __init__(self,name):
# 普通字段
self.name = name
# 直接访问普通字段
# 一般情况下自己访问自己字段
# 规则：
# 普通字段只能用对象访问
# 静态字段只能用类去访问（万不得已可以使用对象访问）
hb = Province(‘河北‘)
bj = Province(‘北京‘)
print(Province.country,hb.name)
print(Province.country,bj.name)
# 直接访问静态字段
print(Province.country)
# 静态字段在代码加载时已经创建
二、方法
方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。
class Province:
# 静态字段
country = ‘中国‘
def __init__(self,name):
# 普通字段
self.name = name
# 普通方法 由对象去调用执行（属于类）
def show(self):
print(self.name)
# 静态方法（属于类,由类调用执行，无默认参数）
@staticmethod
def f1(a,b):
print(a,b)
# 类方法（用到类的时候使用）
@classmethod
def f2(cls): # class
# cls 类名
# cls() 创建对象
print(cls)
hb = Province(‘河北‘)
hb.show()
Province.f1(11,22)
Province.f2()
相同点：对于所有的方法而言，均属于类（非对象）中，所以，在内存中也只保存一份。
不同点：方法调用者不同、调用方法时自动传入的参数不同。
三、属性
Python中的属性其实是普通方法的变种。
属性的基本使用
class Foo:
def func(self):
pass
# 定义属性
@property
def prop(self):
pass
# ############### 调用 ###############
foo_obj = Foo()
foo_obj.func()
foo_obj.prop #调用属性
由属性的定义和调用要注意一下几点：
方法：foo_obj.func()
属性：foo_obj.prop
class Pager:
def __init__(self, all_count):
# 用户当前请求的页码（第一页、第二页...）
self.all_count = all_count
@property
def all_pager(self):
a1,a2 = divmod(self.all_count,10)
if a2 == 0:
return a1
else:
return a1 + 1
@all_pager.setter
def all_pager(self,value):
print(value)
@all_pager.deleter
def all_pager(self):
print(‘del‘)
p = Pager(101)
print(p.all_pager)
p.all_count = 102
del p.all_pager
类的成员有两种形式：
class Foo:
def __init__(self,name):
self.name = name
def f1(self):
print(self.name)
# 公共的 在内部外部都能访问
obj = Foo(‘mxz‘)
print(obj.name)
obj.f1()
class Foo:
__cc = ‘111‘
def __init__(self,name):
self.__name = name
def f1(self):
print(self.__name)
obj = Foo(‘mxz‘)
# 私有 只能在内部调用
obj.f1()
__init__
构造方法，通过类创建对象时，自动触发执行。
class Foo:
def __init__(self, name):
self.name = name
self.age = 18
obj = Foo(‘哈哈‘) # 自动执行类中的 __init__ 方法
__del__
析构方法，当对象在内存中被释放时，自动触发执行。
class Foo:
def __del__(self):
pass
__module__ 和 __class__
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
class C:
def __init__(self):
self.name = ‘haha‘
print(C.__module__) # 输出模块
print(C.__class__) # 输出类
__call__
对象后面加括号，触发执行。
class Foo:
def __init__(self):
pass
def __call__(self):
print(‘call‘)
obj = Foo() # 执行 __init__
obj() # 执行 __call__
__str__
如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
class Foo:
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return ‘%s - %d‘ % (self.name, self.age)
a = Foo(‘m‘,1)
b = Foo(‘n‘,2)
print(a)
print(b)
__dict__
类或对象中的所有成员
class Foo:
def __init__(self,name,age):
self.name = name
self.age = age
# 获取对象中封装的数据
a = Foo(‘m‘,1)
print(a.__dict__)
__getitem__、__setitem__、__delitem__
用于索引操作，如字典。以上分别表示获取、设置、删除数据
class foo:
def __init__(self,name,age):
self.name = name
self.age = age
def __getitem__(self, item):
print(type(item))
return 1
def __setitem__(self, key, value):
print(type(key),type(value))
def __delitem__(self, key):
print(type(key))
obj = foo(‘mxz‘,1)
ret = obj[1:4:2]
print(ret)
obj[1:4] = [1,2,3,4,5]
del obj[1:4]
__iter__
用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__
class foo:
def __iter__(self):
yield 1
yield 2
obj = foo()
for item in obj:
print(item)
isinstance(obj, cls)
检查是否obj是否是类 cls 的对象
class Foo(object):
pass
obj = Foo()
print(isinstance(obj, Foo))
issubclass(sub, super)
检查sub类是否是 super 类的派生类
class Foo(object):
pass
class Bar(Foo):
pass
print(issubclass(Bar, Foo))
标签：
原文地址：http://www.cnblogs.com/mxzheng/p/5634163.html
