Simulating Pointer Behavior in Python

General Discussions
, ,
#1

In Python, we don’t have explicit pointers like in languages such as C++ or PHP. However, I want to achieve a behavior similar to pointers. For example, given the following:

a = 1
b = a  # How can I modify this line so that b "points to" a?
a = 2
print(b)

I would like b to reflect the updated value of a (i.e., b should print 2).

Here’s a use case: I want form.data['field'] and form.field.value to always have the same value, similar to how references work in PHP. In PHP, I can do something like this:

class Form {
    public $data = [];
    public $fields;
    
    function __construct($fields) {
        $this->fields = $fields;
        foreach($this->fields as &$field) {
            $this->data[$field['id']] = &$field['value'];
        }
    }
}

$f = new Form([
    ['id' => 'fname', 'value' => 'George'],
    ['id' => 'lname', 'value' => 'Lucas']
]);

echo $f->data['fname'], $f->fields[0]['value'];  // Outputs: George George
$f->data['fname'] = 'Ralph';
echo $f->data['fname'], $f->fields[0]['value'];  // Outputs: Ralph Ralph

In C++, this would work like this:

int a;
int* b = &a;
a = 1;
cout << a << endl << *b << endl;  // Outputs: 1 1

How can I simulate this kind of pointer behavior in Python?

#2

In Python, you can achieve similar behavior to pointers by leveraging mutable data types like lists or dictionaries. When these objects are modified, the changes reflect across all references since mutable objects are passed by reference.

a = [1]  # A mutable list
b = a  # 'b' points to the same list as 'a'
a[0] = 2
print(b[0])  # Output: 2, as both 'a' and 'b' refer to the same list

By changing a[0], we directly update the underlying list. Since b points to the same object, it also reflects the change. This approach works best for simple use cases, but it might not fit scenarios with more complex relationships between values.

#3

Another way to mimic pointer-like behavior in Python is by creating a custom class to hold references. Here’s how it works:

class Pointer:
    def __init__(self, value):
        self.value = value

a = Pointer(1)
b = a  # 'b' refers to the same object as 'a'
a.value = 2
print(b.value)  # Output: 2, since both 'a' and 'b' refer to the same object

This is closer to a true “pointer” behavior since you’re wrapping the value in an object. Modifying the object through one reference will affect all other references pointing to the same object. This approach is flexible, especially when working with scenarios requiring more complex data structures.

#4

For advanced use cases where you need a lightweight reference without affecting the reference count, Python’s weakref module can help. It creates weak references that simulate pointer-like behavior.

import weakref

class MyClass:
    def __init__(self, value):
        self.value = value

a = MyClass(1)
b = weakref.ref(a)  # Create a weak reference to 'a'
a.value = 2
print(b().value)  # Output: 2, since 'b' refers to 'a'

Using weakref is useful in memory-sensitive applications where you don’t want to prevent garbage collection of the object. However, be cautious: if the original object is deleted, attempting to access it via the weak reference will return None.