3

I know that "variable assignment" in python is in fact a binding / re-bindign of a name (the variable) to an object.

This brings the question: is it possible to have proper assignment in python, eg make an object equal to another object?

I guess there is no need for that in python:

  1. Inmutable objects cannot be 'assigned to' since they can't be changed

  2. Mutable objects could potentially be assigned to, since they can change, and this could be useful, since you may want to manipulate a copy of dictionary separately from the original one. However, in these cases the python philosophy is to offer a cloning method on the mutable object, so you can bind a copy rather than the original.

So I guess the answer is that there is no assignment in python, the best way to mimic it would be binding to a cloned object

I simply wanted to share the question in case I'm missing something important here

Thanks

EDIT:

Both Lie Ryan and Sven Marnach answers are good, I guess the overall answer is a mix of both:

For user defined types, use the idiom:

a.dict = dict(b.dict)

(I guess this has problems as well if the assigned class has redefined attribute access methods, but lets not be fussy :))

For mutable built-ins (lists and dicts) use the cloning / copying methods they provide (eg slices, update)

finally inmutable built-ins can't be changed so can't be assigned

I'll choose Lie Ryan because it's an elegant idiom that I hadn't thought of.

Thanks!

Improve this question
1
  • Are you asking about a deep copy? Is that what you mean by "binding to a cloned object"? Commented Nov 17, 2010 at 11:58

3 Answers 3

Reset to default
4

I think you are right with your characterization of assignment in Python -- I just would like to add a different method of cloning and ways of assignment in special cases.

"Copy-constructing" a mutable built-in Python object will yield a (shallow) copy of that object:

l = [2, 3]
m = list(l)
l is m
--> False

[Edit: As pointed out by Paul McGuire in the comments, the behaviour of a "copy contructor" (forgive me the C++ terminology) for a immutable built-in Python object is implementation dependent -- you might get a copy or just the same object. But because the object is immutable anyway, you shouldn't care.]

The copy constructor could be called generically by y = type(x)(x), but this seems a bit cryptic. And of course, there is the copy module which allows for shallow and deep copies.

Some Python objects allow assignment. For example, you can assign to a list without creating a new object:

l = [2, 3]
m = l
l[:] = [3, 4, 5]
m
--> [3, 4, 5]

For dictionaries, you could use the clear() method followed by update(otherdict) to assign to a dictionary without creating a new object. For a set s, you can use

s.clear()
s |= otherset
Improve this answer
Sign up to request clarification or add additional context in comments.

9 Comments

Your "copy constructor" assumptions may hold true for the built-in Python classes, but they are not generally guaranteed for all classes and objects. I can very easily create an immutable class that takes an instance of itself for construction, but makes an entirely different object with the same values, such that copy == original is True, but copy is original is False.
I just noticed that you already qualified your answer to restrict it to the built-in classes.
A brief experiment with Jython 2.5.0 shows that this does not hold true for strings. : >>> a = "SLJDFSDLJ" >>> b = str(a) >>> b is a False - what you have described is an implementation optimization specific to CPython, but not guaranteed by the Python language spec.
For your own classes, you can always add some kind of assign() method if you need it -- that's why I focussed on the built-in types.
@Paul McGuire: I'm surprised! I just tested with Python 2.6.6 and I get True... To be honest, I'm really not sure any more the behaviour I described is guaranteed. I will investigate...
|
3

This brings the question: is it possible to have proper assignment in python, eg make an object equal to another object?

Yes you can:

a.__dict__ = dict(b.__dict__)

will do the default assignment semantic in C/C++ (i.e. do a shallow assignment).

The problem with such generalized assignment is that it never works for everybody. In C++, you can override the assignment operator since you always have to pick whether you want a fully shallow assignment, fully deep assignment, or any shade between fully deep copy and fully shallow copy.

Improve this answer

Comments

1

I don't think you are missing anything.

I like to picture variables in python as the name written on 'labels' that are attached to boxes but can change its placement by assignment, whereas in other languages, assignment changes the box's contents (and the assignment operator can be overloaded).

Beginners can write quite complex applications without being aware of that, but they are usually messy programs.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.