deepcopy的实现,__new__ __init__ 区别

本人花费半年的时间总结的《Java面试指南》已拿腾讯等大厂offer,已开源在github ,欢迎star!

转载声明:转载请注明出处,本技术博客是本人原创文章

本文GitHub https://github.com/OUYANGSIHAI/JavaInterview 已收录,这是我花了6个月总结的一线大厂Java面试总结,本人已拿大厂offer,欢迎star

原文链接:blog.ouyangsihai.cn >> deepcopy的实现,__new__ __init__ 区别

点击上方”python宝典”,关注获取python全套视频,

技术文章第一时间送达!

Python中copy和deepcopy的区别,以及编程实现deepcopy的功能

在python中,有浅复制copy()和深度复制deepcopy(),这两个的区别我用以
下的例子来说明,例如:


numlist=[[1,2,[3,4,5]],34,"haha",{"name":
{"fistname":"孙","lastName":"悟空"}}]

设  numlist1 = copy(numlist),numlist1是numlist经过浅复制后得到的一个列表,
设  numlist2 = deepcopy(numlist),numlist2是numlist经过深度复制后的带的一个列表
两者的区别:
假如运行表达式 numlist[0][2] = 6,则上面的三个列表的值如下:


numlist=[[1,2,6],34,"haha",{"name":{"fistname":"孙","lastName":"悟空"}}]
numlist1 = numlist=[[1,2,6],34,"haha",{"name":{"fistname":"孙","lastName":"悟空"}}]
numlist2 = numlist=[[1,2,[3,4,5]],34,"haha",{"name":{"fistname":"孙","lastName":"悟空"}}]

再运行表达式  numlist[3][“name”]=”孙大圣” ,三个列表就变成了如下:


numlist=[[1,2,6],34,"haha",{"name":"孙大圣"}]
numlist1 = numlist=[[1,2,6],34,"haha",{"name":"孙大圣"}]
numlist2 = numlist=[[1,2,[3,4,5]],34,"haha",{"name":{"fistname":"孙","lastName":"悟空"}}]

copy()和deepcopy()的区别总结如下:

由浅复制得到的列表,如果列表中含有可变类型的数据,则只要一个列表中的可变类型的数据改变后,另一个表的可变类型的数据也会改变,例如上面的numlist和numlist1而由深度复制得到的列表,如果列表中含有可变类型的数据,则只要一个列表中的可变类型的数据改变后,另一个表的可变类型的数据不会改变,例如上面的numlist和numlist2

编写程序实现deepcopy:

定义个处理函数 deepcopy(data),data是传进来的序列,创建一个新的列表listdata,然后遍历
序列data,如果是int类型或者str类型等不可变类型的数据,直接添加到listdata中,如果是dict(字
典类型的数据),则调用copydict(i)函数,因为字典的遍历跟tuple和list的遍历不同,所以这里定义
了一个专门拿来处理字典类型的函数,如果是list(列表)或者tuple(元组)类型的数据,则递归调
用deepcopy()函数,直到所有的数据都是不可变类型的数据。

代码如下:


#自定义的deepcopy函数
def deepcopy(data):
    #新建的列表
    listdata = []
    if len(data)!=1:
        for i in data:
            #如果i是dict类型的数据,则调用字典处理函数copydict()
            if isinstance(i,dict):
                dictdata = copydict(i)
                listdata.append(dictdata)
            #如果是元组和列表则递归调用deepcopy()函数
            elif isinstance(i,list) or isinstance(i,tuple):
                listdata1 = deepcopy(i)
                listdata.append(listdata1)
            #其他不可变类型的数据就添加到列表listdata中
            else:
                listdata.append(i)
    else:
        return data
    return listdata

#字典类型的处理函数
def copydict(data):
    dict1 = {}
    #遍历字典
    for keys,values in data.items():
        #以下的每一步的含义与deepcopy中的相似
        if isinstance(values,dict):
            numdict=copydict(values)
            dict1[keys]=numdict
        else:
            value = deepcopy(values)
            dict1[keys]=value
    return dict1

if __name__ == '__main__':
    numlist = [[1, 2, [3, 4, 5]], 34, "number", {"name": {"fistname": "孙", "lastName": "悟空","listname":[1,2,3]}}]
    numlist2 = deepcopy(numlist)
    print(id(numlist[0]))
    print(id(numlist2[0]))
    print(numlist2)
    print(numlist)

new init 区别

先看如下代码


class A(object):
    def __init__(self,*args, **kwargs):
        print "init A"
    def __new__(cls,*args, **kwargs):
        print "new A %s"%cls
     #return super(A, cls).__new__(cls, *args, **kwargs)
        return object.__new__(cls, *args, **kwargs)

说明
1、继承自object的新式类才有__new__
2、__new__至少要有一个参数cls,代表当前类,此参数在实例化时由Python解释器自动识别
3、__new__必须要有返回值,返回实例化出来的实例,这点在自己实现__new__时要特别注意,可以return父类(通过super(当前类名, cls))__new__出来的实例,或者直接是object的__new__出来的实例
4、__init__有一个参数self,就是这个__new__返回的实例,__init__在__new__的基础上可以完成一些其它初始化的动作,__init__不需要返回值

5、如果__new__创建的是当前类的实例,会自动调用__init__函数,通过return语句里面调用的__new__函数的第一个参数是cls来保证是当前类实例,如果是其他类的类名,;那么实际创建返回的就是其他类的实例,其实就不会调用当前类的__init__函数,也不会调用其他类的__init__函数。

在继承派生时的调用顺序


class B(A):
    def __init__(self,*args, **kwargs):
        print "init B"
    def __new__(cls,*args, **kwargs):
        print "new B %s"%cls
     #return super(B, cls).__new__(cls, *args, **kwargs)
        return object.__new__(cls, *args, **kwargs) 

1、在定义子类时没有重新定义__new__()时,Python默认是调用该类的直接父类的__new__()方法来构造该类的实例,如果该类的父类也没有重写__new__(),那么将一直按此规矩追溯至object的__new__()方法,因为object是所有新式类的基类。

2、而如果子类中重写了__new__()方法,那么你可以自由选择任意一个的其他的新式类(必定要是新式类,只有新式类必定都有__new__(),因为所有新式类都是object的后代,而经典类则没有__new__()方法)的__new__()方法来制造实例,包括这个新式类的所有前代类和后代类,只要它们不会造成递归死循环。反正肯定不能调用自己的__new__,这肯定是死循环。

3、对于子类的__init__,其调用规则跟__new__是一致的,当然如果子类和父类的__init__函数都想调用,可以在子类的__init__函数中加入对父类__init__函数的调用。

4、我们在使用时,尽量使用__init__函数,不要去自定义__new__函数,因为这两者在继承派生时的特性还是很不一样的。

new 的作用

1、__new__方法主要是当你继承一些不可变的class时(比如int, str, tuple), 提供给你一个自定义这些类的实例化过程的途径。
假如我们需要一个永远都是正数的整数类型,通过集成int,我们可能会写出这样的代码。


class PositiveInteger(int):
    def __init__(self, value):
        super(PositiveInteger, self).__init__(self, abs(value))


i = PositiveInteger(-3)
print i

但运行后会发现,结果根本不是我们想的那样,我们任然得到了-3。这是因为对于int这种 不可变的对象,我们只有重载它的new方法才能起到自定义的作用。
这是修改后的代码:


class PositiveInteger(int):
    def __new__(cls, value):
        return super(PositiveInteger, cls).__new__(cls, abs(value))

i = PositiveInteger(-3)
print i

通过重载new方法,我们实现了需要的功能。

2、实现单例

事实上,当我们理解了__new__方法后,我们还可以利用它来做一些其他有趣的事情,比如实现 设计模式中的 单例模式(singleton) 。 
因为类每一次实例化后产生的过程都是通过__new__来控制的,所以通过重载__new__方法,我们 可以很简单的实现单例模式。


class Singleton(object):
    def __new__(cls):
        # 关键在于这,每一次实例化的时候,我们都只会返回这同一个instance对象
        if not hasattr(cls, 'instance'):
            cls.instance = super(Singleton, cls).__new__(cls)
        return cls.instance


obj1 = Singleton()
obj2 = Singleton()


obj1.attr1 = 'value1'
print obj1.attr1, obj2.attr1
print obj1 is obj2

输出结果:
value1 value1
True
可以看到obj1和obj2是同一个实例。


class Singleton(object):
    __instance = None


    def __init__(self, *args, **kwargs):
        pass


    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            # if not hasattr(cls, 'instance'):
            cls.__instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
            cls.__instance.aa = args[0]
            print type(cls), type(cls.__instance), type(cls.__instance.aa)
        return cls.__instance

obj1 = Singleton(1, 2, 3, b=2)
obj2 = Singleton(1, 2, 3, b=2)

obj1.attr1 = 'value1'
obj2.attr2 = 'value2'
print obj1.attr1, obj1.attr2
print obj1 is obj2
print obj1.aa, obj2.attr1

结果:
type ‘type’ class ‘main.Singleton’ type ‘int’
value1 value2
True
1 value1

来源:
https://www.cnblogs.com/suntp/p/6445286.html
https://blog.csdn.net/qq_31187881/article/details/79176292

deepcopy的实现,__new__ __init__ 区别

识别图中二维码,欢迎关注python宝典

本人花费半年的时间总结的《Java面试指南》已拿腾讯等大厂offer,已开源在github ,欢迎star!

转载声明:转载请注明出处,本技术博客是本人原创文章

本文GitHub https://github.com/OUYANGSIHAI/JavaInterview 已收录,这是我花了6个月总结的一线大厂Java面试总结,本人已拿大厂offer,欢迎star

原文链接:blog.ouyangsihai.cn >> deepcopy的实现,__new__ __init__ 区别


 上一篇
sort与sorted的区别及实例 sort与sorted的区别及实例
点击上方”python宝典”,关注获取python全套视频, 技术文章第一时间送达! 描述我们需要对List进行排序,Python提供了两个方法对给定的List L进行排序 : 方法1.用对List的成员函数sort进行排序方法2.用内置函
2021-04-05
下一篇 
一般Python开发面试中可能会问到的大部分问题 一般Python开发面试中可能会问到的大部分问题
点击上方”python宝典”,关注获取python全套视频, 技术文章第一时间送达! 来源:https://blog.csdn.net/zhusongziye/article/details/79069434 python语法以及其他基础部
2021-04-05