You did not modify the elements of the original array, but rather re-assigned a new list to the arr variable. Your intuition of thinking changes to elements would be reflected in arr1 if you properly accessed its elements is indeed true as lists are mutable in Python. For instance,

arr = [1,2,3]
arr1 = arr
arr[1] = 4
print(arr1) #this prints [1,4,3]

when you did graph[1][2]['data'] = test[0] you took the current value of test[0] and put it in the graph. when you did test[0] = False you changed the value of test[0] to point to a diffrent value, but the graph point to the old value.

a simplified example of your case can be:

x = 1
y = x
x = 2
print y # will print 1

Since you changed x's its value, but y referenced the old value. in python when you assign (use =) you take the value of the right side and place it on the left side, but in your case when you did test[0] = False you didnt change the value, you overriden it with a diffrent value.

if you want to change something and have it shared, you need to manipulate the same instance, for example:

class A(object):
    def __init__(self):
        self.x = 1
y = A()
lst = []
lst.append(y)
y.x += 1
print lst[0].x # will print 2

here the instance of A was shared so the value change was visible by accessing it with the list

In Python, all variable names are references to values.

When Python evaluates an assignment, the right-hand side is evaluated before the left-hand side. arr - 3 creates a new array; it does not modify arr in-place.

arr = arr - 3 makes the local variable arr reference this new array. It does not modify the value originally referenced by arr which was passed to foo. The variable name arr simply gets bound to the new array, arr - 3. Moreover, arr is local variable name in the scope of the foo function. Once the foo function completes, there is no more reference to arr and Python is free to garbage collect the value it references. As Reti43 points out, in order for arr's value to affect a, foo must return arr and a must be assigned to that value:

def foo(arr):
    arr = arr - 3
    return arr
    # or simply combine both lines into `return arr - 3`

a = foo(a)

In contrast, arr -= 3, which Python translates into a call to the __iadd__ special method, does modify the array referenced by arr in-place.

You can't create a reference to a single element, but you can get a view over that single element:

>>> x = numpy.arange(10)
>>> y = x[3:4]
>>> y[0] = 100
>>> x
array([0, 1, 2, 100, 4, 5, 6, 7, 8, 9])

The reason you can't do the former is that everything in python is a reference. By doing y = 100, you're modifying what y points to - not it's value.

If you really want to, you can get that behaviour on instance attributes by using properties. Note this is only possible because the python data model specifies additional operations while accessing class attributes - it's not possible to get this behaviour for variables.

This seems like a really bad idea, but it also seems like a fun problem so here is my crack at it:

class MyProxy(object):
    def __init__(self, obj, key):
        super(MyProxy, self).__setattr__('obj', obj)
        super(MyProxy, self).__setattr__('key', key)

    def __getattr__(self, name):
        return getattr(self.obj, name).__getitem__(self.key)

    def __setattr__(self, name, value):
        return getattr(self.obj, name).__setitem__(self.key, value)

class MyClass(object):
    def __init__(self, array_length):
        self.array_length = array_length

    def __getitem__(self, key):
        if key >= self.array_length:
            raise IndexError
        return MyProxy(self, key)

Example:

>>> obj = MyClass(4)  # replace 4 with the length of your arrays
>>> obj.array1 = [1, 2, 3, 4]
>>> obj.array2 = [5, 6, 7, 8]
>>> for c in obj:
...     print c.array1, c.array2
... 
1 5
2 6
3 7
4 8
>>> obj[1].array1
2
>>> obj[1].array1 = 5
>>> obj.array1
[1, 5, 3, 4]