Arevos

vars() gives you direct access to the references in the current scope. vars().clear() will therefore remove all references in the current scope, which isn't a good idea. So in retrospect it's probably best to copy it before returning it:

free-zombie

*args is more like va_list with friends.

Sane

So, would that mean that returning vars() (without copying it first), would be handing off variables that refer to memory locations inside that scope? The scope that no longer exists because the function has ended? Or do the variables still exist in memory after the function has ended? I'll play with this a bit. You also didn't really answer my question. I know what's happening, what I don't know is if it has any impact on Python. If vars is actually an essential part of Python, or some sort of representation therein.

Dawei, I've sent you a PM.

Arevos

The scope is essentially just a dictionary, and it behaves the same as any other object. It's garbage collected only when no references to it exist. Since you're passing vars() out as an argument, a reference to it still exists, and therefore the scope dictionary still exists.

In a sense, you're persisting the scope of a function after the function has ended. Hmm. Interesting to think what you could do with that.

Sane

Wow, when you step back and it look at it for a second, it's really working on so many dependancy levels. It boggles my mind at least, not saying much however. :p

By the way, I'm not sure if you saw my post edit? It wasn't included in your quote. I'll assume you hadn't seen it.

Arevos

I'm sorry, I don't understand the question. If you're worried about it affecting the internals (which it shouldn't do beyond the scope of its operation), you can aways copy the data to a nice, safe, normal dict object.

Sane

I was referring to my earlier question.

I guess what I'm asking is what the hell vars actually is? :p Is it some make belief object that masks what's really happening, or do you really have that much control over the internals of Python?

It seems strange that I can delete "vars" and still be able to declare variables and use them.

Dameon

Emphasis my own

Since you aren't supposed to modify it, that leaves the actual implementation with the option to return a proxy/reference to the internal symbol table rather than a copy. Certainly good for efficiency. The point is, it doesn't matter how much "control" you are given as a result of implementation...the behavior is ultimately undefined, so a little hack that happens to work today might not work a few releases from now.

__________________
MD5(sig) = bcef75433db02e9ad9bf81d6f7c5c270

free-zombie

vars() is just a copy of the local variables as changes do nothing. globals() gives you an object who's changes are propagated into the global namespace, but the deletition of a globals() output is completely harmless since python retains a copy and thus only a reference is deleted.

EDIT: ok, I guess my first sentence was wrong.
EDIT2: it looks like python2.3.5 gives you a copy when calling vars, except in the global namespace, where vars acts like globals.