• Python类的内置方法


    一、类的type

    class A:pass
    
    print(type(A))              # <class 'type'>
    print(type(object))         # <class 'type'>
    print(type(type))           # <class 'type'>

    ① 所有的对象的type都是创造这个对象类

    ② 所有没有指定metaclass的类的type都是type

    ③ 指定了metaclass,这个类的type就是指定的metaclass的值

    ④ 类也是被创造出来的,type是创造类的机制,即元类是创造类的机制

    所有的对象的type都是创造这个对象类

    class A:pass
    
    a = A()
    print(type(a) is A)         # True

    所有没有指定metaclass的类的type都是type

    class A():pass
    print(type(A))              # <class 'type'>

     指定了metaclass,这个类的type就是指定的metaclass的值

    from abc import ABCMeta
    class A(metaclass=ABCMeta):pass
    print(type(A))                      # <class 'abc.ABCMeta'>

    类也是被创造出来的,type是创造类的机制,即元类是创造类的机制

    print(type(type) is type(object))       # True,type和object的type都是 <class 'type'>
    print(isinstance(type,object))          # True,type和object都属于<class 'type'>
    print(isinstance(object,type))          # True,type和object都属于<class 'type'>
    
    print(issubclass(type,object))          # True,type是object的子类
    print(issubclass(object,type))          # False

    二、__new__  构造方法

    __new__ :构造方法,类实例化对象第一步创建了一个对象空间,这个对象空间是由__new__来创建的,继承object的__new__方法

    __init__:初始化方法

    类实例化对象的时候,先执行的 __new__,再执行__init__。

    类实例化对象的内存机制:

    实例化对象先执行__new__方法,但是类里没有__new__的方法,到父类object中去找到__new__方法并执行,开辟了属于对象的空间,这时才开始执行__init__方法,把self参数传进去才是刚才创造的空间。

    整个过程把类比作模板,创造对象比作捏泥像,__new__方法是捏出来泥像,__init__是给泥像装饰。

    class A:
        def __init__(self):                     # 初始化方法
            print('执行初始化方法')
        def __new__(cls, *args, **kwargs):      # 构造方法
            print('执行构造方法')
            return object.__new__(cls)
    
    a = A()
    
    '''
    执行构造方法
    执行初始化方法
    '''

    三、单例模式

    关于设计模式:

    常用有23种设计模式,源于Java,为了规范java的开发。

    python一种是推崇设计模式,另一种是贬低设计模式。

    单例模式:一个类无论实例化多少次,都只有一个对象,只开辟一个空间,这种就是单例模式。

    单例模式下,创造的对象的属性是最后一个对象的属性,一直再赋值。

    class City:
        __initialize = 0                            # 静态属性
        def __init__(self,city):
            self.city = city
    
        def __new__(cls, *args, **kwargs):
            if not cls.__initialize:
                cls.__initialize = object.__new__(cls)      # 把对象空间地址赋值静态属性
            return cls.__initialize
    
    gz = City('广州')
    sz = City('深圳')
    print(gz,sz)
    print(gz.city,sz.city)
    
    '''
    <__main__.City object at 0x0000022B2DCBC6A0> <__main__.City object at 0x0000022B2DCBC6A0>
    深圳 深圳
    '''

    四、__del__ 析构方法

    ① 析构方法是销毁对象时会调用__del__方法,执行del就会触发__del__的方法

    ② 在删除这个类创建的对象的时候会先触发这个方法,再删除对象,主要是做清理的工作,需要手动归还资源给操作系统,比如:关闭文件,关闭网络的连接,关闭数据库的连接等。

    ③ 无论是手动删除对象还是程序结束自动删除对象,本质上都是执行del 对象,只要调用del 对象,就会触发__del__方法

    ④ 构造方法和析构方法是一对的

    class A:
        def __init__(self,name):                # 初始化方法
            self.name = name
            print(self.name)
            print('执行初始化方法1')
        def __new__(cls, *args, **kwargs):      # 构造方法
            print('执行构造方法!')
            return object.__new__(cls)
        def __del__(self):                      # 析构方法
            print('执行析构方法!')
    
    
    a = A('苹果')
    print('-----分割线-----')
    
    '''
    执行构造方法!
    苹果
    执行初始化方法1
    -----分割线-----
    执行析构方法!
    '''

    总结:初始化对象先执行__new__方法,再执行__init__方法,然后把self传进去,执行__init__的内容,当整个程序执行完自动删除对象,触发了__del__方法,执行__del__方法的内容。

    五、__len__ 方法

    ① 所有使用len()的数据类型都有__len__的方法,使用len()的数据类型:str,list,dict,tuple,set

    ② 只要在类中定义__len__方法,并且方法内return整数,就能使用len(对象)

    ③ 若要统计对象的长度,定义__len__的方法比较好

    class Fruits:
        def __init__(self,name):
            self.name = name
            self.fruit_lis = []
    
        def __len__(self):
            return len(self.fruit_lis)
    
    durian = Fruits('榴莲')
    durian.fruit_lis.append('苹果')
    durian.fruit_lis.append('番茄')
    durian.fruit_lis.append('西瓜')
    durian.fruit_lis.append('雪梨')
    durian.fruit_lis.append('香蕉')
    ret = len(durian)
    print(ret)                               # 5

    六、__eq__ 方法

    ① __eq__方法判断对象是否相等,但是object类的__eq__方法是通过对象的内存地址判断是否相等

    ② __eq__方法 有时会配合__hash__方法使用,判断对象里的对象属性是否相等

    ③ obj.__eq__(obj2) 相当于 obj == obj2

    class City:
        def __init__(self,city):
            self.city = city
    
    
        def __eq__(self, other):
            return self.__dict__ == other.__dict__
    
    c1 = City('广州')
    c2 = City('广州')
    print(c1.__eq__(c2))          # 调用类的__eq__方法
    print(c1 == c2)               # 调用类的__eq__方法
    print(c1,c2)                  # 对象空间的地址
    
    '''
    True
    True
    <__main__.C

    七、__hash__ 方法

    默认的__hash__()继承自对象本身,返回一个基于对象的内部ID值。

    相同的hash值:这意味着两个对象可能是相等的。该hash值为我们提供了一个快速检查对象相等的可能性。如果hash值是不同的,两个对象不可能是相等的,他们也不可能是相同的对象。至关重要的是,内部ID和默认__hash__()方法间有一种强联系。

    等号比较:这意味着hash值也一定相等。这是==操作符的定义。对象可能是相同的对象。

    相同的IDD:这意味着他们是同一个对象。进行了等号比较且有相同的hash值。这是is操作符的定义。

    然而,反过来是不正确的。对象可以有相同的hash值但比较是不相等的。在创建集合或字典时导致一些预计的处理开销是正当的。我们不能确切的从更大的数据结构创建不同的64位hash值。将有不相等的对象被简化为一致相等的hash值。

    特点:

    ① 每次执行的哈希值都会变化

    ② 在一次执行哈希的过程中,对同一个值的hash结果总是不变的

    字典寻址快的原因是运用了哈希算法,比二分查找快。

    字典在内存中的存储方式:

      每存储在内存的数据都有一个内存地址,字典会对键key进行哈希hash(key),把值放在hash的对应地址,所以字典的键是可哈希的

    hash算法的特点:

    ① 对于相同的值在一次程序的运行中是不会变化的

    ② 对于不同的值在一次程序的运行中总是不同的

    set的去重机制:

    ① 对每一个元素进行hash,计算出一个内存地址

    ② 到这个内存地址上查看,如果这块内存中没有值,将这个元素存到对应的内存地址上

    ③ 到这个内存地址上查看,如果这块内存中有值,判断这两个值是否相等。如果相等就舍弃后面的值,如果不相等就二次寻址,再找一个新的空间来存储这个值

    自定义__hash__和__eq__方法

    class Fruits:
        def __init__(self,name):
            self.name = name
    
        def __hash__(self):
            return hash(self.name)
    
        def __eq__(self, other):
            return self.__dict__ == other.__dict__
    
    fruits_lis = ['apple','orange','banana']
    obj_lis = []
    for i in range(9):
        name = Fruits(fruits_lis[i%3])
        obj_lis.append(name)
    print(obj_lis)
    print('-'*100)
    ret = set(obj_lis)
    print(ret)
    
    '''
    [<__main__.Fruits object at 0x000001A5EF92C6D8>, <__main__.Fruits object at 0x000001A5EF9373C8>, <__main__.Fruits object at 0x000001A5EF9370F0>, <__main__.Fruits object at 0x000001A5EF937400>, <__main__.Fruits object at 0x000001A5EF937470>, <__main__.Fruits object at 0x000001A5EF937518>, <__main__.Fruits object at 0x000001A5EF937550>, <__main__.Fruits object at 0x000001A5EF937588>, <__main__.Fruits object at 0x000001A5EF9375C0>]
    ----------------------------------------------------------------------------------------------------
    {<__main__.Fruits object at 0x000001A5EF9370F0>, <__main__.Fruits object at 0x000001A5EF92C6D8>, <__main__.Fruits object at 0x000001A5EF9373C8>}
    
    '''
  • 相关阅读:
    dedecms5.7安装百度(ueditor)编辑器的方法
    shell多线程之进程间通信(2)
    shell多线程之进程间通信
    awk笔记
    用shell做简单的分布式计算
    C语言实现常用查找算法——二分查找
    C语言实现常用排序算法——基数排序
    C语言实现常用数据结构——堆
    C语言实现常用数据结构——图
    C语言实现常用数据结构——二叉查找树
  • 原文地址:https://www.cnblogs.com/st-st/p/9581244.html
Copyright © 2020-2023  润新知