如何在Python中实现指针？（或任何类似的解决方案）

我有一个类，它将被实现为多个实例。我希望在一些实例之间保持连接，并在它们之间传递消息。在C++中，我可以这样做：

class A
{
   A (*connections)[];
   int sum;

public:
   void pass(int index)
   {
       connections[index] -> receive(sum);
   }
   void receive(int input)
   {
       sum += input;
   }
}

然后我只需要将其他实例的指针添加到

连接[]

，我就可以在它们之间互相传递消息

目前我必须使用Python来完成这项工作，但是Python不支持指针。我想知道解决这个问题的正确解决方案或设计模式是什么

预先感谢。python中的< /p> 我们有名称和容器（如List< /Cord>），引用对象，类似于C++中的引用。示例--a和b指的是同一个对象：

>>> a = object()
>>> b = a
>>> a is b
True

---

我想你可能在找一个新的工作

你喜欢这个工作吗

class A(object):
    connection = []
    def send(self, num):
        self.connection.append(num)
    def receive(self):
        return self.connection.pop(-1)

例如：

>>> x = A()
>>> y = A()
>>> x.send(10)
>>> y.receive()
10

无论如何，您可能希望在模块中实现这一点

Edit:我猜您希望

receive

方法如下所示：

def receive(self):
    s = sum(self.connection)
    self.connection[:] = []    # empty the list
    return s

---

请注意，永远不要为

连接
属性分配任何内容，否则会丢失引用。
Python不需要指针来实现这一点，因为每个变量都是对对象的引用。这些引用与C++引用略有不同，因为它们可以被分配给-就像C++中的指针一样。
class A:

    def __init__(self, name, lsum):
        self.__name = name
        self.__sum = lsum
        self.__connections = []

    def add_connection(self, con):
        self.__connections.append(con)

    def send_signal(self, cidx):
        print("Send signal from [%s] to [%s]" % 
              (self.__name, self.__connections[cidx].__name))
        self.__connections[cidx].receive(self.__sum)

    def receive(self, lsum):
        print("Add [%s] to [%s] in [%s]" % (lsum, self.__sum, self.__name))
        self.__sum += lsum

    def get_sum(self):
        return self.__sum

a = A("Obj1", 10)
b = A("Obj2", 20)
c = A("Obj3", 30)

a.add_connection(b)
a.add_connection(c)

a.send_signal(0)
a.send_signal(1)

print("Sum A [%s]" % a.get_sum())
print("Sum B [%s]" % b.get_sum())
print("Sum C [%s]" % c.get_sum())

因此，要实现您所追求的目标，您只需执行以下操作：

class A(object):
    def __init__( self, connections, sum ):
        self.connections = connections
        self.sum = sum

    def passToConnections( self, index ):
        self.connections[ index ].receive( self.sum )

    def receive( self, input ):
       self.sum += input

为了证明这一点，正如预期的那样：

>>> a1 = A( [], 0 )
>>> a2 = A( [], 0 )
>>> a3 = A( [ a1, a2 ], 10 )
>>> a3.passToConnections( 0 )
>>> a3.passToConnections( 1 )
>>> a3.passToConnections( 1 )
>>> print a1.sum
10
>>> print a2.sum
20

如您所见，我们通过
a3
中的引用调用原始对象，从而更改了原始对象
a1
和
a2
，Python标准处理方式支持您。在python中，每个变量都是一个引用

class A:

    def __init__(self, name, lsum):
        self.__name = name
        self.__sum = lsum
        self.__connections = []

    def add_connection(self, con):
        self.__connections.append(con)

    def send_signal(self, cidx):
        print("Send signal from [%s] to [%s]" % 
              (self.__name, self.__connections[cidx].__name))
        self.__connections[cidx].receive(self.__sum)

    def receive(self, lsum):
        print("Add [%s] to [%s] in [%s]" % (lsum, self.__sum, self.__name))
        self.__sum += lsum

    def get_sum(self):
        return self.__sum

a = A("Obj1", 10)
b = A("Obj2", 20)
c = A("Obj3", 30)

a.add_connection(b)
a.add_connection(c)

a.send_signal(0)
a.send_signal(1)

print("Sum A [%s]" % a.get_sum())
print("Sum B [%s]" % b.get_sum())
print("Sum C [%s]" % c.get_sum())

输出：

Send signal from [Obj1] to [Obj2]
Add [10] to [20] in [Obj2]
Send signal from [Obj1] to [Obj3]
Add [10] to [30] in [Obj3]
Sum A [10]
Sum B [30]
Sum C [40]

我不太能理解你的C++代码，你能提供一个Python用法例子吗？@ RikPoggi，我不知道如何在Python中实现这个，这就是为什么我问……我不是在寻找类<代码> A<代码>实现，而是针对它的实例的API。<代码>连接[索引] >接收（和）；
类似于Python中的
connections[index].receive（sum）
，但是
connections[index]
应该是一个指针（或者说是一个引用，而不是一个值）。你的答案以什么方式回答OP问题？任何变量都只是一个指针。所以当你把“object”保存到某个地方时，它只是在保存它的指针。@rplnt:既然OP知道这一点（他似乎也知道），那么他的问题将如何解决呢？在我看来，这是一个非常糟糕的答案，甚至连文档的链接都没有，也没有深入的解释。我想解释往往比完整的解决方案要好。而
connections[index]
不是一个值，而是一个引用。更改时，引用的对象将更改。除非它是不可变的（例如Number或str）。@rplnt:您刚才说的都不在这个答案中，您的意思是这是一个糟糕的答案。@obmag:pass方法应该将
self.sum
传递到
receive
的调用中。但无论如何+1。