详解Python中__new__方法的作用

目录
  • 前言
  • 一、__new__方法简介
    • 1、初始化数据加载+解析类实例
    • 2、初始化数据加载重写new方法+解析类实例
  • 二、单例模式
    • 1、用new方法如何实现单例模式
    • 2、如何控制类仅执行一次初始化方法
  • 三、多例模式
  • 总结

前言

Python中类的构造方法__new__方法有何作用?

Python类中有些方法名、属性名的前后都添加__双下画线,这种方法、属性通常属于Python的特殊方法和特殊属性。通过重写这些方法或直接调用这些方法来实现特殊功能。今天来聊聊构造方法__new__实际程序的应用场景。

我们知道常见的初始化__init__方法,可以重写实现自己想要的初始化逻辑。最近实际业务开发过程中碰到一类问题比如数据资源加载缓存机制的实现,用到了魔法方法中构造方法,其中__init__()和__new__是对象的构造器,合理运用将有效提高程序性能。

希望大家多结合自己的业务需求深刻理解,灵活运用,使得代码变得更加优雅。

一、__new__方法简介

接下来通过实例逐步详细阐述__ new __ 方法在类初始化过程中是什么样的存在!

1、初始化数据加载+解析类实例

class Solution(object):
    def __init__(self, name=None,data=None):
        self.name = name
        self.data = data
        #初始化加载数据
        self.xml_load(self.data)

    def xml_load(self,data):
        print("初始化init",data)

    def Parser(self):
        print("解析完成finish",self.name)

a = Solution(name="A111",data=10)
a.Parser()
b = Solution(name="A112",data=20)
b.Parser()
# print(a)与 print(b)返回了类的名称和对象的地址
print(a)
print(b)
# 可以使用内置函数id()查看python对象的内存地址
print(id(a))
print(id(b))

初始化init 10
解析完成finish A111
初始化init 20
解析完成finish A112
<__main__.Solution object at 0x0000024A3AF28D48>
<__main__.Solution object at 0x0000024A3B055C48>
2517839809864
2517841042504

注:

1、代码实例化类过程

一般使用__init__()方法初始化一个类的实例,当代码中实例化一个类的时候,第一个调用执行的是__new__()方法,当定义的类中没有重新定义__new__()方法时候,Python会默认调用该父类的__new__()方法来构造该实例,new方法就是先创建一个空间,然后每次创建一个实例化的对象,然后用开辟的空间存放这个实例化对象; 再次创建一个实例化的对象的时候,再用new方法开辟一个空间存放实例化对象。注意只有继承了object的类才有此方法。

2、内存地址和对象可相互转换

#通过_ctypes的api进行对内存地址的对象
import _ctypes
obj = _ctypes.PyObj_FromPtr(id(a))
#打印出来通过内存地址寻找到的对象
print(obj)

print(id(a))与 print(id(b))打印出来的都是内存地址(10进制),print(a)与 print(b)返回了类的名称和对象的地址,但是两者并不相同。每次实例化类都会创建分配不同的对象地址,因此,代码实例化类过程中返回类对象的地址引用也就不同。

2、初始化数据加载重写new方法+解析类实例

class Solution:
    """
    注:new方法是为实例化对象创建空间的方法,现在new方法被改写,没有将实例化对象引用返回给python的解释器
    无法为实例化对象创建空间存储,所以运行代码会报错。也没有完成初始化操作。
    """

    def __new__(cls, *args, **kwargs):
        print("对象创建空间")
        cls.instance = super().__new__(cls)
        print(cls.instance)
        # return cls.instance   #若未返回实例对象引用,实例化方法将报错:AttributeError: 'NoneType' object has no attribute 'Parser'

    def __init__(self,name,data):
        self.name = name
        self.data = data
        self.xml_load(self.data)

    def xml_load(self,data):
        print("初始化init", data)

    def Parser(self):
        print("解析完成finish",self.data)

a = Solution("A111",10)
a.Parser()
print(id(a))

注:

1、__init__()方法和__new__()方法区别

__new__()方法用于创建实例,类实例化之前会首先调用,它是class的方法,是个静态方法。而__init__()方法用户初始化实例,该方法用在实例对象创建后被调用,它是实例对象的方法,用于设置类实例对象的一些初始值。

如果类中同时出现了__init__()方法和__new__()方法,则先调用__new__()方法后调用__init__()方法。__new__()方法是创建实例的第一步,执行完了需要返回创建的类的实例,否则则报错,无法执行__init__()方法。其中,__init__()方法将不返回任何信息。

2、重写__new__()方法

def __new__(cls, *args, **kwargs):
    print(cls)  # cls 代表的是Solution这个类本身<class'__ main __.Solution'>
    cls.instance = super().__new__(cls)  # object().__ new __()
    print(cls.instance)
    return cls.instance

super()与object.__new__(cls)都是在调用父类的new方法,必须把父类的new方法返回给函数,才能开辟空间,因此必须添加return。代码的执行顺序是:先执行new方法,然后执行init方法,最后是其它方法。

二、单例模式

单例模式最初的定义出现于《设计模式》:“保证一个类仅有一个实例,并提供一个访问它的全局访问点。”

单例的使用主要是在需要保证全局只有一个实例可以被访问的情况,比如系统日志的输出、操作系统的任务管理器等。

1、用new方法如何实现单例模式

class Solution:
    # 1、记录第一个被创建对象的引用,代表着类的私有属性
    _instance = None # 静态变量 存储在类的命名空间里的

    def __init__(self,name,data):
        self.name = name
        self.data = data
        self.xml_load(self.data)

    def __new__(cls, *args, **kwargs):
        # 2.判断该类的属性是否为空;对第一个对象没有被创建,我们应该调用父类的方法,为第一个对象分配空间
        if cls._instance == None:  
            # 3.把类属性中保存的对象引用返回给python的解释器
            cls._instance = object.__new__(cls)  # 3
            return cls._instance
        # 如果cls._instance不为None,直接返回已经实例化了的实例对象
        else:
            return cls._instance  # 必须把地址返回给new方法,让它有存储空间

    def xml_load(self,data):
        print("初始化init",self.name,data)

    def Parser(self):
        print("解析完成finish",self.name)

a = Solution("A11",10)  #第一次开辟一个对象空间地址,后面创建都是在该地址上进行的
a.Parser()
b = Solution("A12",20)  #b把a覆盖掉
b.Parser()
print(id(a))
print(id(b))
# 内存地址,而且它们的内存地址都是一样的
print(a.name)
print(b.name)

输出

初始化init A11 10
解析完成finish A11
初始化init A12 10
解析完成finish A12
2465140199816
2465140199816
A12
A12

注:

1、单例模式始终只有一个空间,该空间一直重复利用。

首先定义一个类的私有属性_instance,用来记录第一个被创建对象的引用,如果cls._instance为None说明该类还没有实例化过,则实例化该类并返回实例对象。

通过以下数据测试可知,print(obj.name, obj.data)最后打印出来的都是A12,第一次打印"A11"时,属性为空,执行if语句开辟了一个空间存放该属性;从 第二次打已经开辟了空间 ,执行else语句,直接返回"A12"到原来的空间中,把前面的盖数据覆盖掉。

def task(id,data):
    obj = Solution("{0}".format(id), "{0}".format(data))
    print(obj.name, obj.data)

import threading
ID=["A11","A12","A13","A14","A12"]
DATA=[10,20,30,40,20]
for i in range(5):
    t = threading.Thread(target=task(ID[i],DATA[i]), args=[i, ])
    t.start()

输出

<__main__.Solution object at 0x00000221B2129148>
初始化init A11 10
A11 10
初始化init A12 20
A12 20
初始化init A13 30
A13 30
初始化init A14 40
A14 40
初始化init A12 20
A12 20

2、单例模式另外一种实现方法

def __new__(cls,*args,**kwargs):
    # hasattr查询目标并判断有没有,not  1==1  返回的是False
    # if语句后面的
    # not 条件整体为True时,执行cls.instance = object....代码

    # if语句后面的
    # not 条件整体为False时,执行return代码
    if not hasattr(cls,"instance"):     # hasattr查、判断的作用
        cls.instance = object.__new__(cls)
    return cls.instance

2、如何控制类仅执行一次初始化方法

以上实现了单例模式对象空间的重复利用,但是有时候我们想初始化过程只加载一次,避免频繁请求浪费系统资源(如数据库连接请求数据)。

class Solution:
    #定义类变量
    # 记录第一个被创建对象的引用,代表着类的私有属性
    _instance = None
    #记录是否执行过初始化动作
    init_flag = False

    def __init__(self,name,data):
        self.name = name
        self.data = data
        #使用类名调用类变量,不能直接访问。
        if Solution.init_flag:
            return
        self.xml_load(self.data)
        # 修改类属性的标记
        Solution.init_flag = True

    def __new__(cls, *args, **kwargs):
        # 判断该类的属性是否为空;对第一个对象没有被创建,我们应该调用父类的方法,为第一个对象分配空间
        if cls._instance == None: 
            # 把类属性中保存的对象引用返回给python的解释器
            cls._instance = object.__new__(cls)  
            return cls._instance
        #如果cls._instance不为None,直接返回已经实例化了的实例对象
        else:
            return cls._instance 

    def xml_load(self,data):
        print("初始化init",self.name,data)

    def Parser(self):
        print("解析完成finish",self.name)

a = Solution("A11",10)  #第一次实例化对象地址,后面创建都是在该地址上进行的
a.Parser()
b = Solution("A12",20)  #b把a覆盖掉
b.Parser()
print(id(a))
print(id(b))
print(a.name)
print(b.name)

输出

初始化init A11 10
解析完成finish A11
解析完成finish A12
2280855720328
2280855720328
A12
A12

注:

1、单例模式下仅加载一次初始化过程。

这时候我们在类空间中再添加一个init_flag属性来记录是否已经执行过初始化操作即可实现加载一次初始化过程。从以上两次实例化过程结果来看,对象引用地址不变,结果被最后一次实例化数据覆盖且初始化init只被打印一次。

2、单例模式下一次资源加载注意点

单例模式下控制类仅进行一次初始化过程适用于资源一次性加载进缓存的过程,对于多进程应用可采用多例模式实现。

三、多例模式

多个实例对象空间引用地址完全独立,从而保持避免不同请求资源不被占用。将同一个对象请求归为同一个实例。

class Solution:
    ##定义类实例化对象字典,即不同的实例对象对应不同的对象空间地址引用
    _loaded = {}

    def __init__(self,name,data):
        self.name = name
        self.data = data
        self.xml_load(self.data)

    def __new__(cls, name,*args):
        if cls._loaded.get(name) is not None:
            client = cls._loaded.get(name)
            print(f"已经存在访问对象 {name}")
            print(client)
            return client
        # 把类属性中保存的对象引用返回给python的解释器
        print(f"正在创建访问对象 {name}")
        client = super().__new__(cls)
        # 为该类实例name添加一个空间对象地址引用
        print(client)    
        cls._loaded[name] = client
        return client

    def xml_load(self,data):
        print("初始化init",self.name,data)

    def Parser(self):
        print("解析完成finish",self.name)

if __name__ == '__main__':
    print("多例模式实例")
    a = Solution("A11",10)
    a.Parser()
    b = Solution("A11",10)
    b.Parser()
    c = Solution("A12", 20)
    c.Parser()
    print(f"{a is b}")
    print(a.name)
    print(b.name)
    print(c.name)

注:

1、多例模式始终具有多个空间,不同空间完全独立。

我们在类空间中定义类实例化对象字典,即建立不同的实例对象和对象空间地址引用键值对,从而实现多例模式。通过类字典判断实例对象是否创建,节省创建的成本。

2、多例模式测试过程

当创建相同的实例对象name="A11"时,程序首先在实例池中搜索cls._loaded.get(name),若存在则直接返回已创建的实例对象空间。多例模式完美的实现了不同访问对象具体不同的实例化对象地址。

3、多例模式下缓冲机制的实现

进一步优化多例模式初始化过程,比如读取文件或者数据库时仅进行一次初始化加载。

class Solution:
    ##定义类实例化对象字典,即不同的实例对象对应不同的对象空间地址引用
    _loaded = {}

    def __new__(cls, name,data,*args):
        if cls._loaded.get(name) is not None:
            client = cls._loaded.get(name)
            print(f"已经存在访问对象 {name}")
            print(client)
            return client
        print(f"正在创建访问对象 {name}")
        # 把类属性中保存的对象引用返回给python的解释器
        client = super().__new__(cls)
        print(client)
        # 为该类实例name添加一个空间对象地址引用
        cls._loaded[name] = client
        client._init_db(name,data)
        return client

    def _init_db(self,name,data):
        self.name = name
        self.data = data
        self.xml_load(self.data)

    def xml_load(self,data):
        print("初始化init",self.name,data)

    def Parser(self):
        print("解析完成finish",self.name)

if __name__ == '__main__':
    print("多例模式实例-缓存")
    a = Solution("A11",10)
    a.Parser()
    b = Solution("A11",10)
    b.Parser()
    c = Solution("A12", 20)
    c.Parser()
    print(f"{a is b}")
    print(a.name)
    print(b.name)
    print(c.name)

输出

正在创建访问对象 A11
<__main__.Solution object at 0x0000024198989148>
初始化init A11 10
解析完成finish A11
已经存在访问对象 A11
<__main__.Solution object at 0x0000024198989148>
解析完成finish A11
正在创建访问对象 A12
<__main__.Solution object at 0x00000241989891C8>
初始化init A12 20
解析完成finish A12
True
A11
A11
A12

注:多例模式下多个实例化对象均只进行一次初始化过程。

重写__new__方法中每个实例对象创建后绑定初始化_init_db()方法执行一次,后面遇到同一个实例对象将不会发生什么,直接返回已创建的实例对象。从测试结果来看,创建相同的实例对象name="A11"时,第二次将略过初始化数据加载过程,很好的实现了缓存机制。

总结

本文结合项目背景详细介绍了__new__方法实现单例模式和多例模式以及缓存机制的实现!

1、__new__ 方法是在类创建实例的时候自动调用的。

2、 实例是通过类里面的 __ new __ 方法是在类创建出来的。

3、 先调用__new__ 方法创建实例,再调用 __ init __方法初始化实例。

4、 __new__ 方法,后面的括号里面的cls代表的是类本身。

5、__new__ 方法,判断类属性为空就去开辟空间,否则复用原来的地址。

更多的特殊方法比如1、自我描述方法:__repr__2、析构方法:__del__ 3、列出对象所有属性(包括方法)名:__dir__4、__dict__属性:查看对象内部所有属性名和属性值组成的字典5、__getattr__\__setattr__等。

当然还有metaclass类的__new__方法,可以动态修改程序中的一批类,这个功能在开发一些基础性的框架时非常有用,可以使用metaclass为某一批需要通用功能的类添加方法。

以上就是详解Python中__new__方法的作用的详细内容,更多关于Python __new__的资料请关注我们其它相关文章!

(0)

相关推荐

  • Python 用__new__方法实现单例的操作

    介绍 init 方法通常用在初始化一个类实例时候,但其实它不是实例化一个类的时候第一个被调用 的方法.当使用 Student(id, name) 这样的表达式来实例化一个类时,最先被调用的方法 其实是 new 方法. new方法接受的参数虽然也是和init一样,但init是在类实例创建之后调用,而 new方法正是创建这个类实例的方法. new为对象分配空间,是内置的静态方法,new在内存中为对象分配了空间也返回了对象的引用,init获得了这个引用才初始化这个实例. 示例 一个非常简单的单例 cl

  • python__new__内置静态方法使用解析

    这篇文章主要介绍了python__new__内置静态方法使用解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 使用类名()创建对象时,python解释器会调用__new__方法来为对象分配空间.__new__是一个由object基类提供的内置静态方法,主要作用有两个: (1)在内存中为对象分配空间 (2)返回对象的引用 python的解释器在获得对象的引用之后,将引用作为第一个参数,传递给__intit__方法. 重写__new__方法的代码

  • Python中new方法的详解

    new_ 方法是什么? __new__方法其实就是创建对象的方法 new()方法是在类准备将自身实例化时调用. 一个类可以有多个位置参数和多个命名参数,而在实例化开始之后,在调用 init()方法之前,Python首先调用new()方法: def new(cls, *args, **kwargs): - 第一个参数cls是当前正在实例化的类. 如果要得到当前类的实例,应当在当前类中的new()方法语句中调用当前类的父类 的new()方法. 例如,如果当前类是直接继承自object,那当前类的ne

  • Python中__init__和__new__的区别详解

    __init__ 方法是什么? 使用Python写过面向对象的代码的同学,可能对 __init__ 方法已经非常熟悉了,__init__ 方法通常用在初始化一个类实例的时候.例如: # -*- coding: utf-8 -*- class Person(object): """Silly Person""" def __init__(self, name, age): self.name = name self.age = age def __

  • 详解Python中的__new__()方法的使用

    先看下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 obj

  • 详解Python中的__init__和__new__

    一.__init__ 方法是什么?使用Python写过面向对象的代码的同学,可能对 __init__ 方法已经非常熟悉了,__init__ 方法通常用在初始化一个类实例的时候.例如: 复制代码 代码如下: # -*- coding: utf-8 -*- class Person(object):    """Silly Person""" def __init__(self, name, age):        self.name = name

  • Python 中类的构造方法 __New__的妙用

    目录 1.概述 2.__new__ 和 __init__ 的区别 3.应用1:改变内置的不可变类型 4.应用2:实现一个单例 5.应用3:客户端缓存 6.应用4:不同文件不同的解密方法 1.概述 python 的类中,所有以双下划线__包起来的方法,叫魔术方法,魔术方法在类或对象的某些事件发出后可以自动执行,让类具有神奇的魔力,比如常见的构造方法__new__ .初始化方法__init__ .析构方法__del__ ,今天来聊一聊__new__的妙用,主要分享以下几点: __new__ 和 __

  • 详解Python中__new__方法的作用

    目录 前言 一.__new__方法简介 1.初始化数据加载+解析类实例 2.初始化数据加载重写new方法+解析类实例 二.单例模式 1.用new方法如何实现单例模式 2.如何控制类仅执行一次初始化方法 三.多例模式 总结 前言 Python中类的构造方法__new__方法有何作用? Python类中有些方法名.属性名的前后都添加__双下画线,这种方法.属性通常属于Python的特殊方法和特殊属性.通过重写这些方法或直接调用这些方法来实现特殊功能.今天来聊聊构造方法__new__实际程序的应用场景

  • 详解python中init方法和随机数方法

    1.__init__方法的使用 2.random方法的使用 在python中,有一些方法是特殊的,是以两个下划线开始,两个下划线结束,定义类,最常用的方法就是__init__()方法,这是类的初始化方法,类似于C#或Java的构造函数.在创建对象的时候自动执行. class Person(object): ''' 这里定义的属性 为 静态的 ''' empCount = 0 # 创建对象的时候自动执行 def __init__(self, name): print('初始化方法.....') s

  • 详解python中eval函数的作用

    eval() 函数用来执行一个字符串表达式,并返回表达式的值. eval函数功能:将字符串str当成有效的表达式来求值并返回计算结果.eval函数可以实现list.dict.tuple与str之间的转化 eval() 方法的语法: eval(expression[, globals[, locals]]) 参数: expression -- 表达式. globals -- 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象. locals -- 变量作用域,局部命名空间,如果被提供,可以

  • 详解Python中DOM方法的动态性

    文档对象模型 xml.dom 模块对于 Python 程序员来说,可能是使用 XML 文档时功能最强大的工具.不幸的是,XML-SIG 提供的文档目前来说还比较少.W3C 语言无关的 DOM 规范填补了这方面的部分空白.但 Python 程序员最好有一个特定于 Python 语言的 DOM 的快速入门指南.本文旨在提供这样一个指南.在 上一篇专栏文章 中,某些样本中使用了样本 quotations.dtd 文件,并且这些文件可以与本文中的代码样本档案文件一起使用. 有必要了解 DOM 的确切含义

  • 详解Python中find()方法的使用

    find()方法判断字符串str,如果起始索引beg和结束end索引能找到在字符串或字符串的一个子串中. 语法 以下是find()方法的语法: str.find(str, beg=0 end=len(string)) 参数 str -- 此选项指定要搜索的字符串. beg -- 这是开始索引,默认情况下为 0. end -- 这是结束索引,默认情况下它等于字符串的长度. 返回值 如果找到此方法返回的索引,否则返回-1. 例子 下面的例子显示了find()方法的使用. #!/usr/bin/pyt

  • 详解Python中time()方法的使用的教程

    time()方法返回时间,在UTC时代以秒表示浮点数. 注意:尽管在时间总是返回作为一个浮点数,并不是所有的系统提供时间超过1秒精度.虽然这个函数正常返回非递减的值,就可以在系统时钟已经回来了两次调用期间返回比以前调用一个较低的值. 语法 以下是time()方法的语法: 参数 NA 返回值 此方法返回的时间,因为时代以秒表示浮点数(在UTC). 例子 下面的例子显示time()方法的使用. #!/usr/bin/python import time print "time.time(): %f

  • 详解Python中expandtabs()方法的使用

    expandtabs()方法返回制表符,即该字符串的一个副本. '\t'已经使用的空间,可选择使用给定的tabsize(默认8)扩展. 语法 以下是expandtabs()方法的语法: str.expandtabs(tabsize=8) 参数 tabsize -- 此选项指定要替换为制表符"\t' 的字符数. 返回值 此方法返回在制表符,即通过空格进行了扩展字符串,'\t'的副本. 例子 下面的例子显示expandtabs()方法的使用. #!/usr/bin/python str = &quo

  • 详解详解Python中writelines()方法的使用

    writelines()方法写入字符串序列到文件.该序列可以是任何可迭代的对象产生字符串,字符串为一般列表.没有返回值. 语法 以下是writelines()方法的语法: fileObject.writelines( sequence ) 参数 sequence -- 这是字符串的序列. 返回值 此方法不返回任何值. 例子 下面的例子显示writelines()方法的使用. #!/usr/bin/python' # Open a file in witre mode fo = open("foo

  • 详解Python中pyautogui库的最全使用方法

    在使用Python做脚本的话,有两个库可以使用,一个为PyUserInput库,另一个为pyautogui库.就本人而言,我更喜欢使用pyautogui库,该库功能多,使用便利.下面给大家介绍一下pyautogui库的使用方法.在cmd命令框中输入pip3 install pyautogui即可安装该库! 常用操作 我们在pyautogui库中常常使用的方法,如下: import pyautogui pyautogui.PAUSE = 1 # 调用在执行动作后暂停的秒数,只能在执行一些pyaut

  • 详解Python中Addict模块的使用方法

    目录 介绍 1.安装 2.用法 3.要牢记的事情 4.属性,如键.item等 5.默认值 6.转化为普通字典 7.计数 8.更新 9.Addict 是怎么来的 介绍 Addit 是一个Python模块,除了提供标准的字典语法外,Addit 生成的字典的值既可以使用属性来获取,也可以使用属性进行设置. 这意味着你不用再写这样的字典了: body = {     'query': {         'filtered': {             'query': {              

随机推荐