Python练习四-浅拷贝&深拷贝

一、数字、字符串不论是浅拷贝、深拷贝都是指向一个地址。

a = 1
b = "abc"
print (id(a))
print (id(b))
a1 = a
b1 = b
print (id(a1),id(b1))
a2 = copy.copy(a)
b2 = copy.copy(b)
print (id(a2),id(b2))
a3 = copy.deepcopy(a)
b3 = copy.deepcopy(b)
print (id(a3),id(b3))

二、列表、元组、字典的浅拷贝、深拷贝指向的地址是变化的。

1.元组中包含列表、字典 

#定义个函数：打印元组中所有数据的地址
def print_tuple(tuple):
    tup = tuple
    print tup,id(tup)
    for k, v in enumerate(tup, 1):
        print v, id(v)
        if type(v) == list:
            key = v
            for k, v in enumerate(key, 1):
                print v, id(v)
        elif type(v) == dict:
            key = v
            for item in key:
                print item, id(item)
                print key[item], id(key[item])
tup = (1,2,['a','b'],{"k1":11})
print "1、元组中包含字典、列表"
print_tuple(tup)

#tup1 = tup
#print "======赋值后======"
#print_tuple(tup1)

tup2 = copy.copy(tup)
print "======浅拷贝后======"
print_tuple(tup2)

tup3 = copy.deepcopy(tup)
print "======深拷贝后======"
print_tuple(tup3)

赋值、浅拷贝后，元组和元组中所有元组地址，都指向的是一个地址；

深拷贝后，元组、元组中列表、字典的地址都是新创建的，其他的元素地址与原来一致； 

2.字典中包含列表、元组

#定义个函数：打印字典中所有数据的地址
def print_dic(dict):
    dic = dict
    print dic,id(dic)
    for item in dic:
        print item, id(item)
        print dic[item], id(dic[item])
        if type(dic[item]) == list:
            li = dic[item]
            for k, v in enumerate(li, 1):
                print v, id(v)
        elif type(dic[item]) == tuple:
            tup = dic[item]
            for k, v in enumerate(tup, 1):
                print v, id(v)

dic = {"a":11,"c":12,"d":('x',100,'z'),"2":["b",13]}
print "2、字典包含列表、元组"
print_dic(dic)
#dic1 = dic
#print "======赋值后======"
#print_dic(dic1)

dic2 = copy.deepcopy(dic)
print "======深拷贝后======"
print_dic(dic2)

#dic3 = copy.copy(dic)
#print "======浅拷贝后======"
#print_dic(dic3)

赋值指向的是一个地址；

浅拷贝后，字典的地址是新创建的，里面元素（包括列表、元组）的地址与原来一致；

深拷贝后，字典的地址、字典中列表的地址是新创建的，元组的地址还是原来的，里面的元素地址与原来一致；

3.列表中包含字典、元组

#定义个函数：打印列表中所有数据的地址
def print_out(list):
    li = list
    print li,id(li)
    for item in li:
        print item, id(item)

        # print li[i],id(li[i])
        if type(item) == dict:
            dic = item
            # for k,v in enumerate(dic,1):
            # print k,id(k)
            # print v,id(v)
            for item in dic:
                print item, id(item)
                print dic[item], id(dic[item])
        elif type(item) == tuple:
            tup = item
            for k, v in enumerate(tup, 1):
                print v, id(v)

li = ['1',('x','y'),{"k1":0,"k2":10}]
print_out(li)
#li1 = li
#print "======赋值后======"
# print_out(li1)
#li2 = copy.copy(li)
#print "======浅拷贝后======"
#print_out(li2)
li3 = copy.deepcopy(li)
print "======深拷贝后======"
print_out(li3)

赋值指向的是一个地址；

浅拷贝后，列表的地址是新创建的，里面元素（包括字典、元组）的地址与原来一致；

深拷贝后，列表的地址、列表中字典的地址是新创建的，元组的地址还是原来的，其他的元素地址与原来一致；

总结：

1.元组本身在深浅拷贝中，地址会变；但作为列表或者字典的元素时，在深拷贝列表或字典时，地址是不变的。

2.列表、字典本身在浅拷贝中地址会变；作为元素时，在深拷贝中地址才会变；