Python中的列表元素指针

Question

我的问题来自此页面 ，而我想为列表元素创建一个指针（类似东西）。 该元素是一个原始值（字符串），因此我必须按照该页面的说明创建一个FooWrapper类。

我知道通过设置__repr__可以直接访问此值。

class FooWrapper(object):
    def __init__(self, value):
         self.value = value
    def __repr__(self):
         return repr(self.value)


>>> bar=FooWrapper('ABC')
>>> bar
'ABC'
>>> bar=FooWrapper(3)
>>> bar
3

现在，我可以将其用作字符串的引用：

>>> L=[3,5,6,9]
>>> L[1]=FooWrapper('ABC')
>>> L
[3,'ABC',6,9]
>>> this=L[1]
>>> this.value='BCD'
>>> print(L)
[3,'BCD',6,9]

因此，现在对于列表元素L[1]有一个类似this的指针。

但是，这仍然很不方便，因为我必须使用this.value='BCD'来更改其值。 虽然存在__repr__方法，使this直接返回this.value ，有没有类似的方法，使this='BCD'做this.value='BCD' ？ 我知道这会改变绑定规则。但是无论如何，这可能吗？

如果列表元素指针有更好的解决方案，我也将不胜感激。

先感谢您：）

Answer 1

我不确定您要做什么，但是您可以执行以下操作：

class FooWrapper(object):
    def __init__(self, value):
         self.value = value
    def __repr__(self):
         return 'FooWrapper(' + repr(self.value) + ')'
    def __str__(self):
        return str(self.value)
    def __call__(self,value):
        self.value = value

在这里，我摆脱了使用__repr__隐藏FooWrapper想法，因为我认为向程序员隐藏REPL发生的事情是一个坏主意。 相反，我使用__str__以便在打印对象时将打印包装的值。 __call__是默认方法，它不会更改=的含义，但可以满足您的要求：

>>> vals = [1,2,3]
>>> vals[1] = FooWrapper("Bob")
>>> vals
[1, FooWrapper('Bob'), 3]
>>> for x in vals: print(x)

1
Bob
3
>>> this = vals[1]
>>> this(10)
>>> vals
[1, FooWrapper(10), 3]

但是，我认为这会使人误解的，以this作为一个指针。 它只是一个包装对象，几乎可以肯定会使得处理包装对象不方便。

编辑时：以下更多是指向列表的指针 。 它使您可以创建类似于__call__的指针对象，该对象用于取消引用指针（当没有参数传递给它时）或使列表变异（当值传递给__call__ ）。 它还实现了一种带有（ pp ）的p++形式（带有环绕）（尽管当然可以删除环绕部分）：

class ListPointer(object):
    def __init__(self, myList,i=0):
         self.myList = myList
         self.i = i % len(self.myList)

    def __repr__(self):
         return 'ListPointer(' + repr(self.myList) + ',' + str(self.i) + ')'

    def __str__(self):
        return str(self.myList[self.i])

    def __call__(self,*value):
        if len(value) == 0:
            return self.myList[self.i]
        else:
            self.myList[self.i] = value[0]

    def pp(self):
        self.i = (self.i + 1) % len(self.myList)

像这样使用：

>>> vals = ['a','b','c']
>>> this = ListPointer(vals)
>>> this()
'a'
>>> this('d')
>>> vals
['d', 'b', 'c']
>>> this.pp()
>>> this()
'b'
>>> print(this)
b

我认为这是一种更透明的方式来获取类似于列表指针的内容。 它不需要将指向的东西包装在任何东西中。

Answer 2

__repr__方法可以获取所需的字符串。 假设它说return repr(self.value) + 'here' 。 如果您说this = '4here' ，应该受到什么影响？ 应该self.value被分配到4或4here ？ 如果this具有另一个称为key属性并且__repr__ return repr(self.key) + repr(self.value)怎么办？ 当您执行this = '4here' ，它会将self.key分配给整个字符串，将self.value分配给整个字符串，还是将self.key分配给4并将self.value分配给here ？ 如果字符串完全由该方法组成怎么办？ 如果说return 'here' ，我应该this = '4here'吗？

简而言之，你不能。

Answer 3

根据约翰·科尔曼的想法进行自我回答：

class ListPointer(object):
    def __init__(self,list,index):
          self.value=list[index]
          list[index]=self
    def __repr__(self):
          return self.value
    def __call__(self,value):
          self.value=value

>>> foo=[2,3,4,5]
>>> this=ListPointer(foo,2)
>>> this
4
>>> foo
[2,3,4,5]
>>> this('ABC')
>>> foo
[2,3,'ABC',5]
>>> type(foo(2))
<class '__main__.ListPointer'>

ListPointer对象接受一个列表和一个索引，将list[index]存储在self.value ，然后用self替换list元素。 类似地，也可以实现pp方法，同时应该恢复前一个元素，然后用self对象替换下一个元素。 通过直接引用foo[2]也可以得到该对象，这正是我想要的。 （也许应该将其称为引用而不是指针。）