再談抽象

時間 2019-11-11

標籤再談抽象简体版

原文原文鏈接

多態

1 from random import choice
2 x = choice(['hello, world!',[1,2,'e','e',4]])
3 print(x.count('e'))
 執行結果

經過打印一條消息來指出對象的長度
1 def length_message(x):
2     print("the length of", repr(x), "is", len(x))
3 length_message('xiaoming')
執行結果

建立自定義類

 對foo調用set_name和greet是，foo都會做爲第一個參數自動傳遞給它們
 1 class person:
 2 
 3     def set_name(self, name):
 4         self.name = name
 5 
 6     def get_name(self):
 7         return self.name
 8 
 9     def greet(self):
10         print("hello, world! I'm {}.".format(self.name))
11 foo = person()
12 bar = person()
13 foo.set_name('haha xiaoming')
14 bar.set_name('hehe xiaogang')
15 foo.greet()
16 bar.greet()
執行結果

屬性、函數和方法express

指定超類dom

 Filter是一個過濾序列的通用類。實際上，它不會過濾掉任何東西
 1 class Filter:
 2     def init(self):
 3         self.blocked = []
 4     def filter(self, sequence):
 5         return [x for x in sequence if x not in self.blocked]
 6  7 f = Filter()
 8 f.init()
 9 a=f.filter([1,2,3])
10 print(a)
 執行結果

 Filter類的用途在於可用做其餘類（如將'SPAM'從序列中過濾掉的SPAMFilter類）的基類（超類）.
 1 class Filter:
 2     def init(self):
 3         self.blocked = []
 4     def filter(self, sequence):
 5         return [x for x in sequence if x not in self.blocked]
 6 
 7 class SPAMFilter(Filter):
 8     def init(self):
 9         self.blocked = ['SPAM']
10 s = SPAMFilter()
11 s.init()
12 a = s.filter(['SPAM','SPAM','SPAM','SPAM','eggs','bacon','SPAM'])
13 print(a)
   執行結果

深刻探討繼承函數

 1 class Filter:
 2     def init(self):
 3         self.blocked = []
 4     def filter(self, sequence):
 5         return [x for x in sequence if x not in self.blocked]
 6 
 7 class SPAMFilter(Filter):
 8     def init(self):
 9         self.blocked = ['SPAM']
10 s = SPAMFilter()
11 s.init()
12 s.filter(['SPAM','SPAM','SPAM','SPAM','eggs','bacon','SPAM'])
13 a=issubclass(SPAMFilter, Filter)       （要肯定一個類是不是另外一個類的子類issubclass，可以使用內置方法issubclass）
14 print(a)
   執行結果

a=issubclass(Filter, SPAMFilter)
print(a)

若是你有一個類，並想知道它的基類，可訪問其特殊屬性__bases__
a=SPAMFilter.__bases__
print(a)
b=Filter.__bases__
print(b)

s = SPAMFilter()
a=isinstance(s, SPAMFilter)
b=isinstance(s, str)
print(a)
print(b)

多個超類spa

   子類TalkingCalculator自己無所做爲，其全部的行爲都是從超類哪裏繼承的.關鍵是經過從Calculator那裏繼承calculate，並從Talker那裏
 繼承talker,這被稱爲多重繼承
 1 class Calculator:
 2     def calculate(self, expression):
 3         self.value = eval(expression)
 4 
 5 class Talker:
 6     def talk(self):
 7         print('Hi, my value is', self.value)
 8 
 9 class TalkingCalculator(Calculator, Talker):
10     pass
11 tc = TalkingCalculator()
12 tc.calculate('1 + 2 * 3')
13 tc.talk()
   執行結果

接口和內省 3d

   一般，你要求對象遵循特定的接口（即實現特定的方法），但若是須要，也可很是靈活的踢出要求：不是直接調用方法的並期待一切順利，而是檢查所需的
 方法是否存在；若是不存在，就改弦易轍
 1 class Calculator:
 2     def calculate(self, expression):
 3         self.value = eval(expression)
 4 
 5 class Talker:
 6     def talk(self):
 7         print('Hi, my value is', self.value)
 8 
 9 class TalkingCalculator(Talker, Calculator):
10     pass
11 tc = TalkingCalculator()
12 a=hasattr(tc,'talk')
13 b=hasattr(tc, 'fnord')
14 print(a)
15 print(b)
   執行結果

抽象基類 code

抽象類（即包含抽象方法的類）最重要的特徵是不能實例化
1 from abc import ABC, abstractmethod
2 
3 class Talker(ABC):
4     @abstractmethod
5     def talk(self):
6         pass
7 Talker()
執行結果

   如今實例化沒有任何問題，這是抽象基類的主要用途，並且只有在這種情形下使用isinstance纔是穩當的：若是先檢查給定的實例確實是Talker對象，就能
 相信這個實例在須要的狀況下有方法tale
 1 from abc import ABC, abstractmethod
 2 
 3 class Talker(ABC):
 4     @abstractmethod
 5     def talk(self):
 6         pass
 7 class knigget(Talker):
 8     def talk(self):
 9         print("Ni!")
10 k = knigget()
11 a=isinstance(k, Talker)
12 print(a)
13 k.talk()
   執行結果