python oop求三角形面积公式_python学习日记(OOP——类的内置方法)

__str__和__repr__

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

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

classStudent(object):def __init__(self,name):

self.name=nameprint(Student('libai'))

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

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

classStudent(object):def __init__(self,name):

self.name=namedef __str__(self):return 'Student object(name:%s)'%self.nameprint(Student('libai'))

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

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

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

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

classStudent(object):def __init__(self,name):

self.name=namedef __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__()方法，就可以直接对实例进行调用。请看示例：

classStudent(object):def __init__(self,name):

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

s= Student('libai')

s()

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

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

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

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

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

__len__

classA:def __init__(self):

self.a= 1self.b= 2

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

a =A()print(len(a))

__del__

仅了解。

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

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

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

f1=Foo()delf1print('------->')#输出结果

执行我啦------->

__getitem__\__setitem__\__delitem__

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

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

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

classFoo(object):def __init__(self,name):

self.name=namedef __getitem__(self, item):print('call function __getitem__')return self.__dict__[item]def __setitem__(self, key, value):print('call function __setitem__')

self.__dict__[key] =valuedef __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进行下标的操作时，首先会被__getitem__()、__setitem__()、__delitem__()拦截，从而进行我们在方法中设定的操作，如赋值，修改内容，删除内容等等。

item一例

classA(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:returnself.mydata[item]exceptKeyError: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__')delself.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])