天天看點
傳回

Python 進階（四）類的繼承

Python 進階（四）類的繼承
Python 進階（四）類的繼承
Python 進階（四）類的繼承
Python 進階（四）類的繼承
Python 進階（四）類的繼承
Python 進階（四）類的繼承
Python 進階（四）類的繼承
Python 進階（四）類的繼承
Python 進階（四）類的繼承
Python 進階（四）類的繼承
Python 進階（四）類的繼承

繼承一個類

如果已經定義了Person類，需要定義新的Student和Teacher類時，可以直接從Person類繼承：

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

定義Student類時，隻需要把額外的屬性加上，例如score：

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

一定要用 super(Student, self).__init__(name, gender) 去初始化父類，否則，繼承自 Person 的 Student 将沒有 name 和 gender。

函數super(Student, self)将傳回目前類繼承的父類，即 Person ，然後調用__init__()方法，注意self參數已在super()中傳入，在__init__()中将隐式傳遞，不需要寫出（也不能寫）。

任務

請參考 Student 類，編寫一個 Teacher類，也繼承自 Person。

Python 進階（四）類的繼承

判斷類型

函數isinstance()可以判斷一個變量的類型，既可以用在Python内置的資料類型如str、list、dict，也可以用在我們自定義的類，它們本質上都是資料類型。

假設有如下的 Person、Student 和 Teacher 的定義及繼承關系如下：

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

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score

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

p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
t = Teacher('Alice', 'Female', 'English')

當我們拿到變量 p、s、t 時，可以使用 isinstance 判斷類型：

>>> isinstance(p, Person)
True    # p是Person類型
>>> isinstance(p, Student)
False   # p不是Student類型
>>> isinstance(p, Teacher)
False   # p不是Teacher類型

這說明在繼承鍊上，一個父類的執行個體不能是子類類型，因為子類比父類多了一些屬性和方法。

我們再考察 s ：

>>> isinstance(s, Person)
True    # s是Person類型
>>> isinstance(s, Student)
True    # s是Student類型
>>> isinstance(s, Teacher)
False   # s不是Teacher類型

s 是Student類型，不是Teacher類型，這很容易了解。但是，s 也是Person類型，因為Student繼承自Person，雖然它比Person多了一些屬性和方法，但是，把 s 看成Person的執行個體也是可以的。

這說明在一條繼承鍊上，一個執行個體可以看成它本身的類型，也可以看成它父類的類型。

任務

請根據繼承鍊的類型轉換，依次思考 t 是否是 Person，Student，Teacher，object 類型，并使用isinstance()判斷來驗證您的答案。

Python 進階（四）類的繼承

多态

類具有繼承關系，并且子類類型可以向上轉型看做父類類型，如果我們從 Person 派生出 Student和Teacher ，并都寫了一個 whoAmI() 方法：

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def whoAmI(self):
        return 'I am a Person, my name is %s' % self.name

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
    def(self):
        return 'I am a Student, my name is %s' % self.name

class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course
    def(self):
        return 'I am a Teacher, my name is %s' % self.name

在一個函數中，如果我們接收一個變量 x，則無論該 x 是 Person、Student還是 Teacher，都可以正确列印出結果：

def who_am_i(x):
    print x.whoAmI()      
p = Person('Tim', 'Male') 
s = Student('Bob', 'Male', 88) 
t = Teacher('Alice', 'Female', 'English') 

who_am_i(p) 
who_am_i(s) 
who_am_i(t)

運作結果：

I am a Person, my name is Tim
I am a Student, my name is Bob
I am a Teacher, my name is Alice

這種行為稱為多态。也就是說，方法調用将作用在 x 的實際類型上。s 是Student類型，它實際上擁有自己的 whoAmI()方法以及從 Person繼承的 whoAmI方法，但調用 s.whoAmI()總是先查找它自身的定義，如果沒有定義，則順着繼承鍊向上查找，直到在某個父類中找到為止。

由于Python是動态語言，是以，傳遞給函數 who_am_i(x)的參數 x 不一定是 Person 或 Person 的子類型。任何資料類型的執行個體都可以，隻要它有一個whoAmI()的方法即可：

class Book(object):
    def whoAmI(self):
        return 'I am a book'

這是動态語言和靜态語言（例如Java）最大的差别之一。動态語言調用執行個體方法，不檢查類型，隻要方法存在，參數正确，就可以調用。

任務

Python提供了open()函數來打開一個磁盤檔案，并傳回 File 對象。File對象有一個read()方法可以讀取檔案内容：

例如，從檔案讀取内容并解析為JSON結果：

import json
f = open('/path/to/file.json', 'r')
print json.load(f)

由于Python的動态特性，json.load()并不一定要從一個File對象讀取内容。任何對象，隻要有read()方法，就稱為File-like Object，都可以傳給json.load()。

請嘗試編寫一個File-like Object，把一個字元串 r'["Tim", "Bob", "Alice"]'包裝成 File-like Object 并由 json.load() 解析。

Python 進階（四）類的繼承

# -*- coding: UTF-8 -*-

class Person(object):

    def __init__(self, name, gender):

        self.name = name

        self.gender = gender

    def whoAmI(self):

        return 'I am a Person, my name is %s' % self.name

class Student(Person):

    def __init__(self, name, gender, score):

        super(Student, self).__init__(name, gender)

        self.score = score

    def whoAmI(self):

        return 'I am a Student, my name is %s' % self.name

class Teacher(Person):

    def __init__(self, name, gender, course):

        super(Teacher, self).__init__(name, gender)

        self.course = course

    def whoAmI(self):

        return 'I am a Teacher, my name is %s' % self.name

p = Person('Tim', 'Male')

s = Student('Bob', 'Male', 88)

t = Teacher('Alice', 'Female', 'English')

print p.whoAmI()

print s.whoAmI()

print t.whoAmI()

運作輸出結果：

I am a Person, my name is Tim

I am a Student, my name is Bob

I am a Teacher, my name is Alice

多重繼承

除了從一個父類繼承外，Python允許從多個父類繼承，稱為多重繼承。

多重繼承的繼承鍊就不是一棵樹了，它像這樣：

class A(object):
    def __init__(self, a):
        print 'init A...'
        self.a = a

class B(A):
    def __init__(self, a):
        super(B, self).__init__(a)
        print 'init B...'

class C(A):
    def __init__(self, a):
        super(C, self).__init__(a)
        print 'init C...'

class D(B, C):
    def __init__(self, a):
        super(D, self).__init__(a)
        print 'init D...'

看下圖:

​​

Python 進階（四）類的繼承

​​

像這樣，D 同時繼承自 B 和 C，也就是 D 擁有了 A、B、C 的全部功能。多重繼承通過 super()調用__init__()方法時，A 雖然被繼承了兩次，但__init__()隻調用一次：

>>> d = D('d')
init A...
init C...
init B...
init D...

多重繼承的目的是從兩種繼承樹中分别選擇并繼承出子類，以便組合功能使用。

舉個例子，Python的網絡伺服器有TCPServer、UDPServer、UnixStreamServer、UnixDatagramServer，而伺服器運作模式有 多程序ForkingMixin 和 多線程ThreadingMixin兩種。

要建立多程序模式的 TCPServer：

class MyTCPServer(TCPServer, ForkingMixin)
    pass

要建立多線程模式的 UDPServer：

class MyUDPServer(UDPServer, ThreadingMixin):
    pass

如果沒有多重繼承，要實作上述所有可能的組合需要 4x2=8 個子類。

任務

+-Person

  +- Student

  +- Teacher

是一類繼承樹；

+- SkillMixin

   +- BasketballMixin

   +- FootballMixin

是一類繼承樹。

通過多重繼承，請定義“會打籃球的學生”和“會踢足球的老師”。

Python 進階（四）類的繼承

擷取對象資訊

拿到一個變量，除了用 isinstance() 判斷它是否是某種類型的執行個體外，還有沒有别的方法擷取到更多的資訊呢？

例如，已有定義：

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

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
    def whoAmI(self):
        return 'I am a Student, my name is %s' % self.name

首先可以用 type() 函數擷取變量的類型，它傳回一個 Type 對象：

>>> type(123)
<type 'int'>
>>> s = Student('Bob', 'Male', 88)
>>> type(s)
<class '__main__.Student'>

其次，可以用 dir() 函數擷取變量的所有屬性：

>>> dir(123)   # 整數也有很多屬性...
['__abs__', '__add__', '__and__', '__class__', '__cmp__', ...]

>>> dir(s)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'gender', 'name', 'score', 'whoAmI']

對于執行個體變量，dir()傳回所有執行個體屬性，包括`__class__`這類有特殊意義的屬性。注意到方法`whoAmI`也是 s 的一個屬性。

如何去掉`__xxx__`這類的特殊屬性，隻保留我們自己定義的屬性？回顧一下filter()函數的用法。

dir()傳回的屬性是字元串清單，如果已知一個屬性名稱，要擷取或者設定對象的屬性，就需要用 getattr() 和 setattr( )函數了：

>>> getattr(s, 'name') 'Bob'

>>> setattr(s, 'name', 'Adam') 
>>> s.name
'Adam'

>>> getattr(s, 'age')  # 擷取age屬性，但是屬性不存在，報錯：
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'age'

>>> getattr(s, 'age', 20)  # 擷取age屬性，如果屬性不存在，就傳回預設值20：
20

任務

對于Person類的定義：

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

希望除了 name和gender 外，可以提供任意額外的關鍵字參數，并綁定到執行個體，請修改 Person 的 __init__()定 義，完成該功能。

傳入**kw 即可傳入任意數量的參數，并通過 setattr() 綁定屬性。

Python 進階（四）類的繼承
Python 父類 多重繼承 json
上一篇: TVM：Python 建立 Relay 表達式
下一篇: 自學Python5.3-類和對象的簡單操作

繼續閱讀