What z += 3 means is basically advance the pointer 3 elements down. Say you have a pointer to an array in C called lst which contains [1, 2, 3, 4]. The pointer lst points to the first element such that *lst is equivalent to lst[0]. Furthermore, *(lst+1) is equivalent to lst[1].

There are two potential issues.

First, you seem to be relying on your __getattribute__ implementation to let the interpreter find the right __add__ method. Unfortunately, I have noticed that the Python interpreter often has trouble finding special functions, like __add__ or __call__ if they are created on the fly (that is, not made an explicit part of the class when the class is defined). The manuals explicitly acknowledge this, at least for new-style classes:

For new-style classes, implicit invocations of special methods are only guaranteed to work correctly if defined on an object’s type, not in the object’s instance dictionary.

although it seems to me that I have had problems with similar tricks even with old-style classes.

Second, just redirecting __add__ won't be enough. Even if the interpreter successfully reduces

a + b

to

float.__add__( 1.22, b )

the float class still doesn't know how to add a float to a ref. So your __add__ will have to explicitly dereference the target (and dereference that if it's an indirect reference (and dereference that...) Like so:

class ref:
    def __init__(self, obj):
        self.obj = obj
    def get(self): return self.obj
    def set(self, obj): self.obj = obj
    def __str__(self): return self.obj.__str__()
    def __add__( self, other ):
        while isinstance( other, ref ):
            other = other.obj
        return self.obj.__add__( other )

a = ref(1.22)
b = ref(a)

print a
print b

print a + b

The while loop in __add__makes sure that you've unpacked all of the nested refs all the way to the base object.

If I were doing this, and I have used similar constructs to implement proxy patterns, I would refactor so that the while loop is in its own method, say getBaseObject(), and then is called from every time we need the object that is at the actual base of the chain of refs.

I suppose if you want to do something like that you could do the following:

# list we want to mutate
sort_list = [1,2,3,4,5,6,7,8,9,0]

#wrapper just so everything looks pretty, process could go here if we wanted
def wrapper(a, numlems):
    cut = len(a) - numlems
    # overwrites a part of the list with another one
    a[cut:] = process(a[cut:])

# processing of the slice
def process(a):
    # just to show it works
    a[1] = 15
    return a

wrapper(sort_list, 2)
print(sort_list)

wrapper(sort_list, 4)
print(sort_list)

wrapper(sort_list, 6)
print(sort_list)

This is probably considered pretty evil in python and I wouldn't really recommend it, but it does emulate the functionality you wanted.

For python you only really need:

def quicksort(inputList, startIndex):

Then creating and concatenating slices would work fine without the need for pointer like functionality.

You may want to read Semantics of Python variable names from a C++ perspective. The bottom line: All variables are references.

More to the point, don't think in terms of variables, but in terms of objects which can be named.

self.comps[N].position = [1,2,3,4]

will set self.comps[N].position to be a new list. If there are other references to the old list that was self.comps[N].position, they will not be changed.

Example

x=[1,2,3]
y=x
print y #[1, 2, 3]
x[1]=4
print y #[1, 4, 3]
x=[4,5,6]
print y #[1, 4, 3]

You can also use ctypes.cast(buf, ctypes.c_void_p)

Without any source code references, this issue is a little harder to figure out than it should be.

With that said, my first bet is going to be that your Char* type is an “opaque” reference, so when you go to dereference it LLDB knows nothing about the pointee type and can’t resolve it. Or maybe the pointee type is not a basic type (int, char, float, …) and as such does not have a value (values are essentially a scalar property, a structure or a class or a union do not have values, they have members)

Can you publish the definition of your string type?

Working from there, there are a couple ways to extract a chunk of data from a memory location. Is your string ASCII/UTF8 encoded? If so, you could just use Process.ReadCStringFromMemory giving it the value of the pointer. That would read until the first 0 terminator is found, or until a certain maximum length is reached (you want that to avoid reading unbounded amounts of data from garbled memory)

If that is not the case, there are other approaches.

Again, the more information you can provide about the internals of your data structure, the easier it gets to write a formatter for it.

I want form.data['field'] and form.field.value to always have the same value

This is feasible, because it involves decorated names and indexing -- i.e., completely different constructs from the barenames a and b that you're asking about, and for with your request is utterly impossible. Why ask for something impossible and totally different from the (possible) thing you actually want?!

Maybe you don't realize how drastically different barenames and decorated names are. When you refer to a barename a, you're getting exactly the object a was last bound to in this scope (or an exception if it wasn't bound in this scope) -- this is such a deep and fundamental aspect of Python that it can't possibly be subverted. When you refer to a decorated name x.y, you're asking an object (the object x refers to) to please supply "the y attribute" -- and in response to that request, the object can perform totally arbitrary computations (and indexing is quite similar: it also allows arbitrary computations to be performed in response).

Now, your "actual desiderata" example is mysterious because in each case two levels of indexing or attribute-getting are involved, so the subtlety you crave could be introduced in many ways. What other attributes is form.field suppose to have, for example, besides value? Without that further .value computations, possibilities would include:

class Form(object):
   ...
   def __getattr__(self, name):
       return self.data[name]

and

class Form(object):
   ...
   @property
   def data(self):
       return self.__dict__

The presence of .value suggests picking the first form, plus a kind-of-useless wrapper:

class KouWrap(object):
   def __init__(self, value):
       self.value = value

class Form(object):
   ...
   def __getattr__(self, name):
       return KouWrap(self.data[name])

If assignments such form.field.value = 23 is also supposed to set the entry in form.data, then the wrapper must become more complex indeed, and not all that useless:

class MciWrap(object):
   def __init__(self, data, k):
       self._data = data
       self._k = k
   @property
   def value(self):
       return self._data[self._k]
   @value.setter
   def value(self, v)
       self._data[self._k] = v

class Form(object):
   ...
   def __getattr__(self, name):
       return MciWrap(self.data, name)

The latter example is roughly as close as it gets, in Python, to the sense of "a pointer" as you seem to want -- but it's crucial to understand that such subtleties can ever only work with indexing and/or decorated names, never with barenames as you originally asked!