python学习日记(OOP——类的内置方法)

__str__和__repr__

改变对象的字符串显示__str__,__repr__

我们先定义一个Student类，打印一个实例：

class Student(object):
    def __init__(self,name):
        self.name = name

print(Student('libai'))

打印出一堆<__main__.Student object at 0x000002311102EE10>，不好看。

怎么才能打印得好看呢？只需要定义好__str__()方法，返回一个好看的字符串就可以了：

class Student(object):
    def __init__(self,name):
        self.name = name
    def __str__(self):
        return 'Student object(name:%s)'%self.name

print(Student('libai'))

这样打印出来的实例，不但好看，而且容易看出实例内部重要的数据。

但是细心的朋友会发现直接敲变量不用print（在交互式解释器下），打印出来的实例还是不好看：

这是因为直接显示变量调用的不是__str__()，而是__repr__()，两者的区别是__str__()返回用户看到的字符串，而__repr__()返回程序开发者看到的字符串，也就是说，__repr__()是为调试服务的。

解决办法是再定义一个__repr__()。但是通常__str__()和__repr__()代码都是一样的，所以，有个偷懒的写法：

class Student(object):
    def __init__(self,name):
        self.name = name
    def __str__(self):
        return 'Student object(name:%s)'%self.name
    __repr__ = __str__

print(Student('libai'))

'''
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__()
如果__str__没有被定义,那么就会使用__repr__来代替输出
注意:这俩方法的返回值必须是字符串,否则抛出异常
'''

__call__

一个对象实例可以有自己的属性和方法，当我们调用实例方法时，我们用instance.method()来调用。能不能直接在实例本身上调用呢？在Python中，答案是肯定的。

任何类，只需要定义一个__call__()方法，就可以直接对实例进行调用。请看示例：

class Student(object):
    def __init__(self,name):
        self.name = name

    def __call__(self):
        print('My name is %s'%self.name)

s = Student('libai')
s()

__call__()还可以定义参数。对实例进行直接调用就好比对一个函数进行调用一样，所以你完全可以把对象看成函数，把函数看成对象，因为这两者之间本来就没啥根本的区别。

如果你把对象看成函数，那么函数本身其实也可以在运行期动态创建出来，因为类的实例都是运行期创建出来的，这么一来，我们就模糊了对象和函数的界限。

那么，怎么判断一个变量是对象还是函数呢？其实，更多的时候，我们需要判断一个对象是否能被调用，能被调用的对象就是一个Callable对象，比如函数和我们上面定义的带有__call__()的类实例：

print(callable(Student))
print(callable(len))
print(callable(''))

通过callable()函数，我们就可以判断一个对象是否是“可调用”对象。

__len__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __len__(self):
        return len(self.__dict__)
    #不定义这个方法，异常是：object of type 'A' has no len()
a = A()
print(len(a))

__del__

仅了解。

析构方法，当对象在内存中被释放时，自动触发执行。

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

class Foo:

    def __del__(self):
        print('执行我啦')

f1=Foo()
del f1
print('------->')

#输出结果
执行我啦
------->

__getitem__\__setitem__\__delitem__

__getitem__(self,key):返回键对应的值。

__setitem__(self,key,value)：设置给定键的值

__delitem__(self,key):删除给定键对应的元素。

class Foo(object):
    def __init__(self,name):
        self.name = name
    def __getitem__(self, item):
        print('call function __getitem__')
        return self.__dict__[item]
    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]

f = Foo('libai')
print(f['name'])
f['gender'] = 'male'#新增一个Key
print(f['gender'])
f['gender'] = 'female'#重新赋值
print(f['gender'])
del f['gender']#删除了key
print(f['gender'])#引发异常

源码：item_1.py

这些魔术方法的原理就是：当我们对类的属性item进行下标的操作时，首先会被__getitem__()、__setitem__()、__delitem__()拦截，从而进行我们在方法中设定的操作，如赋值，修改内容，删除内容等等。

item一例

class A(object):
    def __init__(self,start=0,step=1):
        print('call function __init__')
        self.start = start
        self.step = step
        self.mydata = {}
    #定义获取值的方法
    def __getitem__(self, item):
        print('call function __getitem__')
        try:
            return self.mydata[item]
        except KeyError:
            return 'no such key'
    #定义赋值方法
    def __setitem__(self, key, value):
        print('call function __setitem__')
        self.mydata[key] = value
    #定义删除元素的方法
    def __delitem__(self, key):
        print('call function __delitem__')
        del self.mydata[key]

a = A(1,2)
print(a[3])# 这里应该执行 'no such key'，因为没有3这个key
a[3] = 'value3'# 进行赋值
print(a[3])# 前面进行了赋值，那么直接输出赋的值 value3
del a[3]# 删除3这个key
print(a[3])

源码：item_2.py