Numpy array values changed without being aksed?

Question

I have 2 vectors, posVec and dirVec who's value I woudl like to keep at (0.0,0.0,0.0).

So I set up temporary vectors t_pos & t_dir and change their values depending on the value of cylCut

Then on the next iteration of the loop I reset the temporary vectors.

The code:

import numpy as np

posVec = np.array([0.0,0.0,0.0]) # orginal vectors
dirVec = np.array([0.0,0.0,0.0])
print "................."
print 'Before'
print "................."
print posVec
print dirVec
print "................."

for cylCut in range(0,3):
    t_pos = posVec      # temporary vectors
    t_dir = dirVec
    if cylCut == 0:     # set temp vects accordingly
        print '0'
        t_pos[0] = 1.0
        t_dir[0] = 1.0
    if cylCut == 1:
        print '1'
        t_pos[1] = 1.0
        t_dir[1] = 1.0
    if cylCut == 2:
        print '2'
        t_pos[2] = 1.0
        t_dir[2] = 1.0
    print t_pos
    print t_dir

print "................."
print 'After'
print "................."
print posVec
print dirVec
print "................."

For an unknown reason (to me at least) the contents of posVec & posDir are also being changed.

The output I'm getting,

.................
Before
.................
[ 0.  0.  0.]
[ 0.  0.  0.]
.................
0
[ 1.  0.  0.]
[ 1.  0.  0.]
1
[ 1.  1.  0.]
[ 1.  1.  0.]
2
[ 1.  1.  1.]
[ 1.  1.  1.]
.................
After
.................
[ 1.  1.  1.]
[ 1.  1.  1.]
.................

Why is this happening? At not point am I explicitly changing the vectors. Does Python/Numpy automatically link variable? Why would you do that? How do I stop it?

Does this answer your question? [List changes unexpectedly after assignment. Why is this and how can I prevent it?](https://stackoverflow.com/questions/2612802/list-changes-unexpectedly-after-assignment-why-is-this-and-how-can-i-prevent-it) — Thomas Weller, Mar 04 '22 at 12:01

daniel451 · Accepted Answer · 2015-06-06T13:23:54.227

This is happening because with

t_pos = posVec
t_dir = dirVec

You are not copying the contents of the vectors but you copy their references. So basically t_pos and posVec are pointing to the very same numpy array object.

What you want to do is:

t_pos = numpy.copy(posVec)
t_dir = numpy.copy(dirVec)

EDIT: Differences for copy methods:

  1 import timeit                                                                                                       
  2 import copy  
  3 import numpy as np
  4              
  5 someArr = np.arange(100)
  6              
  7 def copy1(): 
  8     tempArr = someArr.copy()
  9              
 10 def copy2(): 
 11     tempArr = np.copy(someArr)
 12              
 13 def copy3(): 
 14     tempArr = copy.copy(someArr)
 15              
 16 def copy4(): 
 17     tempArr = copy.deepcopy(someArr)
 18              
 19 print ("copy1: " + str(timeit.timeit(lambda: copy1(), number=1000000)))
 20 print ("copy2: " + str(timeit.timeit(lambda: copy2(), number=1000000)))
 21 print ("copy3: " + str(timeit.timeit(lambda: copy3(), number=1000000)))
 22 print ("copy4: " + str(timeit.timeit(lambda: copy4(), number=1000000)))

Prints the following output (in seconds):

copy1: 0.5677032630010217
copy2: 1.473885050001627
copy3: 1.2420436849988619
copy4: 2.733253653999782

So yes, there are huge differences but only in terms of used computation resources. The results for your example stay exact the same.

someArr.copy() refers to the object you already have saved in memory, so accessing this is the fastest way and every numpy array holds such a method, so basically you are accessing the method of your already created numpy array.

np.copy(someArr) calls the copy-method of the numpy library, therefore it is slower, because it (as far as I know) produced some overhead with creating a temporary instance.

copy.copy(someArr) is the python (non-numpy) way to copy objects generally. I am a bit confused that it performs slightly better than the numpy way...because of its generality (for nearly all objects) it should perform worse...at least I thought that.

copy.deepcopy(someArr) clearly performs worst but it is important to remember it. Deepcopy not only creates a copy of your object (someArr) but it also creates new, fresh copies of every element in your array. So if you have objects (references) stored in your array, you will face the same problem you did. Therefore deepcopy is used and of course creating not only a copy of your array, but also of every element in it takes the most time.

Thanks I had no idea. Is there any difference between numpy.copy(posVec) and posVec.copy()? — DrBwts, Jun 06 '15 at 13:14
The overhead is the function call not creating any instances — Padraic Cunningham, Jun 06 '15 at 13:35

Padraic Cunningham · Answer 2 · 2015-06-06T13:11:12.220

You would need to copy, you are referencing the original arrays so changes in one would be reflected in the other:

t_pos = posVec.copy()    
t_dir = dirVec.copy()

You can check the identity of the objects using the id function:

In [2]: posVec = np.array([0.0,0.0,0.0]) # orginal vectors    
In [3]: dirVec = np.array([0.0,0.0,0.0])    
In [4]: a = posVec    
In [5]: id(a)
Out[5]: 140204693413040    
In [6]: id(posVec) # same object so same id
Out[6]: 140204693413040    
In [7]: a = posVec.copy()    
In [8]: id(posVec) 
Out[8]: 140204693413040
In [9]: id(a)
Out[9]: 140204688418096 # new object so new id

The only time you would get caught checking the id would be using basic indexing with a numpy array:

In [10]: posVec = np.array([0.0,0.0,0.0]) # orginal vectors    
In [11]: a = posVec[:2]    
In [12]: id(a)
Out[12]: 140204688417456    
In [13]: id(posVec)
Out[13]: 140204688417776    
In [14]: a[0] = 99    
In [15]: a
Out[15]: array([ 99.,   0.])  
In [16]: posVec
Out[16]: array([ 99.,   0.,   0.])

Basic slicing returns a view which is An array that does not own its data, but refers to another array’s data instead

Numpy array values changed without being aksed?

2 Answers2

Linked