[python] python 3.4 抽象型別介紹, 實作範例

Part1: 

int 是一個type (型別), list 也是一個型別(type), 而各自不同的type 有自己能使用的method, 方法就如同前幾篇印出來看的結果.

現在, Sequence 是一個型別(type), 當然自己也有自己能用的方法.

但是, list, int 或 str... 等等這種型別, 可以自己產生物件,
ex: a=[1,2,3] => 產生了一個list 物件
ex: t=(1,2,3) =>產生了tuple 物件

而 Sequence 無法產生一個實體物件 => 因此只能算是一個抽象的型別, 概念性的, 不能真的拿來用的型別.

那你會問說, 不能用的Sequence 是要作甚呢？他就像一張賽車的設計藍圖
在Sequence的藍圖中, 畫出了賽車車輪的位置和大小, 畫出了座位的樣子等等等
但是並沒有實際的寫上細節, 沒有真正要用哪些廠牌的資訊, 因為這些細節和實際
製作的工法, 就留給那到藍圖的下游廠商去作就好, 所以換言之, 下游廠商如果接了這個
案子, 就要照著Sequence 的設計藍圖製造, 但是細節由自己決定, 可是不能有少, 否則就
沒有照這個設計圖走了.




所以, 那最源頭的抽象型別是誰呢？我們可以在 Collections Abstract Base Classes,

（https://docs.python.org/3/library/collections.abc.html）


抽象型別的集合中, 看到所有python 定義的抽象型別列表, 如下 （放在collections.abc)

ABC	Inherits from	Abstract Methods	Mixin Methods
Container		__contains__
Hashable		__hash__
Iterable		__iter__
Iterator	Iterable	__next__	__iter__
Generator	Iterator	send, throw	close, __iter__, __next__
Sized		__len__
Callable		__call__
Sequence	Sized, Iterable, Container	__getitem__, __len__	__contains__, __iter__, __reversed__, index, and count
MutableSequence	Sequence	__getitem__, __setitem__, __delitem__, __len__, insert	Inherited Sequence methods and append, reverse, extend, pop, remove, and __iadd__
Set	Sized, Iterable, Container	__contains__, __iter__, __len__	__le__, __lt__, __eq__, __ne__, __gt__, __ge__, __and__, __or__, __sub__, __xor__, and isdisjoint
MutableSet	Set	__contains__, __iter__, __len__, add, discard	Inherited Set methods and clear, pop, remove, __ior__, __iand__, __ixor__, and __isub__
Mapping	Sized, Iterable, Container	__getitem__, __iter__, __len__	__contains__, keys, items, values, get, __eq__, and __ne__
MutableMapping	Mapping	__getitem__, __setitem__, __delitem__, __iter__, __len__	Inherited Mapping methods and pop, popitem, clear, update, and setdefault
MappingView	Sized		__len__
ItemsView	MappingView, Set		__contains__, __iter__
KeysView	MappingView, Set		__contains__, __iter__
ValuesView	MappingView		__contains__, __iter__
Awaitable		__await__
Coroutine	Awaitable	send, throw	close
AsyncIterable		__aiter__
AsyncIterator	AsyncIterable	__anext__	__aiter__

 舉例來看, 在ABC這欄, 有個Sized, 也就是說, python 想營造出一個抽象的東西,
希望能夠處裡有關大小的事情, 所以我的藍圖裡想要有這個概念,
而他右邊那攔 inherits from 是沒有填, 代表Sized 這個概念是原創, 他是第一個頭,
在右邊那攔有個abstracts methods, 他填的是 __len__, 就是說, 希望後人在處裡
有關Sized 的概念時, 請將實作的function 做在__len__裡面, 所以之後, 只要想要找有關
大小的訊息時, 就去你的__len__找, 才不會大家function 名稱不一樣, 搞的亂七八糟的.

另外一個 ABC攔中的 Container 也是類似的, 就是他有個概念是, 我想要找出甚東西
包含在其中, 希望後人們能提供這個方法, 因為還蠻常用的,而你們後人要實作的話
請作在__contains__ 裡面.

那現在看Sequencs , 他繼承了 Sized, Container, Iterable, 這三個人, 所以一定會有
這三個人當初要求要作的方法,但他自己又加入了__getitem__ __len__,這兩個抽象方法

意思是說, 我序列這種類別, 將會提供sized, container, iterable, 和 getitem, len 的方法
如果你要繼承我, 之後你得做出這些東西, 而你看到 __len__不是Sized 裡面就有嗎？
怎又出現在Sequences 的 抽象方法中呢？那是因為 他仍然沒有實作, 繼續擺著, 希望後面的人能作, 而最右邊 Mixin Method, 告訴你, 我還加進了這些方法(已經做好你可以用).

而MutableSequence , 又繼承了Sequence 但列出了一些抽象型別, 等著給別人實作
__getitem__, __setitem__, __delitem__, ...等, 而可用的方法除了繼承了 Sequence
已經有的, 又加入了 append, reversed ,....等等等

這個MutableSequence 抽象型別, 也就是常聽到的[可變序列], 而list , str 都在他的下面,
所以 也就是說, list 得實作這一連串的方法, 加上list 自己想提供的方法, 而 tuple ,
因為是設計來用為不可改變的物件, 當然就不會去繼承 MutableSequence了, 但他仍然
是個序列相關的物件, 所以可見得, tuple 一定是在sequence 之下, 但實際上,
中間還有一層tuple 物件, 而 真正我們在用的實體tuple 是tuple 物件的實作.


you can use it to print the abstract class tree.

def classtree(cls):
       print(cls.__bases__)
       c = list(cls.__bases__)
       for base in c:
            c.extend(classtree(base))
       return c

classtree(MutableSequence)

output:

(<class 'collections.abc.Sequence'>,)
(<class 'collections.abc.Sized'>, <class 'collections.abc.Iterable'>, <class 'collections.abc.Container'>)
(<class 'object'>,) #最上層了
..... #not import so I do not pasted it.


ps. 可以利用 isinstance 看是不是誰的實作, 還有issubclass 看是不是誰的子類別

li=[1,2]
t=(3,4)
print ("---check instance---")
print(isinstance(li,list), isinstance(t,tuple))
print(isinstance(li,Sequence), isinstance(t,Sequence))
print(isinstance(li,MutableSequence), isinstance(t,MutableSequence))

print ("---check list and class level---")
print(type(li),type(t))
print(issubclass(list,MutableSequence),issubclass(MutableSequence,list))
print(issubclass(MutableSequence,Sequence),issubclass(Sequence,MutableSequence))
print(issubclass(Sequence,Sized))



print ("---check tuple and class level---")
print(type(li),type(t))
print(issubclass(tuple,MutableSequence),issubclass(MutableSequence,tuple))
print(issubclass(tuple,Sequence),issubclass(Sequence,tuple))
print(issubclass(Sequence,Sized))

output:
---check instance---
True True
True True
True False
---check list and class level---
<class 'list'> <class 'tuple'>
True False
True False
True
---check tuple and class level---
<class 'list'> <class 'tuple'>
False False
True False
True
[Finished in 0.0s]



Part2 :

     假設你要實作一個Set 的實體instance, 就只要實作 __contains__, __iter__,__len__

（如表格所示）, 而其他Mixin Method 都是python 已經幫我們作好的, 直接可以用了.

所以下面的code, 要實作這三個 (init 本來自己就要), 而也看到, and 直接可以用了.

from collections.abc import *

li=[9,1,2]

class ListBasedSet(Set):
     ''' Alternate set implementation favoring space over speed
         and not requiring the set elements to be hashable. '''
     def __init__(self, iterable):
         self.elements = lst = []
         for value in iterable:
             if value not in lst:
                 lst.append(value)
     def __iter__(self):
         return iter(self.elements)
     def __contains__(self, value):
         return value in self.elements
     def __len__(self):
         return len(self.elements) ＃你在後面+ 100 , s1 印出來值也會變, 可見得真的是跑你作的這邊

s1 = len(ListBasedSet(li)) #拿你實作的來用用看
print(s1)

for x in ListBasedSet(li):  
    print(x)

 ＃你發現 & 不用實作, 直接可以用,因為 __and__在Mixin Method 裡面已經註明他做好了

for x in (ListBasedSet('abcdef') & ListBasedSet('defwxyz')): 
    print(x)

output:

3
9
1
2

d
e
f
[Finished in 0.1s]