Why do I need np.array() or np.copy()?

Question

A real numpy newbie question here.

I have an numpy array called 'image'. Doing this:

image2 = image
image2[image < minval] = minval
image2[image > maxval] = maxval

...changes the contents of 'image'.

I gather that's because variables in Python are really references, so 'image2' is just another way of referring to 'image'. So I'm supposed to use "image2 = np.copy(image)". Fine.

But, then, why doesn't 'a' change when I do this:

a = 5
b = a
b = 7

Isn't 'b' just another way of referring to 'a'? If so, why doesn't a==7 at the end of this?

I want to know if there's some mental model that makes this seem consistent. Because it doesn't.

Answer 1

The answer really lies in the way direct assignments like b=a and b=7 work. b=a creates a new reference to the object also referenced by a , and associates that new reference with the name b . The subsequent b=7 then removes the reference that was attached to the name b , and makes a different association with the name b . This will be true whether a is an immutable type (like an integer) or a mutable type (like a numpy array). In neither case will the content of a be modified.

By contrast, image2[image < minval] = minval is not a reassignment. Via its use of [] it calls a method ( __setitem__ ) of the object image2 . This method changes parts of the underlying data structure without reassigning anything to image2 .

Python's most fundamental types are "immutable". This means that nothing you can do will change them (for example, if image2 were of the immutable type tuple , trying to change one of its elements with [] indexing would cause an exception to be raised).

As a result, very very loosely , if you're accustomed to a C/C++ mindset, it can sometimes help to think of immutable types as being passed by value and mutable types being passed by reference when you're looking at a function or method prototype. As pointed out in the comments, though, this is not really what happens: everything is a reference, but some references (the immutable types) are automatically treated the way C/C++ would treat const references.

The immutable types include:

• basic numeric types: bool , int , long , float and complex
• basic string types: str , unicode (python 2.x only) and bytes (python 3.x only)
• tuple (but not list )