python面向對象

概述：

• 面向過程：根據業務邏輯從上到下寫壘代碼
• 函數式：將某功能代碼封裝到函數中，往後便無需重複編寫，僅調用函數便可
• 面向對象：對函數進行分類和封裝，讓開發「更快更好更強…
• python類在2.7中區分類（經典類和新式類），3.x後再也不使用。

建立類和對象

#定義一個類
class A:
#定義類的函數
    def funa(self):
        pass
    def funb(self,name):
        pass
#定義一個類的對象
obj=A()
obj.funa()
obj.funb('hell word')

self是綁定在類中的，必須有的一個參數。

調用

 

類的特色：

1、封裝

封裝，顧名思義就是將內容封裝到某個地方，之後再去調用被封裝在某處的內容。

因此，在使用面向對象的封裝特性時，須要：

• 將內容封裝到某處
• 從某處調用被封裝的內容

如何封裝：

class A:
    def __init__(self,name,age):
        self.name=name
        self.age=age

obj1=A(name='cai',age=25)
#調用
obj1.name
obj1.age

obj2=A(name='ren',age=24)
obj2.name
obj2.age

self 是一個形式參數

當執行 obj1 = Foo(‘wupeiqi’, 18 ) 時，self 等於 obj1

當執行 obj2 = Foo(‘alex’, 78 ) 時，self 等於 obj2

因此，內容其實被封裝到了對象 obj1 和 obj2 中，每一個對象中都有 name 和 age 屬性，在內存裏相似於下圖來保存。

如何調用：

• 經過對象直接調用

上圖展現了對象 obj1 和 obj2 在內存中保存的方式，根據保存格式能夠如此調用被封裝的內容：對象.屬性名

class A:
    def __init__(self，name,age):
        self.name=name
        self.age=age



#定義一個類的對象       
obj=A(name='jack',age=26)
#直接調用格式：對象加屬性
obj.name

 

• 經過self間接調用

經過self間接調用被封裝的內容，執行類中的方法時，須要經過self間接調用被封裝的內容

class A:
    def __init__(self,age,name):
        self.name=name
        self.age=age
    def show(self):
        print self.name
        print self.age
obj=A(name='jack',age=25)
#間接調用
obj.show()

 

 

 

2.繼承

子類繼承父類

因此，對於面向對象的繼承來講，其實就是將多個類共有的方法提取到父類中，子類僅需繼承父類而沒必要一一實現每一個方法

class animal:
            def eat(self):
      3         print "%s,eat"%self.name
      4     def drink(self):
      5         print "%s,drink"%self.name
      6     def shit(self):
      7         print "%s,shit"%self.name
      8     def pee(self):
      9         print "%s,pee"%self.name
     10 class cat(animal):
     11     def __init__(self,name):
     12         self.name=name
     13         self.bread='cat'
     14     def cry(self):
     15         print "miao miao"
     16 class dog(animal):
     17     def __init__(self,name):
     18         self.name=name
     19         self.bread='dog'
     20     def crazy(self):
     21         print "wang wang"
     22 obj1=cat('cat')
     23 obj1.eat()
     24 obj2=dog('dog')
     25 obj2.eat()
     26 obj3=cat('jack dog')
     27 obj3.eat()

經典類和新式類

那麼問題又來了，多繼承呢？

• 是否能夠繼承多個類
• 若是繼承的多個類每一個類中都定了相同的函數，那麼那一個會被使用呢？

一、Python的類能夠繼承多個類，Java和C#中則只能繼承一個類

二、Python的類若是繼承了多個類，那麼其尋找方法的方式有兩種，分別是：深度優先和廣度優先

• 當類是經典類時，多繼承狀況下，會按照深度優先方式查找
• 當類是新式類時，多繼承狀況下，會按照廣度優先方式查找

那麼如何斷定一個類是經典類仍是新式類？

第一種方法：經典類和新式類，從字面上能夠看出一個老一個新，新的必然包含了跟多的功能，也是以後推薦的寫法，從寫法上區分的話，若是 當前類或者父類繼承了object類，那麼該類即是新式類，不然即是經典類。

第二種方法：

#定義一個經典類，返回值爲classobj
class a:
    pass
#定義一個新式類，新式類集成的參數是類的對象，返回值爲type
class b(object):
    pass
#父是class a，若是他的祖先是class b則是一個新式類；若是他的祖先是class a則爲經典類。
class c(a):
    pass

#經典類的多繼承
class D:
 
    def bar(self):
        print 'D.bar'
 
class C(D):
 
    def bar(self):
        print 'C.bar'
 
class B(D):
 
    def bar(self):
        print 'B.bar'
 
class A(B, C):
 
    def bar(self):
        print 'A.bar'
 
a = A()
# 執行bar方法時
# 首先去A類中查找，若是A類中沒有，則繼續去B類中找，若是B類中麼有，則繼續去D類中找，若是D類中麼有，則繼續去C類中找，若是仍是未找到，則報錯
# 因此，查找順序：A --> B --> D --> C
# 在上述查找bar方法的過程當中，一旦找到，則尋找過程當即中斷，便不會再繼續找了
a.bar()
#新式類的多繼承
class D(object):
 
    def bar(self):
        print 'D.bar'
 
class C(D):
 
    def bar(self):
        print 'C.bar'
 
class B(D):
 
    def bar(self):
        print 'B.bar'
 
class A(B, C):
 
    def bar(self):
        print 'A.bar'
 
a = A()
# 執行bar方法時
# 首先去A類中查找，若是A類中沒有，則繼續去B類中找，若是B類中麼有，則繼續去C類中找，若是C類中麼有，則繼續去D類中找，若是仍是未找到，則報錯
# 因此，查找順序：A --> B --> C --> D
# 在上述查找bar方法的過程當中，一旦找到，則尋找過程當即中斷，便不會再繼續找了
a.bar()

 

類的定義

屬性和方法定義

屬性

類的屬性和實例的屬性

class Chinese（person）:
    nation=china#類的屬性，共有的
def __init__(self,name):
    self.name=name#實力屬性，特殊的，因個體不一樣而變化的

 

屬性的可見性：

共有屬性

私有屬性，Python並無真正的私有屬性。

私有屬性的定義：__name更名換姓；_name，意義在於喚起用戶注意

class chinese:
    nation='chian'
    def __init__(self,id,name):
        self._id=id#沒有換名字，沒有改變，直接用self._id調取，但不可以改變內容
        self.__name=name#沒有被保護，可用.__dict__查看，只是更名字，能夠改變內容
    def fun(self,msg):
        print self.__name,msg

訪問屬性

直接訪問，不推薦，由於函數已經被封裝

自定義get讀操做，set寫方法

經過屬性裝飾器

@property

@***seter

@***delet

#!/user/bin/python
#-*-coding:utf-8-*-
class a:
     nation='china'
    def __init__(self,id,name):
        self._id=id
         self.__name=name
    def func(self,msg):
         print self.__name,msg
    def getid(self):
          return self._id
    def setid(self,id):
        self._id=id
     @property
      def name(self):
           return self.__name
      @name.setter
     def name(self,name):
          self.__name=name
     @name.deleter
        def name(self):
           del self.__name