How to define global function in Python?

Question

Is there a way to define a function to be global from within a class( or from within another function, as matter of fact)? Something similar to defining a global variable.

Answer 1

You can use global to declare a global function from within a class. The problem with doing that is you can not use it with a class scope so might as well declare it outside the class.

class X:
  global d
  def d():
    print 'I might be defined in a class, but I\'m global'

>> X.d

   Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
   AttributeError: 'X' object has no attribute 'd'

>> d()

I might be defined in a class, but I'm global

Answer 2

I found a case where global does not have the desired effect: inside .pdbrc file. If you define functions in .pdbrc they will only be available from the stack frame from which pdb.set_trace() was called.

However, you can add a function globally, so that it will be available in all stack frames, by using an alternative syntax:

def cow(): print("I'm a cow")
globals()['cow']=cow

I've tested that it also works in place of the global keyword in at least the simplest case:

def fish():
    def cow(): 
        print("I'm a cow")
    globals()['cow']=cow

Despite being more verbose, I thought it was worth sharing this alternative syntax. I have not tested it extensively so I can't comment on its limitations vs using the global keyword.

Answer 3

Functions are added to the current namespace like any other name would be added. That means you can use the global keyword inside a function or method:

def create_global_function():
    global foo
    def foo(): return 'bar'

The same applies to a class body or method:

class ClassWithGlobalFunction:
    global spam
    def spam(): return 'eggs'

    def method(self):
        global monty
        def monty(): return 'python'

with the difference that spam will be defined immediately as top-level class bodies are executed on import.

Like all uses of global you probably want to rethink the problem and find another way to solve it. You could return the function so created instead, for example.

Demo:

>>> def create_global_function():
...     global foo
...     def foo(): return 'bar'
... 
>>> foo
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'foo' is not defined
>>> create_global_function()
>>> foo
<function foo at 0x102a0c7d0>
>>> foo()
'bar'
>>> class ClassWithGlobalFunction:
...     global spam
...     def spam(): return 'eggs'
...     def method(self):
...         global monty
...         def monty(): return 'python'
... 
>>> spam
<function spam at 0x102a0cb18>
>>> spam()
'eggs'
>>> monty
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'monty' is not defined
>>> ClassWithGlobalFunction().method()
>>> monty()
'python'