13 python 常用的内置方法介绍

1、isinstance(obj,cls)和issubclass(sub,super)

isinstance(obj,cls)检查是否obj是否是类 cls 的对象

class Foo(object):
    pass
obj = Foo()
print(isinstance(obj,Foo))

输出结果：True

issubclass(sub, super)检查sub类是否是 super 类的派生类

class Foo(object):
    pass
class Bar(Foo):
    pass
print(issubclass(Bar,Foo))

输出结果为：True

2、item系列：属性操作  __setitem__,__getitem__,__delitem__

# 自动触发执行
# 对象可以变成字典对象，可以像字典一样的操作

class Foo:
    def __init__(self, name):
        self.name = name

    def __getitem__(self, item):    # item='name'
        print('getitem..')
        return self.__dict__[item]  # self.__dict__[name]

    def __setitem__(self, key, value):
        print('setitem')
        # print(key,value)
        # self.key = value  #　错误演示　{'name': 'alex', 'key': 'male'}
        self.__dict__[key] = value  # {'name': 'alex', 'sex': 'male'}

    def __delitem__(self, key):
        print('delitem')
        # print(key)
        # del self.__dict__[key]
        self.__dict__.pop(key)

f = Foo('alex')

# 1.查看属性
# obj.属性名
print(f['name'])    # 查看属性obj.name
# print(f['namexxx'])    # 没有namexxx属性
print('-----------------------------------')

# 2.设置属性
f['sex'] = 'male'  # 添加属性
print(f.__dict__)
print(f.sex)
print('-----------------------------------')
# 3.删除属性
# del obj.name
del f['name']
print(f.__dict__)

getitem..
alex
-----------------------------------
setitem
{'name': 'alex', 'sex': 'male'}
male
-----------------------------------
delitem
{'sex': 'male'}

3、_str__,__repr__,__format__

改变对象的字符串显示__str__,__repr__
自定制格式化字符串__format__

# str 方法
d = dict({'name':'alex'})
print(isinstance(d, dict))
print(d)

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

class People:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        print('===>str')
        return 'aaaa'   # 返回值必须是字符串,否则抛出异常

obj = People('alex', 11)
print(obj)  # 执行obj.__str__()

4、__del__     在对象被删除的后执行： f 对象   print('---end----') #del f # f.__del__()

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

注：如果产生的对象仅仅只是python程序级别的（用户级），那么无需定义__del__,如果产生的对象的同时还会向操作系统发起系统调用，

即一个对象有用户级与内核级两种资源，比如（打开一个文件，创建一个数据库链接），则必须在清除对象的同时回收系统资源，这就用到了__del__。

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

f1=Foo()
del f1   # f1.__del__()这个步骤是人为的执行  f1.__del__()

print('------->') #程序运行完

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

#---------------------------------------------------------- 

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

f1=Foo() # del f1 
print('------->') 程序执行完后默认调用 ：def __del__(self):

#输出结果

 -------> 
程序运行完 执行我啦

典型的应用场景：

创建数据库类，用该类实例化出数据库链接对象，对象本身是存放于用户空间内存中，而链接则是由操作系统管理的，存放于内核空间内存中

当程序结束时，python只会回收自己的内存空间，即用户态内存，而操作系统的资源则没有被回收，这就需要我们定制__del__，在对象被删除前向操作系统发起关闭数据库链接的系统调用，回收资源

这与文件处理是一个道理：

f=open('a.txt') #做了两件事，在用户空间拿到一个f变量，在操作系统内核空间打开一个文件
del f #只回收用户空间的f，操作系统的文件还处于打开状态

#所以我们应该在del f之前保证f.close()执行,即便是没有del，程序执行完毕也会自动del清理资源，于是文件操作的正确用法应该是
f=open('a.txt')
读写...
f.close()
很多情况下大家都容易忽略f.close,这就用到了with上下文管理

5、__call__

对象后面加括号，触发执行。

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

class Foo:

    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):

        print('__call__')

obj = Foo() # 执行 __init__  实例初始化自动执行__init__
obj()       # 执行 __call__

一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()。

6、__new__

new()方法的特性：
new()方法是在类准备将自身实例化时调用。
new()方法始终都是类的静态方法，即使没有被加上静态方法装饰器。

类的实例化和它的构造方法通常都是这个样子：

class MyClass(object):
   def __init__(self, *args, **kwargs):
       ...
# 实例化
myclass = MyClass(*args, **kwargs)

正如以上所示，一个类可以有多个位置参数和多个命名参数，而在实例化开始之后，

在调用 init()方法之前，Python首先调用new()方法：

第一个参数cls是当前正在实例化的类。 
如果要得到当前类的实例，应当在当前类中的new()方法语句中调用当前类的父类 的new()方法。 
例如，如果当前类是直接继承自object，那当前类的new()方法返回的对象应该为：

def __new__(cls, *args, **kwargs):
   ...
   return object.__new__(cls)

因此可以这么描述new()和ini()的区别，在新式类中new()才是真正的实例化方法，为类提供外壳制造出实例框架，然后调用该框架内的构造方法init()使其丰满。

__new__() 函数只能用于从object继承的新式类。

先看下object类中对__new__()方法的定义：

class object:
  @staticmethod # known case of __new__
  def __new__(cls, *more): # known special case of object.__new__
    """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
    pass

object将__new__()方法定义为静态方法，并且至少需要传递一个参数cls，cls表示需要实例化的类，此参数在实例化时由Python解释器自动提供。

我们来看下下面类中对__new__()方法的实现：

class Demo(object):
  def __init__(self):
    print '__init__() called...'

  def __new__(cls, *args, **kwargs):
    print '__new__() - {cls}'.format(cls=cls）
    return object.__new__(cls, *args, **kwargs)

if __name__ == '__main__':
  de = Demo()

输出：

发现实例化对象的时候，调用__init__()初始化之前，先调用了__new__()方法

__new__()必须要有返回值，返回实例化出来的实例，需要注意的是，可以return父类__new__()出来的实例，也可以直接将object的__new__()出来的实例返回。

__init__()有一个参数self，该self参数就是__new__()返回的实例，__init__()在__new__()的基础上可以完成一些其它初始化的动作，__init__()不需要返回值。

若__new__()没有正确返回当前类cls的实例，那__init__()将不会被调用，即使是父类的实例也不行。

我们可以将类比作制造商，__new__()方法就是前期的原材料购买环节，__init__()方法就是在有原材料的基础上，加工，初始化商品环节。

实际应用过程中，我们可以这么使用：

class LxmlDocument(object_ref):
  cache = weakref.WeakKeyDictionary()
  __slots__ = ['__weakref__']

  def __new__(cls, response, parser=etree.HTMLParser):
    cache = cls.cache.setdefault(response, {})
    if parser not in cache:
      obj = object_ref.__new__(cls)
      cache[parser] = _factory(response, parser)
    return cache[parser]
该类中的__new__()方法的使用，就是再进行初始化之前，检查缓存中是否存在该对象，如果存在则将缓存存放对象直接返回，如果不存在，则将对象放至缓存中，供下次使用。

再来个单例的，通过重载__new__实现单例：

class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instanc