一篇關于Python面向物件語法的總結

Python是一個面向物件的解釋型語言，所以當然也有類的概念， 
在Python中，所有資料型別都可以視為物件，當然也可以自定義物件，自定義的物件資料型別就是面向物件中的類（Class）的概念， 
之前接觸類的概念是在學習C++時，現在學習了python后，覺得兩者還是有很大的區別的，面向物件的思想是一樣的，但是python做為更高級的語言，在類的定義與使用更加簡便，

很多人學習python，不知道從何學起，
很多人學習python，掌握了基本語法過后，不知道在哪里尋找案例上手，
很多已經做案例的人，卻不知道如何去學習更加高深的知識，
那么針對這三類人，我給大家提供一個好的學習平臺，免費領取視頻教程，電子書籍，以及課程的源代碼！??¤
QQ群：623406465

類的定義

Python中，定義類是通過class關鍵字，例如我們定義一個存盤學生資訊的類：

class Student(object):
    pass

class后面緊接著是類名，即Student，類名通常是大寫開頭的單詞，緊接著是(object)，表示該類是從哪個類繼承下來的，通常，如果沒有合適的繼承類，就使用object類，這是所有類最終都會繼承的類，

定義好了Student類，就可以根據Student類創建出Student的實體，創建實體是通過類名+()實作的:

>> bart = Student()/n>>> bart/n<__main__.Student object at 0x10a67a590>/n>>> Student/n>>> bart = Student()
>>> bart
<__main__.Student object at 0x10a67a590>
>>> Student
<class '__main__.Student'>

可以看到，變數bart指向的就是一個Student的實體，后面的0x10a67a590是記憶體地址，每個object的地址都不一樣，而Student本身則是一個類，

可以自由地給一個實體變數系結屬性，比如，給實體bart系結一個name屬性：

>> bart.name ='Bart Simpson'\n>>> bart.name\n'Bart Simpson'","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> bart.name = 'Bart Simpson'
>>> bart.name
'Bart Simpson'

這點與靜態語言，比如C++是不一樣的，我們可以隨時給一個物件添加屬性， 
在python中，類的屬性就等同于c++類的成員變數，類的方法等同于c++類的成員函式， 
由于類可以起到模板的作用，因此，可以在創建實體的時候，把一些我們認為必須系結的屬性強制填寫進去，通過定義一個特殊的init方法，在創建實體的時候，就把name，score等屬性綁上去：

class Student(object):

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

對比c++，__init__函式就等同于c++類得建構式，注意：特殊方法“init”前后有兩個下劃線， 
注意到init方法的第一個引數永遠是self，表示創建的實體本身，因此，在init方法內部，就可以把各種屬性系結到self，因為self就指向創建的實體本身，

有了init方法，在創建實體的時候，就不能傳入空的引數了，必須傳入與init方法匹配的引數，但self不需要傳，Python解釋器自己會把實體變數傳進去：

>> bart = Student('Bart Simpson', 59)\n>>> bart.name\n'Bart Simpson'\n>>> bart.score\n59","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> bart = Student('Bart Simpson', 59)
>>> bart.name
'Bart Simpson'
>>> bart.score
59

和普通的函式相比，在類中定義的函式只有一點不同，就是第一個引數永遠是實體變數self，并且，呼叫時，不用傳遞該引數，除此之外，類的方法和普通函式沒有什么區別，所以，你仍然可以用默認引數、可變引數、關鍵字引數和命名關鍵字引數，

我們可以給我們定義的Student類增加新的方法，比如get_grade：

= 90:/n            return'A'\n        elif self.score >= 60:\n            return 'B'\n        else:\n            return 'C'","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">class Student(object):
    ...

    def get_grade(self):
        if self.score >= 90:
            return 'A'
        elif self.score >= 60:
            return 'B'
        else:
            return 'C'

訪問限制

在Class內部，可以有屬性和方法，而外部代碼可以通過直接呼叫實體變數的方法來操作資料，這樣，就隱藏了內部的復雜邏輯，

但是，從前面Student類的定義來看，外部代碼還是可以自由地修改一個實體的name、score屬性：

>> bart = Student('Bart Simpson', 98)\n>>> bart.score\n98\n>>> bart.score = 59\n>>> bart.score\n59","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> bart = Student('Bart Simpson', 98)
>>> bart.score
98
>>> bart.score = 59
>>> bart.score
59

如果要讓內部屬性不被外部訪問，可以把屬性的名稱前加上兩個下劃線__，在Python中，實體的變數名如果以__開頭，就變成了一個私有變數（private），只有內部可以訪問，外部不能訪問，所以，我們把Student類改一改：

class Student(object):

    def __init__(self, name, score):
        self.__name = name
        self.__score = score

    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))

改完后，對于外部代碼來說，沒什么變動，但是已經無法從外部訪問實體變數__name和實體變數__score了：

>> bart = Student('Bart Simpson', 98)\n>>> bart.__name\nTraceback (most recent call last):\n  File \"<stdin>\", line 1, in <module>\nAttributeError: 'Student' object has no attribute '__name'","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> bart = Student('Bart Simpson', 98)
>>> bart.__name
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute '__name'

但是如果外部代碼要獲取name和score怎么辦？可以給Student類增加get_name和get_score這樣的方法：

class Student(object):
    ...

    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__score

如果又要允許外部代碼修改score怎么辦？可以再給Student類增加set_score方法：

class Student(object):
    ...

    def set_score(self, score):
        self.__score = score

需要注意的是，在Python中，變數名類似__xxx__的，也就是以雙下劃線開頭，并且以雙下劃線結尾的，是特殊變數，特殊變數是可以直接訪問的，不是private變數， 
有些時候，你會看到以一個下劃線開頭的實體變數名，比如_name，這樣的實體變數外部是可以訪問的，但是，按照約定俗成的規定，當你看到這樣的變數時，意思就是，“雖然我可以被訪問，但是，請把我視為私有變數，不要隨意訪問”，

類的私有成員一定不可以在外部訪問嗎？其實也不是， 
不能直接訪問__name是因為Python解釋器對外把__name變數改成了_Student__name，所以，仍然可以通過_Student__name來訪問__name變數：

>> bart._Student__name/n'Bart Simpson'","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> bart._Student__name
'Bart Simpson'

但是強烈建議你不要這么干，因為不同版本的Python解釋器可能會把__name改成不同的變數名， 
總的來說就是，Python本身沒有任何機制阻止你干壞事，一切全靠自覺， 
最后注意下面的這種錯誤寫法：

>> bart = Student('Bart Simpson', 98)\n>>> bart.get_name()\n'Bart Simpson'\n>>> bart.__name = 'New Name' # 設定__name變數！\n>>> bart.__name\n'New Name'","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> bart = Student('Bart Simpson', 98)
>>> bart.get_name()
'Bart Simpson'
>>> bart.__name = 'New Name' # 設定__name變數！
>>> bart.__name
'New Name'

表面上看，外部代碼“成功”地設定了__name變數，但實際上這個__name變數和class內部的__name變數不是一個變數！內部的__name變數已經被Python解釋器自動改成了_Student__name，而外部代碼給bart新增了一個__name變數，不信試試：

>> bart.get_name() # get_name()內部回傳self.__name/n'Bart Simpson'","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> bart.get_name() # get_name()內部回傳self.__name
'Bart Simpson'

多繼承

在Python中，類也是支持多繼承的，只需要在定義類時的括號里把繼承的所有類名寫入就可以， 
例如:

class Dog(Mammal, Runnable):
    pass

上面的例子定義了一個名為Dog的類，同時繼承了Mammal和Runnable類，

我們再看一個例子，比如，我們已經撰寫了一個名為Animal的class，有一個run()方法可以直接列印：

class Animal(object):
    def run(self):
        print('Animal is running...')

當我們需要撰寫Dog和Cat類時，就可以直接從Animal類繼承：

class Dog(Animal):
    pass

class Cat(Animal):
    pass

我們再撰寫一個函式，這個函式接受一個Animal型別的變數：

def run_twice(animal):
    animal.run()
    animal.run()

我們傳入Animal的實體時，run_twice()就列印出：

>> run_twice(Animal())/nAnimal is running.../nAnimal is running...","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> run_twice(Animal())
Animal is running...
Animal is running...

當我們傳入Dog的實體時，同樣也會列印出：

>> run_twice(Dog())/nAnimal is running.../nAnimal is running...","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> run_twice(Dog())
Animal is running...
Animal is running...

因為Dog類繼承了Animal類，是Animal的子類，在執行run函式時，由于Dog類實體沒有定義自己的run函式，執行的是Animal類的run函式， 
但是如果我們傳入一個跟Animal類沒有任何關系的一個類實體時，會出現什么情況呢？ 
我們定義一個Timer的類，該類也有一個名為run的方法，

class Timer(object):
    def run(self):
        print('Start...')

傳入run_twice函式：

run_twice(Timer())
Start...
Start...

我們會發現該函式仍可以正常運行，

對于靜態語言（例如C++）來說，如果需要傳入Animal型別，則傳入的物件必須是Animal型別或者它的子類，否則，將無法呼叫run()方法， 
對于Python這樣的動態語言來說，則不一定需要傳入Animal型別，我們只需要保證傳入的物件有一個run()方法就可以了，
這就是動態語言的“鴨子型別”，它并不要求嚴格的繼承體系，一個物件只要“看起來像鴨子，走起路來像鴨子”，那它就可以被看做是鴨子，

獲取物件型別

當我們拿到一個物件的參考時，如何知道這個物件是什么型別、有哪些方法呢？

使用type

首先，我們來判斷物件型別，使用type()函式： 
基本型別都可以用type()判斷：

>> type(123)/n>>> type(123)
<class 'int'>
>>> type('str')
<class 'str'>
>>> type(None)
<type(None) 'NoneType'>

如果一個變數指向函式或者類，也可以用type()判斷：

>> type(abs)/n>>> type(abs)
<class 'builtin_function_or_method'>
>>> type(a)
<class '__main__.Animal'>

但是type()函式回傳的是什么型別呢？它回傳對應的Class型別，如果我們要在if陳述句中判斷，就需要比較兩個變數的type型別是否相同：

>> type(123)==type(456)/nTrue/n>>> type(123)==int/nTrue/n>>> type('abc')==type('123')\nTrue\n>>> type('abc')==str\nTrue\n>>> type('abc')==type(123)\nFalse","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> type(123)==type(456)
True
>>> type(123)==int
True
>>> type('abc')==type('123')
True
>>> type('abc')==str
True
>>> type('abc')==type(123)
False

判斷基本資料型別可以直接寫int，str等，但如果要判斷一個物件是否是函式怎么辦？可以使用types模塊中定義的常量：

>> import types/n>>> def fn():/n...     pass/n.../n>>> type(fn)==types.FunctionType/nTrue/n>>> type(abs)==types.BuiltinFunctionType/nTrue/n>>> type(lambda x: x)==types.LambdaType/nTrue/n>>> type((x for x in range(10)))==types.GeneratorType/nTrue","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> import types
>>> def fn():
...     pass
...
>>> type(fn)==types.FunctionType
True
>>> type(abs)==types.BuiltinFunctionType
True
>>> type(lambda x: x)==types.LambdaType
True
>>> type((x for x in range(10)))==types.GeneratorType
True

使用isinstance()

對于class的繼承關系來說，使用type()就很不方便，我們要判斷class的型別，可以使用isinstance()函式， 
如果繼承關系是：object -> Animal -> Dog -> Husky 
那么，isinstance()就可以告訴我們，一個物件是否是某種型別，先創建3種型別的物件：

>> a = Animal()/n>>> d = Dog()/n>>> h = Husky()","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> a = Animal()
>>> d = Dog()
>>> h = Husky()

然后，判斷：

>> isinstance(h, Husky)/nTrue","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> isinstance(h, Husky)
True

沒有問題，因為h變數指向的就是Husky物件， 
再判斷：

>> isinstance(h, Dog)/nTrue","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> isinstance(h, Dog)
True

h雖然自身是Husky型別，但由于Husky是從Dog繼承下來的，所以，h也還是Dog型別，換句話說，isinstance()判斷的是一個物件是否是該型別本身，或者位于該型別的父繼承鏈上，

使用dir()

如果要獲得一個物件的所有屬性和方法，可以使用dir()函式，它回傳一個包含字串的list，比如，獲得一個str物件的所有屬性和方法：

>> dir('ABC')\n['__add__', '__class__', '__contains__', '__delattr__', '__dir__', \n'__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', \n'__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', \n'__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', \n'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', \n'__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', \n'__subclasshook__', 'capitalize', 'casefold', 'center', 'count', \n'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', \n'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', \n'isnumeric', 'isprintable', 'isspace',\n 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', \n'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', \n'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', \n'zfill']","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> dir('ABC')
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', 
'__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', 
'__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', 
'__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', 
'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', 
'__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', 
'__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 
'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 
'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 
'isnumeric', 'isprintable', 'isspace',
 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 
'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 
'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 
'zfill']

類似__xxx__的屬性和方法在Python中都是有特殊用途的，比如__len__方法回傳長度，在Python中，如果你呼叫len()函式試圖獲取一個物件的長度，實際上，在len()函式內部，它自動去呼叫該物件的__len__()方法，所以，下面的代碼是等價的：

>> len('ABC')\n3\n>>> 'ABC'.__len__()\n3","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> len('ABC')
3
>>> 'ABC'.__len__()
3

我們自己寫的類，如果也想用len(myObj)的話，就自己寫一個len()方法：

>> class MyDog(object):/n...     def __len__(self):/n...         return 100/n.../n>>> dog = MyDog()/n>>> len(dog)/n100","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> class MyDog(object):
...     def __len__(self):
...         return 100
...
>>> dog = MyDog()
>>> len(dog)
100

僅僅把屬性和方法列出來是不夠的，配合getattr()、setattr()以及hasattr()，我們可以直接操作一個物件的狀態：

>> class MyObject(object):/n...     def __init__(self):/n...         self.x = 9/n...     def power(self):/n...         return self.x * self.x/n.../n>>> obj = MyObject()","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> class MyObject(object):
...     def __init__(self):
...         self.x = 9
...     def power(self):
...         return self.x * self.x
...
>>> obj = MyObject()

緊接著，可以測驗該物件的屬性：

>> hasattr(obj,'x') # 有屬性'x'嗎？\nTrue\n>>> obj.x\n9\n>>> hasattr(obj, 'y') # 有屬性'y'嗎？\nFalse\n>>> setattr(obj, 'y', 19) # 設定一個屬性'y'\n>>> hasattr(obj, 'y') # 有屬性'y'嗎？\nTrue\n>>> getattr(obj, 'y') # 獲取屬性'y'\n19\n>>> obj.y # 獲取屬性'y'\n19","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> hasattr(obj, 'x') # 有屬性'x'嗎？
True
>>> obj.x
9
>>> hasattr(obj, 'y') # 有屬性'y'嗎？
False
>>> setattr(obj, 'y', 19) # 設定一個屬性'y'
>>> hasattr(obj, 'y') # 有屬性'y'嗎？
True
>>> getattr(obj, 'y') # 獲取屬性'y'
19
>>> obj.y # 獲取屬性'y'
19

如果試圖獲取不存在的屬性，會拋出AttributeError的錯誤：

>> getattr(obj,'z') # 獲取屬性'z'\nTraceback (most recent call last):\n  File \"<stdin>\", line 1, in <module>\nAttributeError: 'MyObject' object has no attribute 'z'","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> getattr(obj, 'z') # 獲取屬性'z'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyObject' object has no attribute 'z'

使用__slots__

正常情況下，當我們定義了一個class，創建了一個class的實體后，我們可以給該實體系結任何屬性和方法，這就是動態語言的靈活性，先定義class：

class Student(object):
    pass

然后，嘗試給實體系結一個屬性：

>> s = Student()/n>>> s.name ='Michael' # 動態給實體系結一個屬性\n>>> print(s.name)\nMichael","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> s = Student()
>>> s.name = 'Michael' # 動態給實體系結一個屬性
>>> print(s.name)
Michael

但是，如果我們想要限制實體的屬性怎么辦？比如，只允許對Student實體添加name和age屬性， 
為了達到限制的目的，Python允許在定義class的時候，定義一個特殊的__slots__變數，來限制該class實體能添加的屬性：

class Student(object):
    __slots__ = ('name', 'age') # 用tuple定義允許系結的屬性名稱

然后，我們試試：

>> s = Student() # 創建新的實體/n>>> s.name ='Michael' # 系結屬性'name'\n>>> s.age = 25 # 系結屬性'age'\n>>> s.score = 99 # 系結屬性'score'\nTraceback (most recent call last):\n  File \"<stdin>\", line 1, in <module>\nAttributeError: 'Student' object has no attribute 'score'","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> s = Student() # 創建新的實體
>>> s.name = 'Michael' # 系結屬性'name'
>>> s.age = 25 # 系結屬性'age'
>>> s.score = 99 # 系結屬性'score'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'score'

由于’score’沒有被放到__slots__中，所以不能系結score屬性，試圖系結score將得到AttributeError的錯誤， 
使用__slots__要注意，__slots__定義的屬性僅對當前類實體起作用，對繼承的子類是不起作用的， 
除非在子類中也定義__slots__，這樣，子類實體允許定義的屬性就是自身的__slots__加上父類的__slots__，

使用@property

在系結屬性時，如果我們直接把屬性暴露出去，雖然寫起來很簡單，但是，沒辦法檢查引數，導致可以把成績隨便改：

s = Student()
s.score = 9999

這顯然不合邏輯，為了限制score的范圍，可以通過一個set_score()方法來設定成績，再通過一個get_score()來獲取成績，這樣，在set_score()方法里，就可以檢查引數：

class Student(object):

    def get_score(self):
         return self._score

    def set_score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

現在，對任意的Student實體進行操作，就不能隨心所欲地設定score了：

>> s = Student()/n>>> s.set_score(60) # ok!/n>>> s.get_score()/n60/n>>> s.set_score(9999)/nTraceback (most recent call last):/n  .../nValueError: score must between 0 ~ 100!","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> s = Student()
>>> s.set_score(60) # ok!
>>> s.get_score()
60
>>> s.set_score(9999)
Traceback (most recent call last):
  ...
ValueError: score must between 0 ~ 100!

但是，上面的呼叫方法又略顯復雜，沒有直接用屬性這么直接簡單， 
有沒有既能檢查引數，又可以用類似屬性這樣簡單的方式來訪問類的變數呢？對于追求完美的Python程式員來說，這是必須要做到的！ 
還記得裝飾器（decorator）可以給函式動態加上功能嗎？對于類的方法，裝飾器一樣起作用，Python內置的@property裝飾器就是負責把一個方法變成屬性呼叫的：

class Student(object):

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

把一個getter方法變成屬性，只需要加上@property就可以了，此時，@property本身又創建了另一個裝飾器@score.setter，負責把一個setter方法變成屬性賦值，于是，我們就擁有一個可控的屬性操作：

>> s = Student()/n>>> s.score = 60 # OK，實際轉化為s.set_score(60)/n>>> s.score # OK，實際轉化為s.get_score()/n60/n>>> s.score = 9999/nTraceback (most recent call last):/n  .../nValueError: score must between 0 ~ 100!","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">>>> s = Student()
>>> s.score = 60 # OK，實際轉化為s.set_score(60)
>>> s.score # OK，實際轉化為s.get_score()
60
>>> s.score = 9999
Traceback (most recent call last):
  ...
ValueError: score must between 0 ~ 100!

注意到這個神奇的@property，我們在對實體屬性操作的時候，就知道該屬性很可能不是直接暴露的，而是通過getter和setter方法來實作的，

還可以定義只讀屬性，只定義getter方法，不定義setter方法就是一個只讀屬性：

class Student(object):

    @property
    def birth(self):
        return self._birth

    @birth.setter
    def birth(self, value):
        self._birth = value

    @property
    def age(self):
        return 2015 - self._birth

上面的birth是可讀寫屬性，而age就是一個只讀屬性，因為age可以根據birth和當前時間計算出來，

@property廣泛應用在類的定義中，可以讓呼叫者寫出簡短的代碼，同時保證對引數進行必要的檢查，這樣，程式運行時就減少了出錯的可能性，

標籤：其他

上一篇：[GO] 變參函式-GO中函式傳遞變長引數

下一篇：編程代碼 | C++/C輸出陽歷萬年歷—精美日歷制作