python中類的成員

成員有以下：
1、字段：   靜態字段 普通字段
2、方法：  靜態方法 類方法 普通方法
3、特性/屬性 普通特性

成員修飾符  修飾成員
公有的：沒有限制
私有的：以__開頭 僅僅內部可以訪問，不能被繼承，僅自己可訪問。私有的成員可通過公有的成員間接訪問

何時用類調用，何時用對象調用？
類調用： 無self
對象調用：self

結論：

1、靜態字段和靜態方法和類方法通過類來訪問，普通字段和方法通過對象來訪問
2、靜態方法，使用@staticmethod來裝飾
3、類方法，使用@classmethod來裝飾
4、屬性（特性），使用@property來裝飾，定義的時候類似普通方法一樣，但調用的時候像普通字段一樣
5、屬性的getter和setter，通過@property來裝飾的方法return來getter，之后通過@方法名.setter裝飾的方法來setter

一些特殊的成員：

__init__ 構造方法，創建對象時調用
__del__ 析構方法，銷毀對象時調用
__call__ 對象() 調用
__getitem__ 對象[] 來調用
__setitem__ 對象[] = xxx 來調用
__delitem__ del 對象[] 來調用
__dict__ 列出所有的成員 用途：在表單對象中獲取表單所有的字段
參考字典對象dict
__str__ 類似java中的toString方法，直接打印對象輸出的就是該方法的返回值

class Province:
    country = "中國"  # 靜態字段，在類中保存，將對象中共有的字段和值可以保存到靜態字段
    def __init__(self, name):
        self.name = name  # 普通字段

    @staticmethod
    def xxoo(arg1, arg2): # 靜態方法
        print(arg1, arg2)

    @classmethod
    def xo(cls):  # 類方法  會將類傳遞過來
        print(cls)

    @property
    def xx(self):  # 屬性（特性），將方法偽裝成字段  getter
        # print("property")
        return self.val

    @xx.setter
    def xx(self, value):  
        self.val = value

hubei = Province("湖北")
print(hubei.__dict__)
print(Province("福建").__dict__)
print(Province.__dict__)
print(Province.country)   # 靜態字段通過類來訪問
Province.xxoo("hello", "hi")  # 靜態方法通過類來訪問
Province.xo()  # 類方法通過類來訪問
hubei.xx = "property1"  # 屬性的setter
print(hubei.xx)  #屬性調用 getter

 

class Foo:
    xo = "xo"
    __ox = "__ox"
    def __init__(self):
        pass
    def fetch(self):
        print(Foo.__ox)  # 私有的成員通過公有的成員間接訪問
    def __hello(self):
        print("__hello")
    @staticmethod
    def __dd():
        print("__dd")
    def dd(self):
        self.__hello()
        Foo.__dd()

    def __call__(self, *args, **kwargs):
        print("call")

    def __getitem__(self, item):
        print(item, type(item))
    def __setitem__(self, key, value):
        print(key,value)
    def __delitem__(self, key):
        print(key)

    def __iter__(self):
        yield 1
        yield 2
        yield 3

class Bar(Foo):
    def __init__(self):
        # self.__hello()
     # self.__ox      # 父類私有的成員，子類不能訪問
        pass
print(Foo.xo)
# print(Foo.__ox)
f = Foo()
f.fetch()
# f.__hello()
f.dd()
print(Bar.xo)
b = Bar()
b.dd()
# f._Foo__hello()  # 私有的普通字段或普通方法可通過該方式在外部訪問，但不建議使用
f()  # 調用__call__方法
f["abcd"]   #調用__getitem__
f[1:6:2]    #slice(1, 6, 2) <class 'slice'>   切片  __getitem__  在py2.7  __getslice__
f["k1"] = "v1"   #調用__setitem__
f[1:6:2] = ["a", "b", "c"]   #slice(1, 6, 2) ['a', 'b', 'c']   切片  __setitem__  在py2.7  __setslice__
del f["k1"]
print(f.__dict__)
print(Foo.__dict__)

for i in f:   # 如果一個類實現了__iter__方法，其對象可以通過for來迭代
    print(i)