Question

这样有一个排序功能：

def iterative_insertion_sort(A):
    '''Sort A iteratively.'''
    for i, key in enumerate(A[1:]):
        while i > -1 and A[i] > key:
            print(id(key), id(A[i+1]))
            A[i + 1] = A[i]
            print(id(key), id(A[i+1]))
            i = i - 1
        A[i + 1] = key

排序功能与浮动工作正常。

示例输出：./ insertion_sort.py .23 .21 .26

140566861513304 140566861513304
140566861513304 140566861513256
[0.21, 0.23, 0.26]

但我有一个名为lList的自定义类，它有链接（另一个自定义类）类型的元素。当我输入lList的实例时，排序不能正常工作。

样品输出：0.23 0.21 0.26 /

139732300992808 139732300992808
139732300992808 139732300992808
0.23 0.23 0.26 /

正如我们可以看到，在float的情况下，在赋值语句之后，key的id和数组元素是不同的。但是在自定义类的情况下，即使在赋值操作之后，key和array元素的id也是相同的。这是麻烦的原因。

我怀疑问题是因为浮点数是不可变的，而我的自定义类不是。我的问题是解决这种情况的最佳方法是什么？

注意：在我的排序过程中，我更喜欢零到最小的更改。但是，我愿意自定义我的lList或链接类。

P.S。我刚刚发布了相关的代码片段。如果还需要类定义，只需提及它，我也会添加它。

非常感谢！

更新

链接定义：

class link:
    '''Implement link.'''

    def __init__(self, key=None):
        self.key = key
        self.nxt = None
        self.prev = None

    def __str__(self):
        '''Print link.'''
        if self:
            return str(self.key)
        else:
            return '/'

    def __gt__(self, other):
        return self.key > other.key

这是lList定义：

class lList:
    '''Implement list of links.'''

    def __init__(self):
        self._head = None
        self._numberOfLinks = 0

    def list_insert(self, x):
        '''Insert link x at the beginning of list.'''
        x.nxt = self._head
        if self._head:
            self._head.prev = x
        self._head = x
        self._numberOfLinks += 1

    def __str__(self):
        '''Print list of links.'''
        listFormat = ''
        temp = self._head
        while temp:
            listFormat += str(temp) + ' '
            temp = temp.nxt
        else:
            listFormat += '/ '
        return listFormat

    def get_data(self, position):
        '''Return link from list at position position from head.'''
        i = 0
        temp = self._head
        while i < position:
            temp = temp.nxt
            i += 1
        return temp

    def set_data(self, position, newLink):
        '''Overwrite key of link at position distance from head of list with key of newLink.'''
        i = 0
        temp = self._head
        while i < position:
            temp = temp.nxt
            i += 1
        temp.key = newLink.key    

    def __getitem__(self, position):
        if type(position) is slice:
            return [self[i] for i in range(*position.indices(len(self)))]
        elif type(position) is int:
            if position < 0:
                position += len(self)
            if position >= len(self):
                raise IndexError("The index (%d) is out of range."%position)
            return self.get_data(position)
        else:
            raise TypeError("Invalid argument type.")

    def __setitem__(self, position, value):
        self.set_data(position, value)

    def __len__(self):
        return self._numberOfLinks

这是创建相同场景的mimimal代码：

test = lList()
l = link(.26)
test.list_insert(l)
l = link(.21)
test.list_insert(l)
l = link(.23)
test.list_insert(l)
print(test)
iterative_insertion_sort(test)
print(test)

Answer 1

是的，问题不再是不变性问题，而是更多的共享参考问题。

对浮点值进行排序时，存储对存储在A[1] key中的浮点数的引用。然后，您使用A[1]中的值更改A[0]中的引用。这意味着A[1]现在指向不同的对象，稍后将A[0]设置为key就可以了。

但是在对链表进行排序时，您永远不会改变A[1]。您更改了A[1]的属性。 key和A[1]继续指向相同的link个实例，A[1].key中也可以看到设置key.key。

您可以通过实际用新的link对象替换整个def set_data(self, position, newLink): '''Overwrite key of link at position distance from head of list with key of newLink.''' i = 0 temp = self._head while i < position: temp = temp.nxt i += 1 newlink = link(newLink.key) if temp.prev: temp.prev.nxt = newlink else: self._head = newlink newlink.nxt = temp.nxt对象来解决此问题：

list

这相当于在Python (4302695168, 4302695168) (4302695168, 4303149248) 0.21 0.23 0.26 /对象中设置新值：

addons_1_ID_addon, addons_2_ID_addon, ... addons_32_ID_addon

Python3：如何控制用户定义类的行为？

1 个答案: