面向對象的特性：
class
一個類即使對一類擁有相同屬性的對象的抽象，藍圖，原型。類就是模板。在類中定義了這些對象都具備的屬性，共同方法。
object（即叫對象，又叫實例）
一個對象即是一個類的實例化後的實例。一個類必須實例化才能調用。
一個類可以實例化多個對象。
Encapsulation封裝
在類中對數據的賦值，內部調用對外部用戶是透明的，裏面包含着類的數據和方法。
Inheritance 繼承
一個類可以派生出子類，這個父類裏定義的屬性，方法自動被子類繼承。
Polymorphism多態
一個接口，多種實現。
一個基類中派生出不同的子類，且每個子類在繼承了同樣的方法名的同時又對父類的方法做了不同的實現，這就是一種食物表現出的多種形態。
————類，類對象，實例對象
>>>
>>> #類
>>> class C:
count = 0
>>> #類對象
>>> C.count
0
>>> #實例化（相當於造了一個對象，初始化一個類）
>>> c = C()
>>> c.count
0
>>> #構造函數
def __init__(self,...)
#在實例化時做一些類的初始化的工作
實例變量（靜態屬性）：默認先找實例變量，找不到再找類變量
構造函數裏的變量，作用域是實例本身
類變量：
寫在類中，構造函數前的類內部公共變量。節省內存開銷。
類的方法（動態屬性）：
類中的方法，功能
私有方法，私有屬性
外部無法直接訪問，只能內部訪問和修改，只能通過內部方法接口訪問。
對象的特有屬性
類中沒有的公共屬性，對象自行創建的。
析構函數
在實例釋放，銷燬的時候自動執行，通常用於做一些收尾工作，如關閉數據庫，和打開的一些文件。
def __del__(self):
class Dog:
name = 'dodo' #類變量
def __init__(self,name,life):##構造函數
self.name = name ##實例變量（靜態屬性）
self.__life__ = life##私有屬性
def bulk(self):#類方法（動態屬性）
print('%s :wang,wang ,wang' % self.name)
def __run__(self):#私有方法
print('run')
d1 = Dog('drag',100) ##d1是對象（實例化）
d2 = Dog('looss')
d1.bulk()##調用類方法
d2.bulk()————封裝
使用私有屬性私有方法隱藏不需對外部分。
————繼承
格式：
class 子類名（父類名）
子類會重寫父類方法，實現子類特有方法
class Animal:
def __init__(self,name,color):
self.name =name
self.color = color
print('myName %s'% name+'----'+color)
def Howl(self):
print('ahohohoahoho')
def run(self):
print('run fly.....')
class Dog(Animal):
pass
class Cat(Animal):
def Howl(self):
print('miaomiaomoiao....')
d =Dog('dog','yellow')
d.Howl()
d.run()
c = Cat('cat','flower')
c.Howl()
c.run()
=========================== RESTART: G:/animal.py ===========================
myName dog----yellow
ahohohoahoho
run fly.....
myName cat----flower
miaomiaomoiao....
run fly.....
>>> 子類對父類的構造函數重構
先重構，把父類的取過來。單獨寫出子類特有的部分。
class Animal:
name = 'dodo' #類變量
def __init__(self,name,life):##構造函數
self.name = name ##實例變量（靜態屬性）
self.__life__ = life##私有屬性
def bulk(self):#類方法（動態屬性）
print('%s :wang,wang ,wang' % self.name)
def __run__(self):#私有方法
print('run----run----run----')
def go(self):
self.__run__()
class Dog(Animal):
def __init__(self,name,life,color): ##對父類構造函數的重構
Animal.__init__(self,name,life) ##繼承父類共有部分
self.color = color##構造子類特有部分，增加自有屬性
print('%s is:%s' %(self.name,self.color))
def bite(self): ##子類特有方法
print('bite~~')
d1 = Dog('drag',100,'black') ##d1是對象（實例化),傳入父類公共參數的同時，需要傳入子類特有參數
d1.bulk()##調用父類方法
d1.bite() ##調用子類特有方法
d1.go()##通過調用父類go方法而調用父類私有方法__run__子類調用父類的方法，可以：
1/ 調用未綁定的父類方法
綁定概念：Python嚴格要求方法需要有實例才能被調用。
2/使用super函數
————支持多重繼承
>>>
>>> class Base1:
def foo1(self):
print('I am foo1')
>>> class Base2:
def foo2(self):
print('I am foo2')
>>> class C(Base1,Base2):
def foo3(self):
print('I am C!')
>>> c = C()
>>> c.foo1()
I am foo1
>>> c.foo2()
I am foo2
>>> c.foo3()
I am C!
>>> ————多態
一種接口多種實現。多態的作用就是爲了實現一個目的——接口重用。
————靜態方法，類方法，屬性方法
靜態方法：@staticmethod只是在類中的一個函數，實際上跟類沒有了關係，所以也不能調用類變量。@staticmethod 截斷了函數和類的關係。
類方法：@classmethod 類方法只能訪問類變量，不能訪問實例變量
屬性方法：@property 把一個方法變成一個靜態屬性。不用加括號調用。
self是什麼：相當於java的this
————————————————————————————————————
————組合
把類的實例化放到新類裏，新類就把舊類組合進去了
把幾個沒有繼承關係的類放在一起。
class Turtle:
def __init__(self):
self.num = x
class Fish:
def __init__(self):
self.num = y
class Pool:
def __init__(self,x,y):
self.Tuitle = Turtle(x)
self.Fish = Fish(y)
def print_num(self):
print('水池中有烏龜%d只，小魚%d條'% （self.Turtle.num,self.Fish.num）)
————————————————————
———— 一些BIF
issubclass(class,classinfo)
返回True,或者False
第一個參數是第二個參數的子類，返回True
第二個參數可以是一個元組
isinstance(object,classinfo)
返回True,或者False
檢查一個實例對象是否屬於一個類的（第二個參數）。
第二個參數可是類和元組
hasattr(object,name)
返回True,或者False
測試一個對象裏面是否有指定的屬性（第二個參數name是屬性名）
>>>
>>> class C:
def __init__(self,x=0):
self.x=x
>>> c1 =C()
>>> hasattr(c1,'x')
True
>>> 返回對象指定的屬性值，如果指定屬性不存在，返回設置的可選屬性
>>>
>>> class C:
def __init__(self,x=0):
self.x = x
>>> c1 =C()
>>> getattr(c1,'x')
0
>>> getattr(c1,'y','所訪問的屬性不存在')
'所訪問的屬性不存在'
>>> 設定對象中指定屬性的值，如果不存在就新建一個字符串屬性
>>> class C:
def __init__(self,x=0):
self.x = x
>>> c1 =C()
>>> getattr(c1,'x')
0
>>> getattr(c1,'y','所訪問的屬性不存在')
'所訪問的屬性不存在'
>>> setattr(c1,'y','longsi')
>>> getattr(c1,'y')
'longsi'
>>> 刪除對象中指定的屬性，屬性不存在則拋出異常
提供一個對外的接口x，內部屬性的重新設置不影響使用感受
>>>
>>> class C:
def __init__(self,x=0):
self.x = x
>>> c1 =C()
>>> getattr(c1,'x')
0
>>> getattr(c1,'y','所訪問的屬性不存在')
'所訪問的屬性不存在'
>>>
>>> setattr(c1,'y','longsi')
>>> getattr(c1,'y')
'longsi'
>>>
>>> delattr(c1,'y')
>>> 參數（獲取，設置，刪除
通過屬性設置屬性
>>>
>>> class C:
def __init__(self,size=10):
self.size=size
def getSize(self):
return self.size
def setSize(self):
self.size = value
def delSize(self):
del self.size
x = property(getSize,setSize,delSize)
>>> c1 = C()
>>> c1.getSize()
10
>>> c1.x
10