30面向对象5_运算符重载-容器相关方法-可调用对象

梦里梦外; 2022-01-10 23:05 146阅读 0赞

运算符重载... 1

容器相关方法... 4

可调用对象... 6

# 运算符重载 #

可大大提高类的可用性；

锦上添花的东西；

好的类的设计应提供类似的方法；

Operator模块提供以下特殊方法，可将类的实例使用下面的操作符来操作：

<table> 
 <tbody> 
 <tr> 
 <td style="border-width:1px;">&lt;,&lt;=,==,&gt;,&gt;=,!=</td> 
 <td style="border-top-width:1px;border-right-width:1px;border-bottom-width:1px;border-left:none;">__lt__,__le__,__eq__,__gt__,__ge__,__ne__</td> 
 <td style="border-top-width:1px;border-right-width:1px;border-bottom-width:1px;border-left:none;">比较运算符，自定义类时用</td> 
 </tr> 
 <tr> 
 <td style="border-right-width:1px;border-bottom-width:1px;border-left-width:1px;border-top:none;">+,-,*,/,%,//,**,divmod</td> 
 <td style="border-top:none;border-left:none;border-bottom-width:1px;border-right-width:1px;">__add__,__sub__,__mul__,__truediv__,__mod__,__floordiv__,__pow__,__divmod__</td> 
 <td style="border-top:none;border-left:none;border-bottom-width:1px;border-right-width:1px;">算术运算符，移位、位运算符也有对应的方法</td> 
 </tr> 
 <tr> 
 <td style="border-right-width:1px;border-bottom-width:1px;border-left-width:1px;border-top:none;">+=,-=,*=,/=,%=,//=,**=</td> 
 <td style="border-top:none;border-left:none;border-bottom-width:1px;border-right-width:1px;">__iadd__,__isub__,__imul__,__itruediv__,__imod__,__ifloordiv__,__ipow__</td> 
 <td style="border-top:none;border-left:none;border-bottom-width:1px;border-right-width:1px;"> </td> 
 </tr> 
 </tbody> 
</table>

注：

移位、位运算符也有对应的方法，在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)

输出：

\-1

\-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

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\}\]

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

\{'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

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)

输出：

例：

class Point:

def \_\_init\_\_(self,x,y):