1

The Hitchhiker’s Guide to Python states that it's good to reuse variable names.

foo = Spam()
bar = foo.eggs()

And I agree w/ it. It makes code readable.

What if the variable is 40 MB of data? Will it copy itself and have 80 MB at total?

foo = buffer  # 40 MB.
bar = foo.resize((50, 50))  # +40?

I know that memory will be released when function will be executed, but I still don't think that it's a good idea to have like two times higher memory usage at one state of app only because of readability. It's like a special case, but on the other hand, special cases aren't special enough, huh?

Improve this question

2 Answers 2

Reset to default
6

Python assignment just copy the reference value to the target object. There is no data copying. Python variable is just the name in a Python system dictionary plus the value which is the reference value to the object.

Actually, you should be careful with assignments. Any Python assignment means sharing the reference value. Python assignment never means copying the target object. When working with immutable objects like strings or numbers, no problem can appear. However, when you assign any mutable object (a list, a dictionary, a set, some user object), you should know that after that you are only giving the target object a different name (access via another copy of the reference value).

The same holds for passing the object as a function/method argument.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

There is no such thing as a "variable" in Python. Its all references.
This is true, but not the only place that copying can happen - foo.resize appears to return its result, which implies that it creates a new buffer and returns it, rather than working in-place. This means that that data could, indeed, exist twice.
I see. But the question contains the foo = buffer, which is the sharing. The .resize is the method of the pointed target. I do not know what it does exactly. If the bar is the core of the question, then the earlier target pointed to by bar is released and the bar is reused for another purpose.
4

If you absolutely must have that data entirely in memory before you resize it (rather than only reading in the bits you care about), you can do this:

foo = buffer()
bar = foo.resize((50, 50))
del foo

or equivalently:

bar = buffer().resize((50, 50))

both of these make the result of buffer immediately available for garbage collection as soon as this code is run.

Also, it can be perfectly reasonable to reuse the variable name in this case - if the lines are immediately one after the other in your code, and especially if foo.resize returns the same type of object as foo (as it seems to), then:

foo = buffer
foo = foo.resize((50, 50))

is perfectly fine. The advice is to not reuse the name for a completely unrelated variable - so that a person reading your code can see the variable and just skip up to wherever it was first assigned to understand what it is. When one of them is just a one-off "stepping stone" to get the actual object you care about, there's only a trivial risk of confusing a reader.

Improve this answer

1 Comment

Good use of del, if you are working with large objects, freeing up the unused objects of gc early can make a huge difference on performance, especially in multi-threaded code where the gc could collect mid function, multiple times due to some other thread. This is especially true if the data being created and discarded is a list or similar, not to mention the memory savings.

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.