从vars（）和dict = {}创建的词典有什么区别？

Question

After reading about vars(), I am still a little confused on what it is actually doing. In looking at the Python documentation, "The vars() function returns the __ dict __ attribute of the given object if the object has __ dict __ attribute." So, it returns a dictionary object? Here are the questions I am really getting at:

1) What is vars() actually doing in the below code?

dict = {}
dict['H'] = atom
vars()[dict['H']] = 20

2) Why is the vars() necessary in front of the dictionary I created and could I leave it out? (I know the code fails if I leave it out, but what would be a different way of accomplishing the same task?)

dict = {}
dict['H'] = atom
dict['H'] = 20

Answer 1

What is vars() actually doing in the below code?

It does what it always does: it retrieves all local variables as a dictionary. That's how it works when calling vars without arguments.

Why is the vars() necessary in front of the dictionary I created and could I leave it out?

It seems that someone is doing shenanigans with the local scope. It's just that it is wrapped with dict['H'] which is just some variable (possibly atom is a string). In other words he's trying to retrieve a variable by dynamic name. For example

>>> test = 15
>>> x = 'test'
>>> vars()[x]
15

This should be avoided at all costs. Forget you even know about the existance of vars() . I do not know a single case when you have to use vars() instead of a dict or some other "normal" (and in this context safe) structure. The code you are looking at is insanely difficult to maintain, error prone and has serious security issues.

Answer 2

1) What is vars() doing in the below code

Honestly, it's hard to tell. vars() (without an argument) returns the local namespace as a dictionary. In other words, it does the same thing as locals() . In your code, you then look up a name ( dict['H'] ) in the locals dict and set an item in there. Setting an item in the dict returned by locals() does nothing if you are in a function... If you are in the global namespace, it adds an attribute.

2) Why is the vars() necessary in front of the dictionary I created and could I leave it out?

It probably isn't necessary and you probably should leave it out. Normally dynamically setting attributes on the global namespace is a really bad idea. You should generally pass around a dictionary of the data that you need instead. In other words, you can do:

v = 'foo'
globals()[v] = 'bar'
# ...
value = globals()[v]  # 'bar'

But you shouldn't . It's much better to just pass a dictionary around:

v = 'foo'
dct = {v: 'bar'}
# ...
value = dct[v]

Answer 3

First, you shouldn't overwrite __builtin__ functions. dict is a reserved name for a function used to create dictionary objects.

Second, var gives you access to name declarations within the current running scope.