30面向對象5_運算符重載-容器相關方法-可調用對象

 

目錄

運算符重載... 1

容器相關方法... 4

可調用對象... 6

 

 

 

運算符重載

 

可大大提升類的可用性；

錦上添花的東西；

好的類的設計應提供相似的方法；

 

Operator模塊提供如下特殊方法，可將類的實例使用下面的操做符來操做：

<,<=,==,>,>=,!=	__lt__,__le__,__eq__,__gt__,__ge__,__ne__	比較運算符，自定義類時用
+,-,*,/,%,//,**,divmod	__add__,__sub__,__mul__,__truediv__,__mod__,__floordiv__,__pow__,__divmod__	算術運算符，移位、位運算符也有對應的方法
+=,-=,*=,/=,%=,//=,**=	__iadd__,__isub__,__imul__,__itruediv__,__imod__,__ifloordiv__,__ipow__

 

注：

移位、位運算符也有對應的方法，在python中沒提高性能，但也沒下降性能，其它語言中會大大提高性能；

 

Int類，幾乎實現了全部操做符，可做爲參考；

在pycharm中，輸入int，ctrl+單擊，可查看運算符魔術方法的幫助；

 

運算符重載應用場景：

每每是用面向對象實現的類，須要作大量的運算；

提供運算符重載（__add__()），比直接提供加法方法（Point類中的add()）要更加適合該領域內使用者的習慣，用戶在平常用的運算符是在數學上最多見的表達方式，如print(p1 + p2)，實現了Point類的二元操做（向量的加法）；

 

例：

class A:

    def __init__(self,x):

        self.x = x

 

    def __sub__(self, other):

        # return self.x - other.x

        # return A(self.x - other.x)   #返回一個新對象（new一個新對象）

        self.x = self.x - other.x

        return self   #就地修改，根據業務場景選擇使用

 

    # def __ne__(self, other):

    #     return self.x != other.x

 

    def __eq__(self, other):   #判斷兩對象是否相等用__eq__，通常不多用__ne__

        return self.x == other.x

 

    def __repr__(self):

        return str(self.x)

 

    __str__ = __repr__   #技巧

 

    def __lt__(self, other):   #也可用__gt__，在測試時缺哪一個補哪一個；只有實現該方法，纔可用sorted()和reversed()，不然報錯TypeError: '<' not supported between instances of 'A' and 'A'；通常把比較大小的函數寫在類內，這樣更優雅

        return self.x < other.x

 

    def __iadd__(self, other):

        # return A(self.x + other.x)

        self.x = self.x + other.x

        return self   #就地修改

 

a1 = A(4)

a2 = A(5)

print(a1)

print(a1 - a2)   #等價於print(a1.__sub__(a2))

print(a1)

print(a1.__sub__(a2))

print(a1)

print(a1 == a2)

 

a3 = A(2)

lst = [a1,a2,a3]

print(lst)

print(sorted(lst))

print(list(reversed(sorted(lst))))

 

a1 += a2

print(a1)

輸出：

4

-1

-1

-6

-6

False

[-6, 5, 2]

[-6, 2, 5]

[5, 2, -6]

-1

 

習題：

完成Point類設計，實現判斷點相等的方法，並完成向量的加法；

class Point:

    def __init__(self,x,y):

        self.x = x

        self.y = y

 

    def __eq__(self, other):

        return self.x == other.x and self.y == other.y

 

    def __add__(self, other):

        return Point(self.x + other.x,self.y + other.y)   #根據使用者習慣設計

 

    # def __add__(self, other):

    #     return (self.x + other.x,self.y + other.y)

 

    def __str__(self):

        return 'Point:{},{}'.format(self.x,self.y)

 

    __repr__ = __str__

 

    def add(self,other):

        return (self.x + other.x,self.y + other.y)

 

p1 = Point(1,1)

p2 = Point(1,1)

print(p1,p2)

points = (p1,p2)

print(points[0].add(points[1]))

print(points[0] + points[1])   #相似pathlib.Path中的/

print(Point(*(points[0].add(points[1]))))

# print(Point(*(points[0] + points[1])))

print(p1 == p2)

print(p1 is p2)

輸出：

Point:1,1 Point:1,1

(2, 2)

Point:2,2

Point:2,2

True

False

 

 

 

容器相關方法

__len__，內建函數len()，返回對象的長度，>=0的整數，即便把對象看成容器類型看，如list、dict，bool()函數調用的時候，若是沒有__bool__()方法，則會看__len__()方法是否存在，存在返回，非0爲真；

__iter__，迭代容器時調用，要求返回一個新的迭代器對象iterator；

__contains__，in成員運算符，沒有實現就調用__iter__方法遍歷；

__getitem__，實現self[key]訪問，序列對象，key接受整數爲索引，或切片，對於set、dict，key爲可hashable，key不存在引起KeyError異常；

__setitem__，相似__getitem__，是設置值的方法；

__missing__，字典使用__getitem__()調用時，key不存在執行該方法，如class MyDict(dict): pass；

 

__len__和__size__並不對等：

__len__，容器中元素的個數；

__size__，容器的大小，第三方庫中，當容量快滿時，會把size擴展；

 

__len__和__iter__：

有時並不關心元素有多少個，直接取元素，__iter__用的多些；

 

注：

single linkedlist中的__getitem__，僅用於容器，提供一種方便的接口，如索引或其它方式來用；

函數中的屬性，foo.__defaults__，用元組保存位置參數默認值；

函數中的屬性，foo.__kwdefaults__，用元組保存關鍵字參數默認值；

 

習題：

將購物車類，改形成方便操做的容器類；

class Color:

    RED = 0

    GREEN = 1

    BLUE = 2

    GOLDEN = 3

    BLACK = 4

    OTHER = 1000

 

class Item:

    def __init__(self,**kwargs):

        self.__spec = kwargs

 

    def __repr__(self):

        # return str(sorted(self.__spec.items()))

        return str(self.__spec)

 

    __str__ = __repr__

 

class Cart:

    def __init__(self):

        self.items = []

 

    def additem(self,item:Item):   #兼容__add__，看用戶使用要求自定義，要不要return，通常用__add__

        self.items.append(item)

 

    def getall(self):

        return self.items

 

    def __len__(self):

        return len(self.items)

 

    def __add__(self, other):

        self.items.append(other)

        return self

 

    def __iter__(self):   #要求必須返回迭代器iterator，簡化，讓使用者以爲實例就是可迭代對象

        return iter(self.items)

 

    def __getitem__(self, item):   #該例容器爲列表，此處item爲索引

        return self.items[item]

 

    def __setitem__(self, key, value):   #key爲index，value爲字典

        self.items[key] = value

        # self[key] = value

 

    def __repr__(self):

        return str(self.items)

 

    __str__ = __repr__

 

mycart = Cart()

myphone = Item(mark = 'sony',color = Color.BLACK,price=2250)

mybicycle = Item(mark='decathlan',color=Color.BLACK,price=1599)

mykindle = Item(mark='amazon',color=Color.OTHER,price=498)

 

mycart.additem(myphone)

print(mycart.getall())

print(len(mycart))

print(mycart + mybicycle + mykindle)   #鏈式編程實現加法，等價於mycart.__add__(mybicycle).__add__(mykindle)

# print(mycart.__add__(mybicycle).__add__(mykindle))

print(len(mycart))

 

# for x in mycart.items:    #類中沒有__iter__方法時使用此種方式迭代實例中的容器

#     print(x)

for x in mycart:   #類中有__iter__方法後，實例就成了可迭代對象，簡化，讓用戶以爲實例就是可迭代對象

    print(x)

 

print(mycart[1])

mycart[1] = {'mark': 'giant', 'color': 4, 'price': 1599}   #此處的value爲字典

print(mycart[1])

輸出：

[{'mark': 'sony', 'color': 4, 'price': 2250}]

1

[{'mark': 'sony', 'color': 4, 'price': 2250}, {'mark': 'decathlan', 'color': 4, 'price': 1599}, {'mark': 'amazon', 'color': 1000, 'price': 498}]

3

{'mark': 'sony', 'color': 4, 'price': 2250}

{'mark': 'decathlan', 'color': 4, 'price': 1599}

{'mark': 'amazon', 'color': 1000, 'price': 498}

{'mark': 'decathlan', 'color': 4, 'price': 1599}

{'mark': 'giant', 'color': 4, 'price': 1599}

 

 

 

可調用對象

python中一切皆對象，函數也不例外；

 

__call__，類中實現，實例就可像函數同樣調用；

定義一個類，並實例化獲得其實例，將實例像函數同樣調用；

 

一個實例可將其看成函數，進而可當裝飾器來用；

 

例：

def foo(x):   #函數即對象，對象foo加上()，就是調用對象的__call__()方法

    print(x)

 

print(callable(foo))

foo(4)   #等價於foo.__call__(4)

foo.__call__(4)

print(foo.__name__)

print(foo.__doc__)

print(foo.__dict__)

print(foo.__call__)

print(dir(foo))

輸出：

True

4

4

foo

None

{}

<method-wrapper '__call__' of function object at 0x7fbbd88d1e18>

['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

 

例：

class A:

    def __call__(self, *args, **kwargs):   #__call__寫在類中，該類的實例就可調用

        print(5)

 

A()()   #先實例化再調用，等價於a = A();a()

a = A()

a()

a(4,5,6)

輸出：

5

5

5

 

例：

class Point:

    def __init__(self,x,y):

        self.x = x

        self.y = y

 

    def __call__(self, *args, **kwargs):

        return 'Point({},{})'.format(self.x,self.y)

 

p = Point(4,5)

print(p)

print(p())

輸出：

<__main__.Point object at 0x7fbc9e10c710>

Point(4,5)

 

例：

class Adder:

    def __call__(self, *args):

        ret = 0

        for x in args:

            ret += x

        self.ret = ret

        return ret

 

adder = Adder()

print(adder(4,5,6))

print(adder.ret)

輸出：

15

15

 

習題：

定義一個fibonacci數列的類，方便調用，計算第n項；

使用類來實現fibonacci數列，可緩存數據，便於檢索；

方1：

 

class Fib:

    def __init__(self):

        self.items = [0,1,1]

 

    def __call__(self, index):

        if index < len(self.items):

            return self.items

            # return self.items[index]

        if index < 0:

            raise IndexError('wrong index')

 

        for i in range(3,index+1):

            self.items.append(self.items[i-1] + self.items[i-2])

        return self.items

        # return self.items[index]

 

print(Fib()(8))

輸出：

[0, 1, 1, 2, 3, 5, 8, 13, 21]

 

方2：

class Fib:

    def __init__(self):

        self.items = [0,1,1]

 

    def __call__(self,index):

        return self[index]

 

    def __iter__(self):

        return iter(self.items)

 

    def __len__(self):

        return len(self.items)

 

    def __getitem__(self, index):

        if index < len(self.items):

            return self.items[index]

        if index < 0:

            raise IndexError('wrong index')

 

        for i in range(len(self),index+1):   #使用len(self)，要加__len__

            self.items.append(self.items[i-2] + self.items[i-1])

        return self.items[index]

 

    def __str__(self):

        return str(self.items)

 

    __repr__ = __str__

 

fib = Fib()

print(fib(8),len(fib))

 

for x in fib:

    print(x)

 

print(fib[8],fib[7])

 

print(fib[-8])

輸出：

21 9

0

1

1

2

3

5

8

13

21

21 13

1