Question

所以我有一个包含许多元素的列表，每个元素都是包含两个元素的子列表;一个字符和一个数字。例如：

unordered_list = [["A", 5], ["B", 3], ["C", 10], ["D", 0]]

我有一个冒泡排序功能，根据每个子列表的索引1中的值，按降序对子列表进行排序。

def list_sort(n):

    ordered = False
    passes = 0
    while not ordered:
        passes += 1
        ordered = True
        for i in range(0, len(n)-passes):
            if n[i][1] < n[i+1][1]:
                n[i], n[i+1] = n[i+1], n[i]
                ordered = False
    return n

该函数工作正常，只是如果我将unordered_list变量传递给赋值中的函数，即;

sorted_list = list_sort(unordered_list)
sorted_list --> [["C", 10], ["A", 5], ["B", 3], ["D", 0]]

sorted_list包含我期望的结果，但传递给函数的unsorted_list也在函数调用之后排序，这不是我所期望的，因为肯定只有函数中的局部变量n和sorted_list变量应该改变吗？

这里发生了什么？

Answer 1

n继续引用原始列表，由于n是一个可变对象，因此通过引用进行修改将修改引用的对象。

您需要创建原始列表的副本。

您可以在改变列表之前通过切片执行此操作：

def list_sort(n_original):
    n = n_original[:]
    # your code
    return n

n_original[:]是列表n_original的浅副本，与n_original.copy()同义。如果您选择使用复制操作更详细，则可以使用内置copy模块。

from copy import copy

def list_sort(n_original):
    n = copy(n_original)
    # your code
    return n

有关复制及其属性的更多信息，请查看以下内容： What exactly is the difference between shallow copy, deepcopy and normal assignment operation?

Answer 2

这是另一种排序方式，同时保持原始状态不变：

unordered_list = [["A", 5], ["B", 3], ["C", 10], ["D", 0]]

sorted_list = sorted(unordered_list, key=lambda x: x[1], reverse=True)

print(sorted_list)
# -> [['C', 10], ['A', 5], ['B', 3], ['D', 0]]

print(unordered_list)
# -> [['A', 5], ['B', 3], ['C', 10], ['D', 0]]

Python排序函数在不应该更改全局变量时

2 个答案: