独立阵列互相干扰？

Question

有两列的给定数据集：EmployeeCode和姓氏。 格式是这样的：

EmployeeCode[1] = "L001" 
Surname[1] = "Pollard" 
EmployeeCode[2] = "L002" 
Surname[2] = "Wills" 
... 

什么，我试图做的是按照字典顺序为每一列，以便以后帮助执行二进制搜索的排序。

这是我的代码：

#data set 
EmployeeCode, Surname = [0]*33, [0]*33 
EmployeeCode[1] = "L001" 
Surname[1] = "Pollard" 
EmployeeCode[2] = "L002" 
Surname[2] = "Wills" 
EmployeeCode[3] = "L007" 
Surname[3] = "Singh" 
EmployeeCode[4] = "L008" 
Surname[4] = "Yallop" 
EmployeeCode[5] = "L009" 
Surname[5] = "Adams" 
EmployeeCode[6] = "L013" 
Surname[6] = "Davies" 
EmployeeCode[7] = "L014" 
Surname[7] = "Patel" 
EmployeeCode[8] = "L021" 
Surname[8] = "Kelly" 
EmployeeCode[9] = "S001" 
Surname[9] = "Ong" 
EmployeeCode[10] = "S002" 
Surname[10] = "Goh" 
EmployeeCode[11] = "S003" 
Surname[11] = "Ong" 
EmployeeCode[12] = "S004" 
Surname[12] = "Ang" 
EmployeeCode[13] = "S005" 
Surname[13] = "Wong" 
EmployeeCode[14] = "S006" 
Surname[14] = "Teo" 
EmployeeCode[15] = "S007" 
Surname[15] = "Ho" 
EmployeeCode[16] = "S008" 
Surname[16] = "Chong" 
EmployeeCode[17] = "S009" 
Surname[17] = "Low" 
EmployeeCode[18] = "S010" 
Surname[18] = "Sim" 
EmployeeCode[19] = "S011" 
Surname[19] = "Tay" 
EmployeeCode[20] = "S012" 
Surname[20] = "Tay" 
EmployeeCode[21] = "S013" 
Surname[21] = "Chia" 
EmployeeCode[22] = "S014" 
Surname[22] = "Tan" 
EmployeeCode[23] = "S015" 
Surname[23] = "Yeo" 
EmployeeCode[24] = "S016" 
Surname[24] = "Lim" 
EmployeeCode[25] = "S017" 
Surname[25] = "Tan" 
EmployeeCode[26] = "S018" 
Surname[26] = "Ng" 
EmployeeCode[27] = "S018" 
Surname[27] = "Lim" 
EmployeeCode[28] = "S019" 
Surname[28] = "Toh" 
EmployeeCode[29] = "N011" 
Surname[29] = "Morris" 
EmployeeCode[30] = "N013" 
Surname[30] = "Williams" 
EmployeeCode[31] = "N016" 
Surname[31] = "Chua" 
EmployeeCode[32] = "N023" 
Surname[32] = "Wong" 


#sort based on value of main array 
def bubble_sort(main, second): 
    sort = True 
    passed = len(main)-1 
    while sort: 
     sort = False 
     i = 2 
     while i<= passed: 
      #print(main[i],main[i-1],i) 
      if main[i] < main[i-1]: 
       main[i], main[i-1] = main[i-1], main[i] 
       second[i], second[i-1] = second[i-1], second[i] 
       sort = True 
      i += 1 
     passed -= 1 
    return main,second 



#main 
#prepare sorted array for binary search 
#for search by surname, sort according to surname 
sName,sCode = bubble_sort(Surname,EmployeeCode) 


print("**BEFORE******") 
for k in range(0,33): 
    print(sName[k],sCode[k]) 
print("*BEFORE*******") 

#for search by ECode, sort according to ECode 
cCode,cName = bubble_sort(EmployeeCode, Surname) 


print("**AFTER******") 
for k in range(0,33): 
    print(sName[k],sCode[k]) 
print("**AFTER******") 

然而，第二次分拣后，第一时间SNAME和SCODE排序结果只是自己改变。我从来没有手动改变它。

之前（第1排序）

**BEFORE****** 
0 0 
Adams L009 
Ang S004 
Chia S013 
Chong S008 
Chua N016 
Davies L013 
Goh S002 
Ho S007 
Kelly L021 
Lim S016 
Lim S018 
Low S009 
Morris N011 
Ng S018 
Ong S001 
Ong S003 
Patel L014 
Pollard L001 
Sim S010 
Singh L007 
Tan S014 
Tan S017 
Tay S011 
Tay S012 
Teo S006 
Toh S019 
Williams N013 
Wills L002 
Wong S005 
Wong N023 
Yallop L008 
Yeo S015 
*BEFORE******* 

后（第2分选，见最后4项）

**AFTER****** 
0 0 
Pollard L001 
Wills L002 
Singh L007 
Yallop L008 
Adams L009 
Davies L013 
Patel L014 
Kelly L021 
Morris N011 
Williams N013 
Chua N016 
Wong N023 
Ong S001 
Goh S002 
Ong S003 
Ang S004 
Wong S005 
Teo S006 
Ho S007 
Chong S008 
Low S009 
Sim S010 
Tay S011 
Tay S012 
Chia S013 
Tan S014 
Yeo S015 
Lim S016 
Tan S017 
Lim S018 
Ng S018 
Toh S019 

谁能告诉我怎么会发生这种情况？

Answer 1

在Python中传递的赋值和参数不会创建对象的副本。当您将列表泡泡时，您传入泡泡排序的列表与内存中排列的泡泡列表返回的列表完全相同。 Surname,sName和cName是完全相同的对象，当您执行第二次冒泡排序时，您修改sName和sCode而不是创建独立的排序列表。

如果你想复制一个列表，你必须明确地这样做。这是一个浅拷贝：

new_list = original[:] 

new_list将包含original包含在同一对象的新名单。

这是一个深刻的副本：

import copy 
new_list = copy.deepcopy(original) 

new_list将包含original所包含对象的深层副本一个新的列表。 （这有时是太深;例如，如果你有一个列表的列表，你有时候不想复制这些对象的内部名单内）

最后，我想指出的是您初始化代码非常冗长。您可以使用列表文字而不是创建一个满零的列表并分别分配每个元素：

EmployeeCode = [ 
    'Pollard', 
    'Wills', 
    ... 
]