Prev: Updating values in a dictionary
Next: Qt and progressBar - how to update
From: TomF on 19 May 2010 03:16
On 2010-05-16 12:27:21 -0700, christian schulze said:

> On 16 Mai, 20:20, James Mills <prolo...(a)shortcircuit.net.au> wrote:
>> On Mon, May 17, 2010 at 4:00 AM, Krister Svanlund
>>
>> <krister.svanl...(a)gmail.com> wrote:
>>> On Sun, May 16, 2010 at 7:50 PM, AON LAZIO <aonla...(a)gmail.com> wrote:
>>>> �� How can I set up global variables for the entire python applications?
>>>> Like I can call and set this variables in any .py files.
>>>> �� Think of it as a global variable in a single .py file but thisis for the
>>>> entire application.
>>
>>> First: Do NOT use global variables, it is bad practice and will
>>> eventually give you loads of s**t.
>>
>>> But if you want to create global variables in python I do believe it
>>> is possible to specify them in a .py file and then simply import it as
>>> a module in your application. If you change one value in a module the
>>> change will be available in all places you imported that module in.
>>
>> The only place global variables are considered somewhat "acceptable"
>> are as constants in a module shared as a static value.
>>
>> Anything else should be an object that you share. Don't get into the
>> habit of using global variables!
>>
>> --james
>
> Exactly! Python's OOP is awesome. Use it. Global vars used as anything
> but constants is bad practice. It isn't that much work to implement
> that.

Let's say you have a bunch of globals, one of which is a verbose flag.
If I understand the difference, using a module gbls.py:
# in gbls.py
verbose = False
# elsewhere:
import gbls
gbls.verbose = True

Using a class:

# In the main module:
class gbls(object):
def __init__(self, verbose=False):
self.verbose = verbose

my_globals = gbls.gbls(verbose=True)
....
some_function(my_globals, ...)


If this is what you have in mind, I'm not really seeing how one is good
practice and the other is bad. The OOP method is more verbose (no pun
intended) and I don't see how I'm any less likely to shoot myself in
the foot with it.

-Tom


From: Steven D'Aprano on 19 May 2010 10:34
On Wed, 19 May 2010 00:16:56 -0700, TomF wrote:

> Let's say you have a bunch of globals, one of which is a verbose flag.
> If I understand the difference, using a module gbls.py:
>
> # in gbls.py
> verbose = False
> # elsewhere:
> import gbls
> gbls.verbose = True
>
> Using a class:
>
> # In the main module:
> class gbls(object):
> def __init__(self, verbose=False):
> self.verbose = verbose
>
> my_globals = gbls.gbls(verbose=True)
> ...
> some_function(my_globals, ...)
>
>
> If this is what you have in mind, I'm not really seeing how one is good
> practice and the other is bad. The OOP method is more verbose (no pun
> intended) and I don't see how I'm any less likely to shoot myself in the
> foot with it.

Exactly! Both are considered harmful. Best is to avoid the use of globals
if possible, not to disguise them by wrapping them in a class.

The second case (using a class) is slightly less harmful, because you can
set up multiple global namespaces and do this:

some_function(my_globals, ...)
some_function(other_globals, ...)

which at least allows you to replace the globals on demand, but it is
still somewhat of a code-smell. Best is to find a way of doing without
them. (Note that global constants and functions are usually fine.)

Unfortunately, it's rarely possible to do entirely without global
settings, except in trivial applications. But what you can do is use
Python's dynamic programming to reduce the need to keep globals hanging
around:


# Untested.
def verbose_print(arg, level, verbosity=1):
if level <= verbosity:
print arg

def my_function(arg):
my_print(arg, level=2)
return arg.upper()

if __name__ == '__main__':
if '--verbose' in sys.argv:
my_print = functools.partial(verbose_print, verbosity=2)
elif '--quiet' in sys.argv:
my_print = functools.partial(verbose_print, verbosity=0)

my_function("hello world")


Note that although there is no verbosity global setting, every function
that calls my_print will do the right thing (unless I've got the test
backwards...), and if a function needs to override the implicit verbosity
setting, it can just call verbose_print directly.


--
Steven
From: TomF on 20 May 2010 14:17


On 2010-05-19 07:34:37 -0700, Steven D'Aprano said:

> # Untested.
> def verbose_print(arg, level, verbosity=1):
> if level <= verbosity:
> print arg
>
> def my_function(arg):
> my_print(arg, level=2)
> return arg.upper()
>
> if __name__ == '__main__':
> if '--verbose' in sys.argv:
> my_print = functools.partial(verbose_print, verbosity=2)
> elif '--quiet' in sys.argv:
> my_print = functools.partial(verbose_print, verbosity=0)
>
> my_function("hello world")
>
>
> Note that although there is no verbosity global setting, every function
> that calls my_print will do the right thing (unless I've got the test
> backwards...), and if a function needs to override the implicit verbosity
> setting, it can just call verbose_print directly.


First  |  Prev  | 
Pages: 1 2 3 4
Prev: Updating values in a dictionary
Next: Qt and progressBar - how to update