内置函数

Posted 2020-10-31 kuoiea

原文地址：http://www.meng1.top/%e5%86%85%e7%bd%ae%e6%96%b9%e6%b3%95/

内置方法

__len__:len(obj) obj对应的类中含有__len__方法，len(obj)才能正常执行

1   class A(object):
2       def __init__(self,name):
3           self.name= name
4   ?
5       def __len__(self):
6           return len(self.name)
7   ?
8   a = A("lll")
9   print(len(a))

 

__hash__:hash(obj)是obj类自带的 只有实现了__hash__方法，hash(obj)才能正常执行

 

__str__: 只有一个类中实现了__str__才能使用str的一些方法

 1   class List(object):
 2       def __init__(self,*args):
 3           self.l = list(args)
 4       def __str__(self):
 5           return ‘[%s]‘%(‘,‘.join(str(i) for i in self.l))
 6   ?
 7   l = List(1,2,3,4,5)
 8   print(l)
 9   print(type(l))
10   ?
11   #print(obj) 的结果 是 obj.__str__()的结果
12   #str(obj)   的结果 也是 obj.__str__()的结果
13   #‘%s‘%obj   的结果 也是 obj.__str__()的结果

 

__repr__:作用和__str__的作用差不多，也是用来处理字符串的

 1   class List(object):
 2       def __init__(self,*args):
 3           self.l = list(args)
 4       def __str__(self):
 5           return ‘[%s]‘%(‘,‘.join(str(i) for i in self.l))
 6       def __repr__(self):
 7           return "‘[%s]‘" %(‘,‘.join(str(i) for i in self.l))
 8   ?
 9   l = List(1,2,3,4,5)
10   print(repr(l))

 

当需要使用__str__的场景找不到__str__就找__repr__当需要使用__repr__的场景找不到__repr__就找打印内存地址__repr__是__str__的备胎

__format__:格式化输出的内置方法

 1   
 2   #自定义格式化输出类型
 3   class C(object):
 4       def __init__(self,name,age,cls):
 5           self.name = name
 6           self.age = age
 7           self.cls = cls
 8       def __format__(self, format_spec):
 9           return format_spec.format(obj = self)
10   ?
11   a = C("kuoiea",20,"python")
12   format_spec = "{obj.name}:{obj.age}:{obj.cls}"
13   print(format(a,format_spec))

 

 

__del__: 析构方法，在删除一个对象的时候做一些收尾工作

 1   #当我们不主动调用的时候，析构函数会在函数执行结束的时候自动执行
 2   class A(object):
 3       def __init__(self):
 4           self.f = open("继承.py",encoding= "UTF-8",mode="r")
 5   ?
 6       def __del__(self):
 7           print("执行我了")
 8   ?
 9   ?
10   a = A()
11   print(a.f.readline())
12   ?
13   ?
14   #当我们主动使用del删除的时候，__del__就会执行，这样就会删除对象a和其空间，因此后面需要使用这个空间的代码就会报错
15   class A(object):
16       def __init__(self):
17           self.f = open("继承.py",encoding= "UTF-8",mode="r")
18   ?
19       def __del__(self):
20           print("执行我了")
21   ?
22   a = A()
23   del a
24   print(a.f.readline())

 

  ?

__new__:构造方法 实例化的时候 创造对象的过程 __new__ __init__ 初始化

单例模式：就是一个类只能有一个实例

 1 class A(object):
 2       __instance = None
 3       def __new__(cls, *args, **kwargs):
 4           if cls.__instance is None:
 5               obj = object.__new__(cls)
 6               cls.__instance = obj
 7           return cls.__instance
 8       def __init__(self,name,age):
 9           self.name= name
10           self.age = age
11   ?
12       def func(self):
13           print(self.name)
14           print(self.age)
15   ?
16   a = A("kuoiea",20)
17   b =A("pp",50)
18   a.func()
19   print(a.name)
20   ?
21   ?
22   #__new__方法放置在类中哪里都可以，但是为了规范，__new__一般放置在最前面
23   class A(object):
24       __instance = None
25   ?
26       def __init__(self,name,age):
27           self.name= name
28           self.age = age
29   ?
30   ?
31       def func(self):
32           print(self.name)
33           print(self.age)
34       def __new__(cls, *args, **kwargs):
35           if cls.__instance is None:
36               obj = object.__new__(cls)
37               cls.__instance = obj
38           return cls.__instance
39   ?
40   a = A("kuoiea",20)
41   b =A("pp",50)
42   a.func()
43   print(a.name)

 

 

__call__: 对象名()相当于调用内置的__call__方法

1   class A(object):
2       def __init__(self):
3           pass
4       def __call__(self, *args, **kwargs):
5           print("执行了call")
6   ?
7   a = A()
8   a()

 

callable:查看类是否可以被调用，如果返回True，有可能还是不能被调用，但是如果返回False，那么一定不能被调用。

__eq__: ==是由__eq__的返回值来决定的

 1   #重写内置函数，__eq__原本是通过内存地址来判断两个对像的，冲写之后变成了通过值来判断两个对象是否相等
 2   class D(object):
 3       def __init__(self):pass
 4       def __eq__(self, other):
 5           if self.__dict__ == other.__dict__:
 6               return True
 7           else:return False
 8   ?
 9   a = D()
10   b = D()
11   print(a == b)

 

item:对象使用中括号的形式去操作

 1   class Foo:
 2       def __init__(self,name):
 3           self.name=name
 4   ?
 5       def __getitem__(self, item):
 6           print(self.__dict__[item])
 7   ?
 8       def __setitem__(self, key, value):
 9           self.__dict__[key]=value
10       def __delitem__(self, key):
11           print(‘del obj[key]时,我执行‘)
12           self.__dict__.pop(key)
13       def __delattr__(self, item):
14           print(‘del obj.key时,我执行‘)
15           self.__dict__.pop(item)
16   ?
17   f1=Foo(‘sb‘)
18   f1[‘age‘]=18
19   f1[‘age1‘]=19
20   f1[‘age1‘]
21   del f1.age1
22   del f1[‘age‘]
23   f1[‘name‘]=‘alex‘
24   print(f1.__dict__)