一、属性（特性）
普通方法去执行的时候，后面需要加括号，特性方法执行的时候和静态字段一样不需要不需要加括号.
特性方法不和字段同名.
特性方法不能传参数.
在我们定义数据库字段类的时候,往往需要对其中的类属性做一些限制,一般用get和set方法来写,那在python中,我们该怎么做能够少写代码,又能优雅的实现想要的限制,减少错误的发生呢,这时候就需要我们的@property.
class Foo: def __init__(self,name): self.name = name # 普通方法 def start(self): temp = ‘%s sb‘ %self.name return temp # 特性，将方法的执行方式变为和字段一样 @property def end(self): temp = ‘%s gd‘%self.name return temp obj = Foo(‘alexsel‘) ret1 = obj.start() ret2 = obj.end print(ret2) print(obj.name) 输出结果： alexsel gd alexsel
设置特性方法的时候，所需要加的装饰器名字规则是，你所设置特性方法名字点setter（例如：@end.setter）
class Foo: def __init__(self,name): self.name = name # 普通方法 def start(self): temp = ‘%s sb‘ %self.name return temp # 特性，将方法的执行方式变为和字段一样 @property def end(self): temp = ‘%s gd‘%self.name return temp # 如果需要使用设置特性的的方法，就需要这个点前面名字和所要设置特性的方法同名，就像这里的end @end.setter def end(self,value): print(value) self.name = value obj = Foo(‘alexsel‘) #获取特性,获取特性的时候，拿到的是@Property的返回值 ret2 = obj.end print(ret2) #设置特性，设置特性的时候，会执行@end.setter下面的方法，这个‘aaa‘就传递给value obj.end = ‘aaa‘ ret1 = obj.end print(ret1) 输出结果： alexsel gd aaa aaa gd
这个特性在python中不是特别常用，因为我们一般可以使用普通的方法代替特性方法。
二、成员修饰符
首先介绍‘__’，这个在命名之前添加就会变成私有的，只有在类的内部才能访问。
class Foo: book = ‘alexsel‘ #命名的时候前面添加__，只有在类的内部才能访问，在外部无法访问 __book = ‘book‘ def __init__(self): self.__name = ‘alexsel‘ def start(self): print(Foo.__book) print(self.__name) def __end(self): print(‘__end‘) obj = Foo() print(obj.book) # print(obj.__book) #这种无法拿到字段 #在外部也无法调用类私有方法 #obj.__end() #通过内部方法调用拿到字段 obj.start() 输出结果： alexsel book alexsel
私有的属性只有自己可以访问，当某个类继承这个类之后，也无法访问父类的私有属性。
class Foo: book = ‘alexsel‘ __book = ‘book‘ def __init__(self): self.__name = ‘alexsel‘ def start(self): print(Foo.__book) print(self.__name) self.__end() def __end(self): print(‘__end‘) class Bar(Foo): def start(self): print(self.__name)#子类继承父类，也无法调用父类的私有属性 obj = Bar() obj.start() 输出结果： 报错
静态方法也是如此
class Foo: book = ‘alexsel‘ __book = ‘book‘ def __init__(self): self.__name = ‘alexsel‘ def start(self): Foo.__add() #内部调用私有静态方法 def __end(self): print(‘__end‘) @staticmethod def __add(): print(‘add‘) obj = Foo() obj.start() 输出结果： add
python成员修饰符有两种，一种是共有的，一种是私有的，共有的都可以访问，私有的只有自己可以访问，或者在外部间接访问。
但是还有一种强行访问私有属性的方法，如下：
class Foo: book = ‘alexsel‘ __book = ‘book‘ def __init__(self): self.__name = ‘alexsel‘ def start(self): Foo.__add() #内部调用私有静态方法 def __end(self): print(‘__end‘) @staticmethod def __add(): print(‘add‘) obj = Foo() print(obj._Foo__book) 输出结果： book
虽然可以使用，但是不推荐这种使用方法。
三、类的特殊成员
__call__()的作用是使实例能够像函数一样被调用，同时不影响实例本身的生命周期（__call__()不影响一个实例的构造和析构）。
__call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()。
class Foo: def __init__(self): print( Foo: def ‘init‘) def __call__(self, *args, **kwargs): print(‘call‘) return 1 r = Foo() r() r = Foo()()#加第一个括号执行__init__，执行完__init__,获取到一个对象，对象加一个括号就是执行__call__，拿到返回值 print(r) 输出结果： init call init call 1
类后面添加括号执行__init__方法，对象后面加括号执行__call__方法。
用于索引操作，如字典。以上分别表示获取、设置、删除数据。
首先得实例是字典类型的操作。
class Foo: def __init__(self): print(‘init‘) def __call__(self, *args, **kwargs): print(‘call‘) return 1 def __getitem__(self, item): print(item) def __setitem__(self, key, value): print(key,value) def __delitem__(self, key): print(key) r = Foo() r() #调用__call__方法 r[‘k1‘]#使用中括号传参数的时候，默认使用过的是__getitem__方法 r[‘xxx‘] = 123#这里的xxx传给__setiem__的key，123传给__setitem__的value。 del r[‘xxx‘] #删除的时候，调用的是__delitem__方法 输出结果： init call k1
接下来是切片类型的操作，在切片操作的时候，在2.x版本中，执行的是__getslice_，__setslice__,delslice__方法，在3.x中的版本执行的是还是__getitem__，__setitem__，__delitem__方法。
class Foo: def __init__(self): print(‘init‘) def __call__(self, *args, **kwargs): print(‘call‘) return 1 def __getitem__(self, item): print(item,type(item),‘__getitem__‘) def __setitem__(self, key, value): print(key,value) def __delitem__(self, key): print(key) r = Foo() #使用切片的时候，在2.x版本中，调用的是__getslice__方法，在3.x中调用的是__getitem__方法。 r[1:3] r[1:3] = [11,22,33] #这里执行__setitem__方法 del r[1:3] #在这里执行__delitem__方法
dict是用来存储对象属性的一个字典，其键为属性名，值为属性的值。
class Foo: """ 我是一个注释 """ book = ‘alexsel‘ __book = ‘book‘ def __init__(self): self.__name = ‘alexsel‘ def start(self): Foo.__add() #内部调用私有静态方法 def __end(self): print(‘__end‘) @staticmethod def __add(): print(‘add‘) obj = Foo() print(obj.__dict__) #获取对象里面所有字段 print(Foo.__dict__) 输出结果： {‘_Foo__name‘: ‘alexsel‘} {‘book‘: ‘alexsel‘, ‘_Foo__book‘: ‘book‘, ‘__init__‘: <function Foo.__init__ at 0x00000000027CF950>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Foo‘ objects>, ‘start‘: <function Foo.start at 0x00000000027EBB70>, ‘_Foo__add‘: <staticmethod object at 0x00000000027B6390>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Foo‘ objects>, ‘_Foo__end‘: <function Foo.__end at 0x00000000027EBBF8>, ‘__doc__‘: ‘\n 我是一个注释\n ‘, ‘__module__‘: ‘__main__‘}
类的迭代器可以使用for循环迭代类。
如果创建的对象可以被迭代，在类的内部就执行了__iter__方法。
class Foo: def __iter__(self): yield 1 yield 2 yield 3 yield 4 obj = Foo() #如果执行for对象时，自动会执行对象的iter方法 for i in obj: print(i) 输出结果： 1 2 3 4
Python学习：17.Python面向对象（四、属性（特性），成员修饰符，类的特殊成员）
原文：https://www.cnblogs.com/liudi2017/p/9383838.html