一 多態和多態性

1 什麽是多態：多態就是一種失誤的多種形態。（例如：水有冰的形態，還有水蒸氣的形態等等）一個抽象類有多個子類，因而多態的概念依賴於繼承。

序列類型有多種形態：字符串，列表，元組。

動物有多種形態：人，狗，豬

 1 import abc
 2 class Animal(metaclass=abc.ABCMeta): #同一類事物:動物
 3     @abc.abstractmethod
 4     def talk(self):
 5         pass
 6 
 7 class People(Animal): #動物的形態之一:人
 8     def talk(self):
 
 9         print(‘say hello‘)
10 
11 class Dog(Animal): #動物的形態之二:狗
12     def talk(self):
13         print(‘say wangwang‘)
14 
15 class Pig(Animal): #動物的形態之三:豬
16     def talk(self):
17         print(‘say aoao‘)

文件有多種形態：文本文件，可執行文件

 1 import abc
 2 class File(metaclass=abc.ABCMeta): #同一類事物:文件
 

 3     @abc.abstractmethod
 4     def click(self):
 5         pass
 6 
 7 class Text(File): #文件的形態之一:文本文件
 8     def click(self):
 9         print(‘open file‘)
10 
11 class ExeFile(File): #文件的形態之二:可執行文件
12     def click(self):
13         print(‘execute file‘)

2 什麽是多態性

多態性是指具有不同函數的功能可以使用同一個函數名，也就是同一個函數名可以調用不同功能的函數。面向對象中是怎麽表示多態性的：給不同的對象發送同一條信息，而不同對象在接收到信息後不同的行為或方法。也就是說每一個對象用自己的方式去響應共同的調用函數。不同的行為是指不同的實現，即不同的函數。

比如：老師.下課鈴響了（），學生.下課鈴響了()，老師執行的是下班操作，學生執行的是放學操作，雖然二者消息一樣，但是執行的效果不同

多態性分為靜態多態性和動態多態性

靜態多態性：如任何類型都可以用運算符+進行運算

動態多態性：如下1

2

 1 >>> def func(animal): #參數animal就是對態性的體現
 2 ...     animal.talk()
 3 ... 
 4 >>> people1=People() #產生一個人的對象
 5 >>> pig1=Pig() #產生一個豬的對象
 6 >>> dog1=Dog() #產生一個狗的對象
 7 >>> func(people1) 
 8 say hello
 9 >>> func(pig1)
10 say aoao
11 >>> func(dog1)
12 say wangwang

3

1 >>> def func(f):
2 ...     f.click()
3 ... 
4 >>> t1=Text()
5 >>> e1=ExeFile()
6 >>> func(t1)
7 open file
8 >>> func(e1)
9 execute file

綜上我們也可以說，多態性是‘一個接口（函數func），多種實現（如f.click()）’

3為什麽要用多態性（多態性的好處）

python本身就是支持多態性的

多態性的好處：1.增加了程序的靈活性：不管對象怎麽變化，使用者都可以用同一種形式去調用它

2增加了程序額可擴展性：通過繼承類創建了一個新的類，使用者無需更改自己的代碼，還是用函數名(類名)去調用

 1 >>> class Cat(Animal): #屬於動物的另外一種形態：貓
 2 ...     def talk(self):
 3 ...         print(‘say miao‘)
 4 ... 
 5 >>> def func(animal): #對於使用者來說，自己的代碼根本無需改動
 6 ...     animal.talk()
 7 ... 
 8 >>> cat1=Cat() #實例出一只貓
 9 >>> func(cat1) #甚至連調用方式也無需改變，就能調用貓的talk功能
10 say miao
11 
12 ‘‘‘
13 這樣我們新增了一個形態Cat，由Cat類產生的實例cat1，使用者可以在完全不需要修改自己代碼的情況下。使用和人、狗、豬一樣的方式調用cat1的talk方法，即func(cat1)
14 ‘‘‘

二 綁定方法和非綁定方法

類中定義的函數分為了兩大類：

1 綁定方法：綁定給誰，誰來調用就會自動的將它本身當作第一個參數被傳入。

綁定到類的方法：classmethod裝飾器是專門給類定制的

　　　　類.函數名()：類名會被自動當作第一個參數被傳入。而對象調用時，也是將類名當作第一個參數被傳入。

屬於類的函數，類可以調用，但是沒有自動傳值。

classmehtod

 1 # class People:
 2 #     def __init__(self,name):
 3 #         self.nam=name
 4 #     def bar(self):
 5 #         print(self.name)
 6 #     @classmethod
 7 #     def func(cls):
 8 #         print(cls)
 9 # t=print(‘egon‘)
10 # print(t.bar)
11 # People.func()
12 #

綁定給對象的方法：沒有被任何裝飾器給裝飾，為對象專門定制的。

對象名.函數名()，而對象會被自動當中第一個參數給傳入。

2 非綁定方法：用staticmethod裝飾器來裝飾的。

不與類或對象綁定，但是他們都可以調用。但是沒有傳值，只是一個普通的工具。

註意：與綁定到對象方法區分開，在類中直接定義的函數，沒有被任何裝飾器裝飾的，都是綁定到對象的方法，可不是普通函數，對象調用該方法會自動傳值，而staticmethod裝飾的方法，不管誰來調用，都沒有自動傳值一說

statimethod不與類或對象綁定，誰都可以調用，沒有自動傳值效果，python為我們內置了函數staticmethod來把類中的函數定義成靜態方法

 1 import hashlib
 2 import time
 3 class MySQL:
 4     def __init__(self,host,port):
 5         self.id=self.create_id()
 6         self.host=host
 7         self.port=port
 8     @staticmethod
 9     def create_id(): #就是一個普通工具
10         m=hashlib.md5(str(time.clock()).encode(‘utf-8‘))
11         return m.hexdigest()
12 
13 
14 print(MySQL.create_id) #<function MySQL.create_id at 0x0000000001E6B9D8> #查看結果為普通函數
15 conn=MySQL(‘127.0.0.1‘,3306)
16 print(conn.create_id) #<function MySQL.create_id at 0x00000000026FB9D8> #查看結果為普通函數

走入計算機的第三十一天（多態和綁定方法）