　　一个bug引起的……thinking

需求简述

　　将excel学生信息表转换为json格式。　　其中代码有一步要将excel每行的数据按照json模板格式替换掉默认值。

原代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


import xlrd
import json

class GetStudentInfo(object):
    def __init__(self, student_info_path):
        self.student_info_path = student_info_path
        self.template = {
            "name": "ZhangSan",
            "sex": "female",
            "grade": "6",
            "age": "12",
            "id": "0"
        }

    def create_new_student(self, name, student_id):
        new_student = self.template
        new_student['name'] = name
        new_student['id'] = student_id
        return new_student

    def get_whole_stu_info(self):
        students = {}
        tables = xlrd.open_workbook(self.student_info_path)
        table = tables.sheets()[0]
        for row in range(0, table.nrows - 1):
            name = table.cell_value(row + 1, 0)
            student_id = table.cell_value(row + 1, 1)
            new_student = self.create_new_student(name, student_id)
            students[str(row)] = new_student
        self.get_new_file(students)

    def get_new_file(self, students):
        with open('./output.json', 'w', encoding='utf-8') as file:
            json.dump(students, file, indent=4, ensure_ascii=False)

if __name__ ==  '__main__':
    student_info_path = './student_info.xlsx'
    data = GetStudentInfo(student_info_path)
    data.get_whole_stu_info()

　　输出文件为

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


{
    "0": {
        "name": "GouDong",
        "sex": "female",
        "grade": "6",
        "age": "12",
        "id": 4.0
    },
    "1": {
        "name": "GouDong",
        "sex": "female",
        "grade": "6",
        "age": "12",
        "id": 4.0
    },
    "2": {
        "name": "GouDong",
        "sex": "female",
        "grade": "6",
        "age": "12",
        "id": 4.0
    },
    "3": {
        "name": "GouDong",
        "sex": "female",
        "grade": "6",
        "age": "12",
        "id": 4.0
    }
}

Bug定位

1
2
3
4
5
6


    def create_new_student(self, name, student_id):
        new_student = self.template # 这一行有问题！
        print(id(new_student))
        new_student['name'] = name
        new_student['id'] = student_id
        return new_student

　　发现每一次的new_student的id是一样的

1
2
3
4


2110590375320
2110590375320
2110590375320
2110590375320

解决方法

修改为

1
2
3
4
5
6
7


    def create_new_student(self, name, student_id):
        new_student = copy.deepcopy(self.template) # 修改后（法一）
        # new_student = copy.copy(self.template) # 修改后（法二）
        print(id(new_student))
        new_student['name'] = name
        new_student['id'] = student_id
        return new_student

　　此时输出的id不同了：

1
2
3
4


2392740865832
2392740866072
2392740866152
2392740865752

　　新的输出文件为

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


{
    "0": {
        "name": "LiuBo",
        "sex": "female",
        "grade": "6",
        "age": "12",
        "id": 1.0
    },
    "1": {
        "name": "BoCai",
        "sex": "female",
        "grade": "6",
        "age": "12",
        "id": 2.0
    },
    "2": {
        "name": "CaiGou",
        "sex": "female",
        "grade": "6",
        "age": "12",
        "id": 3.0
    },
    "3": {
        "name": "GouDong",
        "sex": "female",
        "grade": "6",
        "age": "12",
        "id": 4.0
    }
}

分析

　　原代码中，new_student = self.template每一次都将*new_student指向self.template，students[str(row)] = new_student每一次都将students[str(row)]指向new_student。所以每次new_student修改后，students[str(row)]的全部值都会更改为最新版。

　　若要避免该问题，就涉及到浅拷贝和深拷贝的问题。

赋值：仅仅是个别名，引用，指向原有地址，id的地址和原有地址相同。（就像快捷方式。）
浅拷贝：第一层拷贝了，里面子文件全是引用。（先建一个新对象，对象地址是新的，里面放原数据的地址，就像一个文件夹里放的全是快捷方式。）
深拷贝：新对象的内存地址也会重新分配，跟原来的内存地址不一样。完全弄一个克隆版，克隆体和本体没有关系了，本体改了克隆体不变。（先建一个新对象，对象地址是新的，里面放的全是克隆体，其地址也是新的。就像一个文件夹里放的全是文件，而不是快捷方式。）

　　再要分清Python里，“=”号、copy.copy和copy.deepcopy三者的区别。

“=“号：对应赋值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


a = 1
b = a
print('原来的a', a, '地址', id(a))
print('b', b, '地址', id(b))
b = 2
print('此时的a', a, '地址', id(a))
print('修改后的b', b, '地址', id(b))
# output
# 原来的a 1 地址 140720364485696
# b 1 地址 140720364485696
# 此时的a 1 地址 140720364485696
# 修改后的b 2 地址 140720364485728

修改后b此时地址变了，因为赋给一个全新完整的变量会重新生成新地址。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


c = [1, 2]
print('原来的c', c, '地址', id(c))
d = c
print('d', d, '地址', id(d))
d[0] = 3
print('此时的c', c, '地址', id(c))
print('修改后的d', d, '地址', id(d))
# output
# 原来的c [1, 2] 地址 2758022890888
# d [1, 2] 地址 2758022890888
# 此时的c [3, 2] 地址 2758022890888
# 修改后的d [3, 2] 地址 2758022890888

　　修改后d地址没变，因为只修改了d内的部分值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


e = {
    "name": "ZhangSan",
    "id": "0"
}
print('原来的e', e, '地址', id(e))
f = e
print('f', f, '地址', id(f))
f['id'] = '1'
print('此时的e', e, '地址', id(e))
print('修改后的f', f, '地址', id(f))
# output
# 原来的e {'name': 'ZhangSan', 'id': '0'} 地址 2001978290072
# f {'name': 'ZhangSan', 'id': '0'} 地址 2001978290072
# 此时的e {'name': 'ZhangSan', 'id': '1'} 地址 2001978290072
# 修改后的f {'name': 'ZhangSan', 'id': '1'} 地址 2001978290072

　　修改后f地址没变，因为只修改了f内的部分值。

copy.copy：对应浅拷贝
copy.deepcopy：对应深拷贝　　官方文档：copy函数

The difference between shallow and deep copying is only relevant for compound objects (objects that contain other objects, like lists or class instances): A shallow copy constructs a new compound object and then (to the extent possible) inserts references into it to the objects found in the original. A deep copy constructs a new compound object and then, recursively, inserts copies into it of the objects found in the original.

　　注意加粗字体，区别在于一个是引用，一个是复制体本身。