提前說一點：如果你是專注于Python開發，那么本系列知識點只是帶你入個門再詳細的開發點就要去看其他資料了，而如果你和作者一樣只是操作其他技術的Python API那就足夠了。
Python是一個完全面向對象開發的語言，它的一切都以對象的方式操作
類(Class): 用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。
類變量：類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數體之外。類變量通常不作為實例變量使用。
數據成員：類變量或者實例變量, 用于處理類及其實例對象的相關的數據。
方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆蓋（override），也稱為方法的重寫。
局部變量：定義在方法中的變量，只作用于當前實例的類。
實例變量：在類的聲明中，屬性是用變量來表示的。這種變量就稱為實例變量，是在類聲明的內部但是在類的其他成員方法之外聲明的。
繼承：即一個派生類（derived class）繼承基類（base class）的字段和方法。繼承也允許把一個派生類的對象作為一個基類對象對待。例如，有這樣一個設計：一個Dog類型的對象派生自Animal類，這是模擬"是一個（is-a）"關系（例圖，Dog是一個Animal）。
實例化：創建一個類的實例，類的具體對象。
方法：類中定義的函數。
對象：通過類定義的數據結構實例。對象包括兩個數據成員（類變量和實例變量）和方法。
定義一個類的語法如下，注意如果你用的是Python2，那么不要寫objeck，不然會報錯的
class ClassName(objeck):'類的幫助信息' #類文檔字符串class_suite #類體#類的實例方法def aaa(self) :return
實例化類，生成對象語法如下
變量名 = 類名() ---不需要其他語言那樣的new
Python的類里面，和其他語言不同的就是，有時方法中會多一個 self，這個變量你要使用的時候，一般都是放在第一個參數位，并且代表對象本身，下面這個例子可以解釋這一點
class Test:def prt(self):print(self)t = Test()
print(t)
t.prt()結果發現指向的都是同一個對象：
<__main__.Test instance at 0x10d066878>
<__main__.Test instance at 0x10d066878>
切記：對于 self 本身來說，它不是一個定死的關鍵字，我們換成其他的名字也可以，只是在開發中我們按照慣例，把它寫在了第一個參數位，并且起名為 self ，它本身其實是和JAVA的this對象等價的，只不過Python需要在參數位聲明一下而已
而且當你使用了self的時候，在傳遞參數時，不需要在意它的值，因為可以自動補齊，如下
class Test :def fun_name(self,b,c):print(b+str(c))a = Test()
a.fun_name('忽略self正常傳參',21)
結果：忽略self正常傳參21
對于Python的類來說，也是擁有屬性的，我們在類的內部，類實體方法的外部，書寫屬性即可，但是切記在類中書寫屬性的時候一定要給一個初值，不然訪問的時候會報錯
class Test :age = ''def fun_test():print('llll')
在使用這個類創建對象之后，對象會擁有類的所有東西，屬性自然也包括其中，調用時語法如下，這一點在Python中叫做 “類外面獲取對象屬性”
對象名.屬性名 #調用獲取
對象名.屬性名 = 值 #修改
但是注意，Python允許一個對象擁有屬于自己的屬性，這種屬性不需要在類中定義，直接使用對象調用就可以，會自動生成一個數據這個對象自己的屬性，其他對象沒有，下面這個例子可以解釋這一點，這一點在Python中也叫做 “類外面添加對象屬性”
class Test :def fun_name():print('llll')a = Test()
b = Test()a.age = '12'
print(a.age)
print(b.age)結果會報錯，提示對象b沒有age屬性：
12
Traceback (most recent call last):File "main.py", line 12, in <module>print(b.age)
AttributeError: Test instance has no attribute 'age'
這個時候有的小伙伴可能就會疑惑，有類外面獲取對象屬性、類外面添加對象屬性，這兩點都聚焦在對象的身上，和類的關系不是很明顯，其實Python還有最后一種相關操作，叫做“在類內部獲取對象屬性”，對于這一點，個人認為其實是Python提供給我們開發者的一種輔助，防止我們由于其他因素導致訪問不到對象的屬性，比如被局部變量或者其他變量干擾，操作方式如下
class Test :age = 12def fun_name(self):print(self.age)a = Test()
a.fun_name()
其實就是self的應用，不過注意，這種操作可以和類外部添加屬性那樣直接調用一個原先沒有的屬性
class Test :def fun_name(self):print(self.age)a = Test()
a.age = 10
a.fun_name()
現在我猜測大家或許會混亂，沒關系，記住核心的一點：在Python中，可以像常規那樣使用對象和類，只是Python除此之外，允許一個屬性在使用的時候，是從無到有的，也就是沒有被預先定義的
其實對于self來說，它不止可以調用我們自己定義的屬性，它還帶有著其他的東西，有興趣大家可以在其他地方找一找資料，比如可以獲取對象實例化的類名
class Test :def fun_name(self):print(self.__class__)a = Test()
a.fun_name()結果：__main__.Test
對于對象的屬性，Python其實有著其他的方式可以調用
getattr(obj, name[, default]) : 訪問對象的屬性。
hasattr(obj,name) : 檢查是否存在一個屬性。
setattr(obj,name,value) : 設置一個屬性。如果屬性不存在，會創建一個新屬性。
delattr(obj, name) : 刪除屬性。hasattr(emp1, 'age') # 如果存在 'age' 屬性返回 True。
getattr(emp1, 'age') # 返回 'age' 屬性的值
setattr(emp1, 'age', 8) # 添加屬性 'age' 值為 8
delattr(emp1, 'age') # 刪除屬性 'age'
Python類的本身其實也有自帶的被規定的屬性，俗稱類屬性，為什么說它被規定呢？這個后面我會解釋
調用的時候用 類名.類屬性 就可以了__dict__ : 類的屬性（包含一個字典，由類的數據屬性組成）
__doc__ :類的文檔字符串
__name__: 類名
__module__: 類定義所在的模塊
__bases__ : 類的所有父類構成元素（包含了一個由所有父類組成的元組）
有意思的是我們通過類名可以直接將自己定義的屬性獲取到，這個時候，這個屬性也叫做類屬性
下面我們了解一下，在Python中對象是如何被垃圾回收的
在Python中只有一種垃圾回收機制，就是引用計數法，在 Python 內部記錄著所有使用中的對象各有多少引用。
一個內部跟蹤變量，稱為一個引用計數器。
當對象被創建時， 就創建了一個引用計數， 當這個對象不再需要時， 也就是說， 這個對象的引用計數變為0 時， 它被垃圾回收。但是回收不是"立即"的， 由解釋器在適當的時機，將垃圾對象占用的內存空間回收。
垃圾回收機制不僅針對引用計數為0的對象，同樣也可以處理循環引用的情況。循環引用指的是，兩個對象相互引用，但是沒有其他變量引用他們。這種情況下，僅使用引用計數是不夠的。Python 的垃圾收集器實際上是一個引用計數器和一個循環垃圾收集器。作為引用計數的補充， 垃圾收集器也會留心被分配的總量很大（即未通過引用計數銷毀的那些）的對象。 在這種情況下， 解釋器會暫停下來， 試圖清理所有未引用的循環，其實說白了就是有a、b兩個對象，它們獨立與其他對象，產生較為單獨的一對相互引用關系，這種對象時間長了，也會被回收掉
特別注意一個對象被回收時，會調用它的__del__方法，這個方法是用來回收對象的，但大家不要糾結，后面我會單獨說這種有四個下滑線的方法，是干什么的
下面我們來了解一下類的繼承，類繼承語法如下
class 派生類名(基類名):...
Python的類繼承的時候，和其他語言一樣有著注意點：
1、如果在子類中需要父類的構造方法就需要顯式的調用父類的構造方法，或者不重寫父類的構造方法。實例如下
當你沒有重寫構造方法時：
class Father():def __init__(self, name):self.name=namedef getName(self):return 'Father ' + self.nameclass Son(Father):def getName(self):return 'Son '+self.nameson=Son('runoob')
print ( son.getName() )結果：Son runoob
從結果中你可以發現，傳入的name值作用在了父類的構造器上-----------------------------------------------------------------------------
當你重寫了子類的構造方法，但是沒有調用父類的時候：
class Father():def __init__(self, name):self.name=namedef getName(self):return 'Father ' + self.nameclass Son(Father):def __init__(self, name):print ( "hi" )self.name = namedef getName(self):return 'Son '+self.nameson=Son('runoob')
print ( son.getName() )結果：
hi
Son runoob
從結果來看，發現并沒有調用父類的構造方法------------------------------------------------------------
當你重寫了子類的構造方法，并調用了父類的構造方法時：
class Father():def __init__(self, name):self.name = nameprint("這里是父類")class Son(Father):def __init__(self, name):#第一種調用方法：super(Son, self).__init__(name)#第二種調用方法：Father.__init__(self,name)print ("hi")self.name = namedef getName(self):return 'Son '+self.nameson=Son('runoob')
print ( son.getName() )
結果：
這里是父類
hi
Son runoob
2、在調用基類的方法時，基類的方法必須有self參數，不然無法執行，對于這一點其實大家養成寫方法參數要帶上self的習慣就可以了
基類沒有self：
class Father():def __init__(self, name):self.name = namedef nnn():print('父類方法')class Son(Father):def __init__(self, name):Father.__init__(self,name)self.name = nameson=Son('runoob')
son.nnn()
結果報錯：
Traceback (most recent call last):File "main.py", line 17, in <module>son.nnn()
TypeError: nnn() takes no arguments (1 given)----------------------------------------------------------------
基類有self
class Father():def __init__(self, name):self.name = namedef nnn(self):print('父類方法')class Son(Father):def __init__(self, name):Father.__init__(self,name)self.name = nameson=Son('runoob')
son.nnn()
結果：父類方法
3、Python 總是首先查找對應類型的方法，如果它不能在派生類中找到對應的方法，它才開始到基類中逐個查找。（先在本類中查找調用的方法，找不到才去基類中找）。
值得高興的是Python支撐多繼承
class A: # 定義類 A
.....class B: # 定義類 B
.....class C(A, B): # 繼承類 A 和 B
.....
還提供了兩個檢查函數
issubclass() 布爾函數判斷一個類是另一個類的子類或者子孫類，語法：issubclass(子類,父類)
isinstance(obj, Class) 布爾函數如果obj是Class類的實例對象或者是一個Class子類的實例對象則返回true
Python也支持多態，在重寫父類方法的時候也要注意self
class Father():def __init__(self, name):self.name = namedef nnn(self):print('父類方法')class Son(Father) :def __init__(self, name) :Father.__init__(self,name)self.name = namedef nnn(self,age) :print('子類方法' + str(age))def nnn(self,age,ppp) :print('子類方法' + str(age) + str(ppp))a = Son('Tom')
a.nnn(10)
a.nnn(10,20)
結果：
子類方法10
子類方法1020
如果看了我寫的公共方法篇，一定知道加法是合并的意思，而有趣的是Python的對象也支持這樣的操作，不過想要對象之間執行合并你需要重寫__add__方法
class Vector:def __init__(self, a, b):self.a = aself.b = bdef __str__(self):return 'Vector (%d, %d)' % (self.a, self.b)def __add__(self,other):return Vector(self.a + other.a, self.b + other.b)v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2
結果：Vector (7, 8)
值得一提的是，在Python中類也是有靜態方法的
class Father():def __init__(self, name):self.name = name@staticmethoddef nnn(self):print('靜態方法')Father.nnn()
a = Father('Tom')
a.nnn()
