Updating referenced variables in functions in python

Question

I'm trying to change the order of the matrix X through class P, which is already passed to a function in the base class B. The change in order does not reflect in the base class B. Is there a way to achieve this? Please see the following MWE:

#p.py
import numpy as np
import b

class P(b.B):

    def __init__(self, opts):
        self.opts = opts

    def func1(self, X):

        print('func1:',X)

    def func2(self):

        randomize = np.arange(len(self.myX))
        np.random.shuffle(randomize)
        self.myX = self.myX[randomize]

        print('func2',self.myX)

    def func3(self, X):
        """
        X is a 2d matrix 
        """
        self.myX = X
        #call the function from the base class 
        b.B.func3(self, self.myX)  

#b.py
class B:
    """
    base class.

    """
    def __init__(self, opts):
        self.opts = opts


    def func3(self, X):

        for n in range(2):
            for i in range(X.shape[0]):
                self.func1(X[i])
            self.func2()

from the console:

p1 = p.P({})
X=np.array([[1,2,3], [2,3,4], [3,4,5], [4,5,6], [5,6,7], [6,7,8]])
p1.func3(X)

Current Output:

func1: [1 2 3]
func1: [2 3 4]
func1: [3 4 5]
func1: [4 5 6]
func1: [5 6 7]
func1: [6 7 8]
func2 [[6 7 8]
 [3 4 5]
 [2 3 4]
 [5 6 7]
 [4 5 6]
 [1 2 3]]
func1: [1 2 3]
func1: [2 3 4]
func1: [3 4 5]
func1: [4 5 6]
func1: [5 6 7]
func1: [6 7 8]

Expected Output:

func1: [1 2 3]
func1: [2 3 4]
func1: [3 4 5]
func1: [4 5 6]
func1: [5 6 7]
func1: [6 7 8]
func2 [[6 7 8]
 [3 4 5]
 [2 3 4]
 [5 6 7]
 [4 5 6]
 [1 2 3]]
func1: [6 7 8]
func1: [3 4 5]
func1: [2 3 4]
func1: [5 6 7]
func1: [4 5 6]
func1: [1 2 3]

So basically, when the control returns from p.func2 to func3 in B, X should be the same as self.myX. I believe this should happen because self.myX is by default passed by reference to b.func3.

Answer 1

The problem is here:

#class p.P
    def func2(self):

        randomize = np.arange(len(self.myX))
        np.random.shuffle(randomize)
        self.myX = self.myX[randomize]  # <-- this line

        print('func2',self.myX)

You effectively reassigned self.myX to a new randomized np array, changing the object reference away from X to this new randomized array.

If you added a print(id(self.myX)) between this line, you'll notice the initial reference points back to X, but once you reassigned it, the id is not longer the same.

You should do this instead to maintain the reference:

np.random.shuffle(self.myX)

If you actually wanted to shuffle the inner array as well:

for arr in self.myX:
    np.random.shuffle(arr)
np.random.shuffle(self.myX)

This will also maintain the reference.

Edit: If you wish to keep a reference of the randomized order while still maintaining the object, it's a bit trickier but doable:

# use make randomize an instance attribute so you can refer to it even after the function ended
self.shuffle_order = np.arange(len(self.myX))
np.random.shuffle(self.shuffle_order)

# loop through each inner array and reassign based on a copy of the shuffled matrix
for i, arr in enumerate(self.myX[self.shuffle_order]):
    self.myX[i] = arr

This changes the inner array but maintain the overall object reference between self.myX and X.

Afterwards you can retrieve the order via p1.shuffle_order.