title: python中的類
data: 2018-4-4
categories:

• 類別
  tags:
• 標籤

__metaclass__ = type

class Person:
    def __init__(self, name):
        self.name = name

    def getName(self):
        return self.name

    def color(self, color):
        print('%s is %s' % (self.name, color))

（1）新式類
__metaclass__ = type

（2）定義類
建立了一個叫"Persion“的類，這裡就不廢話了。。。

（3）初始化
def __init__()這個函式比較特殊，叫做初始化函式（有的書上也會稱之為建構函式，但 __new__()才是真的構造）

通過 Person 建立一個例項物件：girl = Person('xuyuling')傳遞一個引數xuyuling

girl 是Person類的一個例項物件，它Person類有屬性和方法。。。。
使用物件的屬性：girl.name
呼叫物件的方法：girl.getName()

def __init__(self, *args):
            pass
 

不一定每次都要從外部傳入引數，可以在函式引數中設定預設值

class Person:
    def __init__(self, name, lang='python', website='youif.cn'):
        self.name = name
        self.lang = lang
        self.website = website

p1 = Person('張三')
p2 = Person('李四', lang='java', website='www.baidu.com')

print('p1name=', p1.name)
print('p2name=', p2.name)
print('p2lang=', p2.lang)
print('p1Web=', p1.website)
print('p2Web=', p2.website)
 

輸出：

----------------
p1name= 張三
p2name= 李四
p2lang= java
p1Web= youif.cn
p2Web= www.baidu.com
----------------------

self 的作用

類的函式裡面，第一個引數是 self ，而且不能省略。但在例項化的時候，這個引數不需要寫，也不需要為這個引數傳值。

以前面的”Person“類為例，在 Person 例項化的過程總 girl = Person('xuyuling')，字串’xuyuling'通過初始化函式（init)的引數已經存入到記憶體中，並且是以 Person 型別，組成了一個物件，這個物件和變數 girl 建立引用關係。

self 其實也是一個例項，這個例項與上面的 girl 一樣，也有屬性。
上述程式碼中：self.name = name， 就是規定了 self 例項的一個屬性，這個是屬性的名字也叫 name，且屬性的值等於初始化函式的引數 name 所匯入的資料。
注意，self.name 中的 name 和初始化函式的引數 name 沒有任何關係，它們兩個一樣。當然，如果寫出 self.xyz = name，也是可以的。

當然，self 的屬性資料，也不一定非得由引數傳入，可以在建構函式中設定。例如：

__metaclass__ = type

class Person:
    def __init__(self, name):
        self.name = name
        self.email = "[email protected]" #這個屬性不是通過引數傳遞的

info = Person('zhong')
print('inofName=', info.name)
print('ifoEmail=', info.email)

輸出結果：

----------------
inofName= zhong
ifoEmail= [email protected]
----------------------

繼承

__metaclass__ = type

class Person:
    def speak(self ):
        print('hello world!')

    def setHeight(self):
        print('一米八')

    def setWeight(self, n):
        print('My weight is :', n)

class Girl(Person):
    def setHeight(self):
        print('一米六')

if __name__ == '__main__':
    xu = Girl()
    xu.setHeight()
    xu.speak()
    xu.setWeight(90)

輸出結果：

----------------
一米六
hello world!
My weight is : 90
--------------------

首先，定義了一個 Person 類，在這個類裡面定義了三個方法。注意，沒有定義初始化函式，初始化函式在類中不是必須的。

然後有自定義了一個 Girl 類，這個類後面的括號裡面是一個類的名字，這句以為著 Girl 類繼承了 Person 類。因此 Girl 類就有了 Person 中的全部方法和屬性。

如果子類中有父類中相同的方法名，那麼，執行的執行的是子類的方法，這樣叫做重寫。

多重繼承

__metaclass__ = type

class Person:
    def eye(self):
        print('two eyes')
    def height(self, n):
        print("一米八")

class Girl:
    age = 20
    def color(self):
        print('The girl is white')

class HotGirl(Person, Girl):
    pass

if __name__ == '__main__':
    kong = HotGirl()
    kong.eye()
    kong.height(90)
    kong.color()
    print(kong.age)

輸出：

--------------------
two eyes
一米八
The girl is white
20
-------------------------

多重繼承的順序

class A1(object):
    def foo(self):
        print("A1-foo")

class A2(object):
    def foo(self):
        print('A2-foo')
    def color(self):
        print('A2-color')

class B1(A1, A2):
    pass

class B2(A1, A2):
    def color(self):
        print('M2-color')

class H(B1, B2):
    pass

if __name__ == '__main__':
    print(H.__mro__)
    s = H()
    s.foo()
    s.color()

輸出：

(<class '__main__.H'>, <class '__main__.B1'>, <class '__main__.B2'>, <class '__main__.A1'>, <class '__main__.A2'>, <class 'object'>)
A1-foo
M2-color

程式碼總的print(G.__mro__)是要打印出類的繼承順序。
即 H --> B1 --> B2 --> A1 --> A2

對繼承屬性和方法搜尋的順序稱之為“廣度優先”。