内置方法

1.__str__和__repr__

改变对象的字符串显示

class Foo:
    def __init__(self,name):
        self.name = name
    def __repr__(self):
        return 'obj in str'  #这里只能是return
    # def __str__(self):
    #     return '%s obj in str'%self.name
f = Foo('egon')
print(f)  #优先执行__str__里面的内容
# 那么你是不是据地__repr__没用呢?
# print('%s'%f)  #执行的是__str__里面的返回值
# print('%r'%f)  #执行的是__repr__里面的返回值
print('==============')
print(str(f))  #当执行str(f)时,会去找__str__这个方法,如果找不到的时候,__repr__这个方法就给替补了
print(repr(f))
#1.当打印一个对象的时候,如果实现了__str__方法,打印__str__中的返回值
# 2.当__str__没有被实现的时候,就会调用__repr__方法
# 3.但是当你用字符串格式化的时候,%s和%r会分别调用__str__和__repr__方法
# 4.不管是在字符串格式化的时候还是在打印对象的时候,
# __repr__方法都可以作为__str__方法的替补,但反之则不行
# 5.用于友好的表示对象。如果__str__和__repr__方法你只能实现一个:先实现__repr__

 __str__和__repr__

2.__del__

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

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

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

f= Foo()
print(123)
print(123)
print(123)
print(123)
View Code

3.item系列

分别有__getitem__      ,__setitem__    ,__delitem__

class Foo:
    def __init__(self):
        self.name = 'egon'
        self.age = 73
        self.l=[1,2,3]
    def __getitem__(self, item):  #得到
        # return  self.l[item]
        # return self.__dict__[item]
        # print(Foo.__dict__)
        return 123
    def __setitem__(self, key, value):  #修改
        print(key,value)
        self.__dict__[key] = value
    def __delitem__(self, key):  #删除
        del self.__dict__[key]
f = Foo()
print(f['qqq'])  #不管里面放的啥值,它都会得到返回值的内容,调用的是__getitem__方法
f['name']='alex' #修改egon的值为alex,调用 __setitem__方法
# del f['name'] #删除name,就会报错了,说明在调用__delitem__方法调用成功了,就已经删了,就会报错了
print(f.name) 
f1 = Foo()
print(f == f1)
# print(f.name)
# print(f[0])  #一开始不能这样取值,但是提供了一个__getitem__方法,这样就可以用了
# print(f[1])
# print(f[2])

三个方法的使用
View Code

4.__new__(创建)

# 4.__new__方法
# 单例模式:是一种设计模式
class Singleton:
    def __new__(cls, *args, **kw):
        if not hasattr(cls, '_instance'):
            orig = super(Singleton, cls)
            cls._instance = orig.__new__(cls, *args, **kw)
        return cls._instance

one = Singleton()
two = Singleton()
print(one,two)   #他们两个的地址一样

one.name = 'alex'
print(two.name) 

单例模式

# class A:
# def __init__(self): #有一个方法在帮你创造self
# print('in init function')
# self.x = 1
#
# def __new__(cls, *args, **kwargs):
# print('in new function')
# return object.__new__(A, *args, **kwargs)
# a = A()
# b = A()
# c = A()
# d = A()
# print(a,b,c,d)


__new__

 

5.__call__

对象后面加括号,触发执行

注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()

 

1 class Foo:
2     def __call__(self, *args, **kwargs):
3         print(123)
4 # f = Foo()
5 # f() #如果不写上面的__call__方法,就不会调用。如果加上,就正确了
6 Foo()() #也可以这样表示
View Code

6.__hash__

class Foo:
    def __hash__(self):
        print('aaaaaaaaaa')
        return hash(self.name)
        # print('aaas')
f = Foo()
f.name = 'egon'
print(hash(f))  #hash方法是可以重写的

__hash__

7.__eq__

class A:
    def __eq__(self, other):
        return True
a = A()
b = A()
print(a==b) #不加方法的时候返回的是False,加了个__eq__方法就返回了个True
# '=='内部就调用了__eq__方法
print(a is b)

__eq__

 

posted @ 2018-08-30 11:27  RootEvils  阅读(129)  评论(0编辑  收藏  举报