1：類和對象
是面向對象中的倆個重要概念，類是對事物的抽象，比如人類，球類。對象是事物的執行個體，比如足球，籃球。球類可以對球的特征和行為進行抽象，然後可以執行個體化一個真實的球體出來。
2：類的定義
類把需要的變量和函數組合成一起，這種包含稱為“封裝”。。classA（object）：
3：類的結構
class類名：
成員變量-屬性 ## 類的屬性是對資料的封裝
成員函數-方法 ## 類的方法是對類的行為進行封裝
類的建立：
class MyClass1(object): ## 類名
color = 'Black' ## 類的屬性-變量
def fun(self): ## 類的方法中必須有參數self，這是成員函數類的方法
print "I am function"
#!/usr/bin/python
class People():
color = 'yellow' ## 成員變量
def think(self): ## 成員函數
self.color = 'Black' ## self表示類本身
print 'I am a %s' % self.color
print 'I am a thinker'
ren = People() ## 把類賦予一個變量，即執行個體化
print ren.color
ren.think() 複制
4：類的屬性
公有屬性：在類中類外都可以使用。
私有屬性：隻能在類中使用，定義方式為__name（雙下劃線）
内置屬性：由系統定義類的時候預設添加的，由前後雙下劃線構成。__dict__,__module__。
#!/usr/bin/python
class People():
color = 'yellow'
__age = 20
def think(self):
self.color = 'Black'
print 'I am a %s' % self.color
print 'I am a thinker'
print self.__age ## 私有函數，隻能在類中使用
ren = People()
print ren.color
ren.think()
print ren._People__age ## 僅測試使用，類外使用私有函數 複制
5：類的方法相當于函數，類的屬性相當于變量。
方法的定義跟函數一樣，但是需要self作為第一個參數。
公有方法：跟公有屬性一樣，類内類外都可以使用
私有方法：跟私有屬性一樣，隻能類内使用。__self
self：用來區分類跟方法，self本身表示類
類方法：被classmethod編譯過的函數，能被類所調用，也能被對象調用（繼承的關系）
靜态方法：被staticmethod編譯過的函數，可以被類直接調用，靜态方法不需要設定self參數。
裝飾器：
@classmethod：類方法
@staticmethod：靜态方法
6：對象的建立
建立對象的過程稱之為執行個體化：當一個對象被建立後，包含三個方面的特性：對象句柄，屬性，方法。句柄用來區分對象。
對象的屬性和方法與類中的成員變量和成員函數相對應
object=MyClass() ## 建立類的一個執行個體（對象），通過對象來調用方法和屬性
#!/usr/bin/python
# coding:utf-8
class MyClass1(object): ## 類
color = 'Yellow' ## 類的屬性--變量
__age = 20 ## 類的私有屬性，隻能在類中使用
@classmethod
def __hide(self): ## 類的隐藏方法，隻能在類中使用
print "I am hidemethods!"
@classmethod ## 裝飾，對象和類都可以調用
def fun(self): ## 類的方法--函數
print self.__age ## self等同類，表示調用類的私有屬性
print 'This is function!'
@staticmethod ## 裝飾，對象和類都能調用，不需要self
def fun1(): ## 不需要self
print MyClass1.color ## 直接使用類調用類的屬性或方法
MyClass1.__hide() ## 調用類的隐藏方法
class InsideClass(object): ## 類中類，内部類
Inside = 'Red' ## 内部類的屬性
@classmethod
def InsideFun(self): ## 内部類的方法
print self.Inside
object = MyClass1() ## 對象，執行個體化類
object.fun() ## 對象調用類的方法
MyClass1.fun() ## 類調用類的方法
MyClass1.fun1()
object_inside = object.InsideClass() ## 先調用外部類，再調用内部類
MyClass1.InsideClass.InsideFun() ## 調用内部類的方法
print object_inside.Inside ## 調用内部類的屬性 複制
7：内部方法（魔術方法）
def __str__(self): ## 如果直接執行個體化類，會傳回__str__的值，而不是提示這樣<對象>
return "This is class object!"
構造函數
def __init__(self,c='Black'): ## 初始化對象的屬性，但不會改變類的屬性
self.color = c
析構函數
def __del__(self): ## 主要用于釋放資源，一般執行與腳本的最後
#!/usr/bin/python
class PeoPle(object):
color = 'Black'
def __init__(self,c): ## 初始化屬性，c需要在執行個體化類的時候，跟在後面
self.color = c
print "Init runinng ......" ## 隻要把類執行個體化成對象，就會列印這行，
def fun1(self):
print "Color is: %s" % self.color
pe = PeoPle('Red')
print "Object print is: %s" %pe.color ## __init__會影響對象的屬性
print "Class print is: %s" %PeoPle.color ## 類不會受__init__的影響 複制
類的繼承：
單類繼承
#!/usr/bin/python
class PeoPle(object):
color = 'Black'
def __init__(self,c): ## 初始化參數
self.color = c
print "Init runinng ......"
@classmethod ## 裝飾方法，使其對象和類都可以調用
def fun1(self):
print "Color is: %s" % self.color
class MyClass(PeoPle): ## 繼承父類PeoPle
color = 'MyClass'
def __init__(self):
PeoPle.__init__(self.'Red') ## 表示繼承父類的__init__構造函數。
@classmethod
def fun1(self):
print "This is MyClass the function"
pass
my=MyClass() ## 由于MyClass類中繼承過PeoPle裡的__init__參數。
print MyClass.color ## 優先傳回MyClass裡的屬性
my.fun1() ## 優先傳回MyClass裡的方法
PeoPle.fun1() ## 傳回PeoPle裡的fun1方法
MyClass.fun1() ## 傳回MyClass裡的fun1方法
pe = PeoPle('Green') ## 由于PeoPle初始化__init__那裡需要倆個參數，是以這裡要加一個參數
print "Object print is: %s" % pe.color ## 列印初始化後對象的屬性即Green
print "Class print is: %s" % PeoPle.color ## 列印類屬性即Black 複制
多類繼承：
#!/usr/bin/python
class PeoPle(object):
def __init__(self):
self.dwell = 'Earth'
self.color = 'Yellow'
def think(self):
print "I dwell am %s!" % self.dwell
class Chinese(object):
color = 'Black'
def __init__(self):
self.dwell = 'China'
def think(self):
print "I am chinese %s " % self.color
class MyClass(Chinese,PeoPle): ## 預設首先繼續第一個類的屬性跟方法
def __init__(self):
PeoPle.__init__(self) ## 表示使用指定類的屬性
pass
my = MyClass()
my.think() ## 傳回I am Chinese Yellow 複制
類的屬性---總結
- 類屬性（公有屬性）： 可以在類中使用，相當于變量。
- 類私有屬性（私有屬性）： 隻能函數中使用，無法被對象調用
- 對象的公有屬性： 對象可以調用
- 對象的私有屬性： 隻能類中調用
- 内置屬性：
- 函數的局部變量： 隻能在本函數中使用
- 函數的全局變量： 可以在類中所有的函數裡使用
#!/usr/bin/python
# coding:utf8
val6 = "全局變量"
print '*' * 50
class My(object):
val1 = "類的公有屬性 val1"
__val2 = "類的私有屬性 __val2"
def fun(self):
self.val3 = "對象的公有屬性 val3"
self.__val4 = "對象的私有屬性 __val4"
val5 = "函數的局部變量,隻能在本函數使用"
global val6
val6 = "函數的全局變量,可以在類中所有的函數中使用"
def fun1(self):
print val6
my = My()
print my.val1
print my._My__val2
my.fun()
print '*' * 50
my.fun1() 複制
類的方法總結：
- 公有方法：
- 私有方法：
- 類方法：
- 靜态方法：
- 内置方法：
#!/usr/bin/python
#-*- coding:utf8 -*_
class MyClass(object):
name = 'Warning'
def __init__(self):
self.fun1()
self.__fun2()
self.fun3()
self.fun4()
def fun1(self):
print "%s %s" % (self.name,'我是公有方法')
def __fun2(self):
print "%s %s" % (self.name,'我是私有方法')
@classmethod
def fun3(self):
print "%s %s" % (self.name,'我是類方法')
@staticmethod
def fun4():
print "%s %s" % (MyClass.name,'我是靜态方法')
my = MyClass()
my.fun1() ## 調用公有方法
MyClass.fun3() ## 調用類方法
MyClass.fun4() ## 調用靜态方法，注意靜态方法不需要self,與類方法的差別 複制