python面向对象之类成员修饰符

类的所有成员分为：

　　公有成员，在任何地方都能访问

　　私有成员，只有在类的内部才能访问

私有成员和公有成员的定义不同：私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：__init__、__call__等）

私有成员和公有成员的访问限制不同：

静态字段：

公有静态字段：类可以访问，类内部可以访问；派生类中可以访问

私有静态字段：仅类内部可以访问

class C(object):
    name = '公有静态字段'
    __age = '私有静态字段'

    def func(self):
        print(C.name, self.__age)

class D(C):
    def show(self):
        print(self.name)

print(C.__age)      #错误！类不可直接访问私有静态字段
obj = D()
obj.func()          #类内部可以访问
obj.show()          #派生类中可以访问公有静态字段，但不可访问私有静态字段

普通字段：
　　公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问

　　私有普通字段：仅类内部可以访问

class C(object):
    def __init__(self):
        self.name = '公有普通字段'
        self.__age = '私有普通字段'

    def func(self):
        """类内部可以访问公有和私有字段"""
        print(self.name, self.__age)

class D(C):
    def show(self):
        """派生类内部不可以访问私有字段"""
        print(self.name)

obj = D()
print(obj.name) #类直接访问公有字段
obj.func()      #类内部访问各种字段
obj.show()      #派生类中访问公有字段
print(obj._C__age)  #私有成员可通过  对象名._类名__属性名称 来访问

方法、属性的访问与上述方式相似，即，私有成员只能在类内部使用
PS:私有成员若非要访问的花，可以通过  对象._类__属性名  来访问

类的特殊成员：

1、__doc__

　　表示描述信息

class Foo(object):
    """描述类的信息"""

    def func(self):
        """描述方法的信息"""
        pass

print(Foo.__doc__)      #打印出类的描述信息
print(Foo.func.__doc__) #打印出方法的描述信息

2、__module__ 和 __class__
　　__module__表示当前操作的对象在哪个模块

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

class Foo(object):
    def __init__(self):
        self.name = 'cable'

from memb import Foo

obj = Foo()
print(obj.__module__)
print(obj.__class__)

3、__init__
　　构造方法，通过类创建对象时，自动触发执行。

class Foo(object):
    def __init__(self, name):
        self.name = name
        self.age = 20

obj = Foo('cab')    #自动执行类中的__init__方法

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

PS：此方法一般无需定义，因为python时一门高级语言，程序员在使用中无需关心内存的分配和释放，因为此工作都交给Python解释器来执行，所以，析构方法的调用是由解释器在进行垃圾回收时自动触发执行的。

5、__call__

　　对象后面加括号，触发执行

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

class Foo(object):
    def __init__(self):
        print('starting')

    def __call__(self, *args, **kwargs):
        print('执行__call__')

obj = Foo()
obj()

6、__dict__
　　类或对象中的所有成员

　　类的普通字段属于对象；类中的静态字段和方法等属于类，即：

class Province(object):
    country = '中国'

    def __init__(self, name, count):
        self.name = name
        self.count = count

    def func(self, *args, **kwargs):
        print('func方法')

print(Province.__dict__)            #获取类Province的成员
obj1 = Province('山东', '德州')
print(obj1.__dict__)                #获取对象obj1的成员
obj2 = Province('黑龙江', '北安')
print(obj2.__dict__)                #获取对象obj2的成员

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

class Foo(object):
    def __str__(self):
        return '返回值'

obj = Foo()
print(obj)      #输出返回值

8、__getitem__ 、  __setitem__ 和 __delitem__ 方法
　　用于索引操作，例如字典。以上分别表示获取、设置和删除数据

class Foo(object):
    def __getitem__(self, item):
        print('getitem', type(item))

    def __setitem__(self, key, value):
        print('setitem', type(key), type(value))

    def __delitem__(self, key):
        print('delitem', type(key))

obj = Foo()
res = obj['k1']     #自动触发__getitem__方法
obj[3] = 666        #自动触发__setitem__方法
del obj['k2']       #自动触发__delitem__方法

9、 __getslice__ 、 __setslice__ 和 __delslice__
　　这三个方法用于分片操作，但在python3中已经弃用

10、__iter__方法

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

class Foo(object):
    def __init__(self, value):
        self.value = value

    def __iter__(self):
        return iter(self.value)

obj = Foo('cable')

for i in obj:
    print(i)

for循环内部代码如下：

obj = iter([11,22,33,44])

while True:
    val = obj.next()
    print val