<snip>
> 3) using the bare name:
> whatever
> 1) and 2) are useful when the desired name is variable, not a constant like
> "whatever".
I thought that went without saying.
> > I have been using #1 for two reasons. First, I will never run this
> > module directly, so __name__ will always be the module name and not
> > "__main__".
>
> (note that it works even with __main__)
Nice. Thanks.
> > Second, I can use this in a class to decide whether I want
> > the module where the class came from or, if I make the class a base
> I don't completely understand your use case. In the expression:
> getattr(some_module, attribute_name)
> you may use any module as the first argument (the current module, or any
> other).
Right, I was just confused about the effects of inheritance and scope.
If I put a method in a baseclass, which is inherited in another
module, and then run the method from an instance of the sub-class...
- "sys.modules[__name__]" returns the baseclass module.
- "sys.modules[self.__class__.__module__]" returns the subclass
module.
in the end I found it felt more logical to put the code in a module-
level function and call it from the class. All of this was part of a
fairly large factory method implementation.
I now know that globals() refers to module-level names. The pros and
cons were the main point of this thread and so far I have...
1) getattr(module, "whatever") seems the most pythonic way to do it
but it takes more than one line and requires a little more thought
about scope and inheritance.
2) globals()["whatever"] is concise, but it seems a little like a
shortcut which requires special knowledge (though a very small
amount).
I did a quick benchmark test:
< tmp2.py >
import time
import sys
import tmp
class A(tmp.A): pass
class B(tmp.A): pass
class C(tmp.A): pass
class D(tmp.A): pass
class E(tmp.A): pass
class F(tmp.A): pass
class G(tmp.A): pass
class H(tmp.A): pass
class I(tmp.A): pass
class J(tmp.A): pass
def test_globals_vs_gettattr():
t1 = time.time()
for i in range(0, 1000000):
H = globals()["H"]
t2 = time.time()
print "globals() too %s seconds." % str(t2-t1)
t1 = time.time()
mod = sys.modules[__name__]
for i in range(0, 1000000):
H = getattr(mod, "H")
t2 = time.time()
print "getattr() too %s seconds." % str(t2-t1)
< /tmp2.py >
tmp.py just has a simple class in it. I just wanted to add some
complexity, but I doubt this had any affect on the times.
>>> import tmp2
>>> tmp2.test_globals_vs_gettattr()
globals() too .146900010109 seconds.
getattr() too .434299993515 seconds.
Just to see how much the call to sys.modules was affecting the test, I
moved it outside the loop and reloaded the module for a second test.
>>> reload(tmp2)
<module 'tmp2' from '\\nas6tb\PROJECTS\tech\users\rafe.sacks\python
\tmp2.py'>
>>> tmp2.test_globals_vs_gettattr()
globals() too .139100003242 seconds.
getattr() too .254600000381 seconds.
This second test is pointless in practice since I would be calling
sys.modules each time anyway.
Even though the getattr() way is around 3.5 times slower, I had to run
the code 1,000,000 times before the difference became humanly
recognizable. I also realize benchmarks should be taken with a grain
of salt since my setup may differ greatly from others'.
I guess, in the end, I'd use getattr() because it feels more pythonic,
and more basic. I got pretty deep in to learning python before I had
to learn what the globals() dict could do for me.
Cheers,
- Rafe
--
http://mail.python.org/mailman/listinfo/python-list
