python中定制类_【Python入门】15.面向对象编程之定制类常用的定制方法

太过爱你忘了你带给我的痛 2022-12-31 11:27 174阅读 0赞

面向对象编程

\_\_str\_\_( )

\_\_repr\_\_( )

\_\_iter\_\_( )与\_\_next\_\_( )

\_\_getitem\_\_( )

\_\_setitem\_\_( )

\_\_delitem\_\_( )

\_\_getattr\_\_( )

\_\_call\_\_( )

面向对象编程

之前已经介绍过形似\_\_xxx\_\_的是特殊变量或函数，如\_\_init\_\_、\_\_slots\_\_等。这一节将介绍更多的特殊方法，来帮助我们定制自己定义到class。

\_\_str\_\_( )

\_\_str\_\_( )方法可以根据定义的字符串，在打印实例时返回所定义的字符串。

在没有使用\_\_str\_\_( )方法时：>>>class Stu(object):                                              \#定义一个class...    def \_\_init\_\_(self, name):

...        self.name = name

...>>>print(Stu('Ming'))                                              \#打印一个实例<\_\_main\_\_.stu>

使用了\_\_str\_\_( )方法后：>>>class Stu(object):...    def \_\_init\_\_(self, name):

...        self.name = name

...    def \_\_str\_\_(self):

...        return 'Stu object (name: %s)' % self.name

...>>>print(Stu('MIng'))

Stu object (name: MIng)

这样可以清楚地看到实例内部的重要数据，需要注意的是，\_\_str\_\_( )方法里的return后面跟的必须是字符串。

\_\_repr\_\_( )

\_\_repr\_\_( )的用途与\_\_str\_\_( )很像，两者的区别是\_\_str\_\_( )返回的是用户看到的字符串，而\_\_repr\_\_( )返回的是程序开发者看到的字符串。

也就是说，如按上面的定义，在交互模式中直接调用实例，还是不会返回想要的字符串的。>>>Stu('Ming')

我们把上面的\_\_str\_\_( )改为\_\_repr\_\_( )，再试试。>>>class Stu(object):...    def \_\_init\_\_(self, name):

...        self.name = name

...    def \_\_repr\_\_(self):

...        return 'Stu object (name: %s)' % self.name

...>>>Stu('MIng')

Stu object (name: MIng)

成功返回。此时如果使用print，还是能够返回想要的字符串的。>>>print(Stu('Ming'))

Stu object (name: MIng)

如果同时定义\_\_str\_\_( )和\_\_repr\_\_( )呢？class Stu(object):

def \_\_init\_\_(self, name):        self.name = name    def \_\_repr\_\_(self):        return 'Stu object (name: %s)' % self.name    def \_\_str\_\_(self):        return 'str'>>>Stu('MIng')

Stu object (name: MIng)

>>>print(Stu('Ming'))

str

可见在这种情况下，print是优先考虑\_\_str\_\_( )的。

总而言之，\_\_str\_\_( )面向用户，而\_\_repr\_\_( )面向程序员。所以如果想要在所有环境下统一显示的话，直接用\_\_repr\_\_即可。若要区分，则定义两个。一般情况下显示的内容时相同的，可用\_\_repr\_\_( ) = \_\_str\_\_( )来简化定义。

\_\_iter\_\_( )与\_\_next\_\_( )

for...in循环是作用于可迭代对象，那想要让自己定义的类可用for...in循环，就必须把自己变成可迭代对象。

\_\_iter\_\_( )方法的用途就是返回一个可迭代对象Iterable。

\_\_next\_\_( )方法的用途是定义一个循环的逻辑而返回下一个循环值(用了之后就是一个迭代器对象了Iterator)。

那么结合两种方法，for..in循环就会不断调用该可迭代对象作用于\_\_next\_\_( )方法得出下一个循环值。直到遇到StopIteration错误时退出循环。

举个例子，如生成斐波那契数列，写个Fib类。class Fib(object):

def \_\_init\_\_(self):        self.a, self.b = 0, 1                              \# 初始化两个计数器a，b

def \_\_iter\_\_(self):        return self                                        \# 实例本身就是迭代对象，故返回自己

def \_\_next\_\_(self):        self.a, self.b = self.b, self.a + self.b           \# 计算下一个值

if self.a > 1000:                                  \# 退出循环的条件

raise StopIteration()        return self.a                                      \# 返回下一个值

用for..in作用于Fib的实例>>>for n in Fib():...    print(n)1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

实际上，不用\_\_iter\_\_( )方法也可以得到斐波那契数列，只不过需要不断调用next( )来拿取下一个值，而用了\_\_iter\_\_( )方法之后变成可迭代对象，就可以用for...in循环来轻松拿取了。

\_\_getitem\_\_( )

\_\_getitem\_\_( )方法的用途是让实例像list那样按照下标取元素。\_\_getitem\_\_( )方法需要传入两个参数，一个是实例本身，另一个是下标。当检测到有\[ \]时就会运行\_\_getitem\_\_( )。>>>class A(object):...    def \_\_getitem\_\_(self, key):                       \# 定义一个\_\_getitem\_\_方法，key参数是下标...        print('Call function \_\_getitem\_\_')

...        print(key + 1)>>>a = A()>>>a\[1\]                                                  \# 在这里会把a传给self，而把1传给keyCall function \_\_getitem\_\_                                \# 当检测到有\[\]时，就会执行\_\_getitem\_\_方法2                                                        \# 返回的是key+1，即1+1=2

利用\_\_getitem\_\_( )方法的特性，我们可以生成一个能够按下标输出的斐波那契数列。class Fib(object):

def \_\_getitem\_\_(self, n):

a, b = 1, 1

for x in range(n):

a, b = b, a + b        return a

试一下：>>> f = Fib()>>> f\[0\]1>>> f\[1\]1>>> f\[2\]2>>> f\[3\]3>>> f\[10\]89

若还想要想list那样具有切片功能，就需要判断传入的参数是整数还是切片，然后进一步做输出处理。像这样(以下代码转自廖雪峰的官方网站)class Fib(object):

def \_\_getitem\_\_(self, n):

if isinstance(n, int): \# n是索引

a, b = 1, 1

for x in range(n):

a, b = b, a + b            return a        if isinstance(n, slice): \# n是切片

start = n.start

stop = n.stop            if start is None:

start = 0

a, b = 1, 1

L = \[\]            for x in range(stop):                if x >= start:

L.append(a)

a, b = b, a + b            return L

运行结果：>>> f = Fib()>>> f\[0:5\]

\[1, 1, 2, 3, 5\]

当然还有地方需要改进，如对step参数的处理，对负数的处理等等，这些都可以在后面继续完善，这里值简单介绍\_\_getitem\_\_( )的用法。

\_\_setitem\_\_( )

\_\_setitem\_\_( )同样可以让实例像list那样按照下标取元素，同时还可以给key赋值value，所以需要传入三个参数，分别是实例本身，键key，值value。当检测到有形如\[ \] = 的赋值语句时就会执行\_\_setitem\_\_( )方法。>>>class A(object):...    def \_\_setitem\_\_(self, key, value):            \# 定义一个\_\_setitem\_\_方法，key参数是键，value是值...        print('Call function \_\_setitem\_\_')

...        print(value)>>>a = A()>>>a\[1\] = 10                                         \# 在这里会把a传给self，而把1传给key，把10传给valueCall function \_\_getitem\_\_                            \# 当检测到有\[\] = 时，就会执行\_\_setitem\_\_方法10                                                   \# 打印value

\_\_delitem\_\_( )

\_\_delitem\_\_( )用来删除指定key的元素，需要传入self和key两个参数。当检测到del时就会执行\_\_delitem\_\_( )方法。

结合\_\_getitem\_\_( )、\_\_setitem\_\_( )和\_\_delitem\_\_( ),方法，给个简单的例子再帮助理解。class A(object):

def \_\_init\_\_(self, start = 0):

print('Call function \_\_init\_\_')        self.start = start        self.dict = \{\}                              \# 定义一个dict

def \_\_getitem\_\_(self, key):                     \# 定义获取值的方法

print('Call function \_\_getitem\_\_')        try:

return self.dict\[key\]                   \# 如果有对key赋值，则返回key对应的value

except KeyError:

return key                              \# 如果没有对key赋值，则返回key本身

def \_\_setitem\_\_(self, key, value):              \# 定义赋值方法

print('Call function \_\_setitem\_\_')        self.dict\[key\] = value    def \_\_delitem\_\_(self, key):                     \# 定义删除元素的方法

print('Call function \_\_delitem\_\_')

del self.dict\[key\]a = A()                                             \# 创建A的一个实例aCall function \_\_init\_\_

a\[1\] = 10                                           \# 执行赋值方法\_\_setitem\_\_ Call function \_\_setitem\_\_

a\[2\] = 20                                           \# 执行赋值方法\_\_setitem\_\_Call function \_\_setitem\_\_

a\[1\]                                                \# 执行取值方法\_\_getitem\_\_，\[1\]有对应的值10Call function \_\_getitem\_\_

a.dict                                              \#dict属性中已有的值\{1: 10, 2: 20\}

del a\[1\]                                            \#删除dict属性中，key为\[1\]的值Call function \_\_delitem\_\_

a.dict

\{2: 20\}

\_\_getattr\_\_( )

当我们尝试调用一个没有被定义的属性或方法时，会出现错误。而\_\_getattr\_\_( )的用途是当调用不存在的属性时，就会执行\_\_getattr\_\_( )尝试返回另外的值。

未定义\_\_getattr\_\_( )时class Stu(object):

def \_\_init\_\_(self, name):        self.name = name

a = Stu('Ming')>>>a.name

Ming>>>a.ageAttributeError: 'Stu' object has no attribute 'age'

定义了\_\_getattr\_\_( )之后class Stu(object):

def \_\_init\_\_(self, name):        self.name = name

def \_\_getattr\_\_(self, attr):        return 1>>>a.name

Ming>>>a.age                          \# 这里的age将会传给\_\_getattr\_\_()的第二个参数attr1

也能返回一个函数class Stu(object):

def \_\_init\_\_(self, name):        self.name = name

def \_\_getattr\_\_(self, attr):        return lambda: 10

当然，我们能根据\_\_getattr\_\_( )的参数，去完善定义，像这样：class Stu(object):

def \_\_getattr\_\_(self, attr):

if attr=='age':            return lambda: 10

raise AttributeError('\\'Student\\' object has no attribute \\'%s\\'' % attr)

\_\_call\_\_( )

\_\_call\_\_( )方法可以使实例变为可调用对象，当尝试直接调用实例时，会执行\_\_call\_\_( )方法。class Stu(object):

def \_\_init\_\_(self, name):        self.name = name

def \_\_call\_\_(self):

print('I am %s' % self.name)>>>a = Stu('Ming')>>>a()                                           \# 注意需要加()I am Ming

\_\_call\_\_( )还能定义参数，这样的话就可以实例对象看成一个函数了。这就模糊了对象和函数的区别，其实很多时候我们需要区分的是对象是否可调用，可以用callable( )函数来判断。>>> callable(Stu())True>>> callable(max)True>>> callable(\[1, 2\])False>>> callable(None)False

作者：三贝\_

链接：https://www.jianshu.com/p/2e7bcb8e9493