面向對象編程
面向對象編程 Object Oriented Programming 簡稱 OOP，是一種程序設計思想。OOP把對象作為程序的基本單元，一個對象包含了數據和操作數據的函數。
面向過程的程序設計把計算機程序視為一系列的命令集合，即一組函數的順序執行。為了簡化程序設計，面向過程把函數繼續切分為子函數，即把大塊函數通過切割成小塊函數來降低系統的復雜度。
而面向對象的程序設計把計算機程序視為一組對象的集合，而每個對象都可以接收其他對象發過來的消息，並處理這些消息，計算機程序的執行就是一系列消息在各個對象之間傳遞。
在Python中，所有數據類型都可以視為對象，當然也可以自定義對象。自定義的對象數據類型就是面向對象中的類（Class）的概念。面向對象的抽象程度又比函數要高，因為一個Class既包含數據，又包含操作數據的方法。
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))
類和實例
class后面緊接着是類名，即Student，類名通常是大寫開頭的單詞，緊接着是(object)，表示該類是從哪個類繼承下來的，繼承的概念我們后面再講，通常，如果沒有合適的繼承類，就使用object類，這是所有類最終都會繼承的類。
定義好了Student類，就可以根據Student類創建出Student的實例，創建實例是通過類名+()實現的。__init__函數與其它函數有所不同，它的第一個參數永遠是實例變量self，並且，調用時，不用傳遞該參數。
數據封裝
類本身擁有數據和方法，相當於將“數據”封裝起來了。對於外部來說，並不需要知道內部的邏輯。
訪問限制
Class可以有屬性和方法，我們可以對屬性和方法進行控制，以達到允許或者不允許外部訪問的目的。如果要讓內部屬性不被外部訪問，可以把屬性的名稱前加上兩個下划線__，在Python中，實例的變量名如果以__開頭，就變成了一個私有變量（private），只有內部可以訪問，外部不能訪問。
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))
def get_name(self):
return self.__name
def get_score(self):
return self.__score
def set_score(self, score):
if 0 <= score <= 100:
self.__score = score
else:
raise ValueError('bad score’)
在Python中，變量名類似
__xxx__的，也就是以雙下划線開頭，並且以雙下划線結尾的，是特殊變量，特殊變量是可以直接訪問的，不是private變量，所以，不能用__name__、__score__這樣的變量名。
繼承和多態
在OOP程序設計中，當我們定義一個class的時候，可以從某個現有的class繼承，新的class稱為子類（Subclass），而被繼承的class稱為基類、父類或超類（Base class、Super class）。
class Animal(object):
def run(self):
print('Animal is running…')
class Dog(Animal):
def run(self):
print('Dog is running...')
class Cat(Animal):
def run(self):
print('Cat is running…')
當子類和父類都存在相同的run()方法時，我們說，子類的run()覆蓋了父類的run()，在代碼運行的時候，總是會調用子類的run()。這樣，我們就獲得了繼承的另一個好處：多態。在繼承關系中，如果一個實例的數據類型是某個子類，那它的數據類型也可以被看做是父類。但是，反過來就不行。
對於一個變量，我們只需要知道它是Animal類型，無需確切地知道它的子類型，就可以放心地調用run()方法，而具體調用的run()方法是作用在Animal、Dog、Cat還是Tortoise對象上，由運行時該對象的確切類型決定，這就是多態真正的威力：調用方只管調用，不管細節，而當我們新增一種Animal的子類時，只要確保run()方法編寫正確，不用管原來的代碼是如何調用的。這就是著名的“開閉”原則：
對擴展開放：允許新增Animal子類；
對修改封閉：不需要修改依賴Animal類型的外部函數。
鴨子類型
對於靜態語言（例如Java）來說，如果需要傳入Animal類型，則傳入的對象必須是Animal類型或者它的子類，否則，將無法調用run()方法。對於Python這樣的動態語言來說，則不一定需要傳入Animal類型。我們只需要保證傳入的對象有一個run()方法就可以了。這就是動態語言的“鴨子類型”，它並不要求嚴格的繼承體系，一個對象只要“看起來像鴨子，走起路來像鴨子”，那它就可以被看做是鴨子。
獲取對象信息
判斷Python中對象的類型，可以用以下方法。
type()
基本類型都可以用type()判斷，基本數據類型可以直接寫int、str，判斷是否函數需要使用types中定義的常量。
>>> 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()
對於類和實例，使用type()就不是很方便，可以使用isinstance()。基本數據類型也可以使用isinstance()判斷。還可以判斷一個變量是否是某些類型中的一種。
>>> isinstance([1, 2, 3], (list, tuple))
True
>>> isinstance((1, 2, 3), (list, tuple))
True
dir()
如果要獲得一個對象的所有屬性和方法，可以使用dir()函數，它返回一個包含字符串的list，比如，獲得一個str對象的所有屬性和方法。
實例屬性和類屬性
Python類創建的實例可以任意綁定屬性，如果需要對類本身綁定屬性，則需要在類中定義，這就區分了類屬性和實例屬性。
在編寫程序的時候，千萬不要把實例屬性和類屬性使用相同的名字，因為相同名稱的實例屬性將屏蔽掉類屬性，但是當你刪除實例屬性后，再使用相同的名稱，訪問到的將是類屬性。
面向對象高級編程
數據封裝、繼承和多態是面相對象程序設計中的三個基本概念，另外還有很多特性，包括多重繼承、定制類等。
使用 slots()
在Python中，可以對類動態的增加屬性和方法，這在靜態語言中很難實現。
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
class Student(object):
def __init__(self):
print("Instance Created")
Tracy = Student()
Tracy.age = 30
Bob = Student()
Bob.age = 41
Ceaser = Student()
print(Tracy.age)
print(Bob.age)
def set_age(self, age):
self.age = age
from types import MethodType
s = Student()
s.set_age = MethodType(set_age, s)
s.set_age(25)
print(s.age)
Student.set_age = set_age
Ceaser.set_age(33)
print(Ceaser.age)
但這也帶來一個問題，屬性和方法可以隨意更改，如果我們要限制怎么辦？可以使用__slots。Python允許在定義class的時候，定義一個特殊的__slots__變量，來限制該class實例能添加的屬性。使用__slots__要注意，__slots__定義的屬性僅對當前類實例起作用，對繼承的子類是不起作用的。
class Student(object):
__slots__ = ('name', 'age') # 用tuple定義允許綁定的屬性名稱
使用@Property
Python中實例的屬性暴露在外面可以隨便修改，這樣就無法保證屬性的有效性符合校驗規則。雖然可以通過設置Setter和Getter來進行檢查，但如果屬性特別多，操作起來又比較麻煩。
還記得裝飾器（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
@property的實現比較復雜，我們先考察如何使用。把一個getter方法變成屬性，只需要加上@property就可以了，此時，@property本身又創建了另一個裝飾器@score.setter，負責把一個setter方法變成屬性賦值，於是，我們就擁有一個可控的屬性操作。
>>> 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!
還可以定義只讀屬性，只定義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
多重繼承
繼承是面向對象編程的一個重要的方式，因為通過繼承，子類就可以擴展父類的功能。舉例來說對於動物的對象設計，可以按照“哺乳動物”、“鳥類”來設計分類對象，按照不同的維度，也可以按照“能跑的”、“能飛的”或者“寵物”、“非寵物”設計分類，如果按照單一繼承的方式，類的設計就像下圖，會變的非常復雜。
正確的辦法是采用多重繼承。一個子類就可以同時獲得多個父類的所有功能。在設計類的繼承關系時，通常，主線都是單一繼承下來的，例如，Ostrich繼承自Bird。但是，如果需要“混入”額外的功能，通過多重繼承就可以實現，比如，讓Ostrich除了繼承自Bird外，再同時繼承Runnable。這種設計通常稱之為MixIn。
class Animal(object):
pass
# 大類:
class Mammal(Animal):
pass
class Bird(Animal):
pass
# 各種動物:
class Dog(Mammal):
pass
class Bat(Mammal):
pass
class Parrot(Bird):
pass
class Ostrich(Bird):
pass
class Runnable(object):
def run(self):
print('Running...')
class Flyable(object):
def fly(self):
print('Flying…’)
class Dog(Mammal, Runnable):
pass
class Bat(Mammal, Flyable):
pass
Python自帶的很多庫也使用了MixIn。舉個例子，Python自帶了TCPServer和UDPServer這兩類網絡服務，而要同時服務多個用戶就必須使用多進程或多線程模型，這兩種模型由ForkingMixIn和ThreadingMixIn提供。通過組合，我們就可以創造出合適的服務來。
定制類
類似於__slots__，Python的class中還有許多這樣有特殊用途的函數，可以幫助我們定制類。
str
定義print 函數調用時的返回結果。
>>> class Student(object):
... def __init__(self, name):
... self.name = name
... def __str__(self):
... return 'Student object (name: %s)' % self.name
...
>>> print(Student('Michael'))
Student object (name: Michael)
repr
定義返回程序開發者看到的字符串，也就是在命令行狀態下執行時的返回值。
class Student(object):
def __init__(self, name):
self.name = name
def __str__(self):
return 'Student object (name=%s)' % self.name
__repr__ = __str__
iter
如果一個類想被用於for … in循環，類似list或tuple那樣，就必須實現一個__iter__()方法，該方法返回一個迭代對象，然后，Python的for循環就會不斷調用該迭代對象的__next__()方法拿到循環的下一個值，直到遇到StopIteration錯誤時退出循環。
class Fib(object):
def __init__(self):
self.a, self.b = 0, 1 # 初始化兩個計數器a，b
def __iter__(self):
return self # 實例本身就是迭代對象，故返回自己
def __next__(self):
self.a, self.b = self.b, self.a + self.b # 計算下一個值
if self.a > 100000: # 退出循環的條件
raise StopIteration()
return self.a # 返回下一個值
getitem
Fib實例雖然能作用於for循環，看起來和list有點像，但是，把它當成list來使用還是不行，比如，取第5個元素。
class Fib(object):
def __getitem__(self, n):
if isinstance(n, int): # n是索引
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
if isinstance(n, slice): # n是切片
start = n.start
stop = n.stop
if start is None:
start = 0
a, b = 1, 1
L = []
for x in range(stop):
if x >= start:
L.append(a)
a, b = b, a + b
return L
通過上面的方法，我們自己定義的類表現得和Python自帶的list、tuple、dict沒什么區別，這完全歸功於動態語言的“鴨子類型”，不需要強制繼承某個接口。
getattr
正常情況下，當我們調用類的方法或屬性時，如果不存在，就會報錯。要避免這個錯誤，除了可以加上一個屬性外，Python還有另一個機制，那就是寫一個__getattr__()方法，動態返回一個屬性。
class Student(object):
def __init__(self):
self.name = 'Michael'
def __getattr__(self, attr):
if attr=='score':
return 99
call
任何類，只需要定義一個__call__()方法，就可以直接對實例進行調用。__call__()還可以定義參數。對實例進行直接調用就好比對一個函數進行調用一樣，所以你完全可以把對象看成函數，把函數看成對象，因為這兩者之間本來就沒啥根本的區別。
class Student(object):
def __init__(self, name):
self.name = name
def __call__(self):
print('My name is %s.' % self.name)
使用枚舉類
之前說到過，Python中其實不存在常量，但是可以通過枚舉類的方式來變通實現。
from enum import Enum
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
for name, member in Month.__members__.items():
print(name, '=>', member, ',', member.value)
from enum import Enum, unique
@unique #@unique裝飾器可以幫助我們檢查保證沒有重復值。
class Weekday(Enum):
Sun = 0 # Sun的value被設定為0
Mon = 1
Tue = 2
Wed = 3
Thu = 4
Fri = 5
Sat = 6
這樣我們就獲得了Month類型的枚舉類，可以直接使用Month.Jan來引用一個常量，或者枚舉它的所有成員。
使用元類
type()
type()函數可以查看一個類型或變量的類型，Hello是一個class，它的類型就是type，而h是一個實例，它的類型就是class Hello。我們說class的定義是運行時動態創建的，而創建class的方法就是使用type()函數。
type()函數既可以返回一個對象的類型，又可以創建出新的類型，比如，我們可以通過type()函數創建出Hello類，而無需通過class Hello(object)…的定義。
>>> def fn(self, name='world'): # 先定義函數
... print('Hello, %s.' % name)
...
>>> Hello = type('Hello', (object,), dict(hello=fn)) # 創建Hello class
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<class 'type'>
>>> print(type(h))
<class '__main__.Hello’>
要創建一個class對象，type()函數依次傳入3個參數：
1.class的名稱；
2.繼承的父類集合，注意Python支持多重繼承，如果只有一個父類，別忘了tuple的單元素寫法；
3.class的方法名稱與函數綁定，這里我們把函數fn綁定到方法名hello上。
通過type()函數創建的類和直接寫class是完全一樣的，因為Python解釋器遇到class定義時，僅僅是掃描一下class定義的語法，然后調用type()函數創建出class。
metaclass
metaclass，直譯為元類，簡單的解釋就是：
當我們定義了類以后，就可以根據這個類創建出實例，所以：先定義類，然后創建實例。
但是如果我們想創建出類呢？那就必須根據metaclass創建出類，所以：先定義metaclass，然后創建類。
# metaclass是類的模板，所以必須從`type`類型派生：
class ListMetaclass(type):
def __new__(cls, name, bases, attrs):
attrs['add'] = lambda self, value: self.append(value)
return type.__new__(cls, name, bases, attires)
參考資料：
1、Python 3 官方文檔