How can I do a one-time Initialization? [closed]

Question

In the following script I want to perform the loading of a DLL only once when initializing

import ctypes
import mathutils
from ctypes import *

hmd = None

def poll():
    if hmd is None:
        hmd = ctypes.WinDLL("C:\\Program Files\\Blender Foundation\\Blender\\2.68\\scripts\\addons\\game_engine_rift\\openhmd.dll")
    hmdPoll = hmd.poll
    hmdPoll.argtypes = ()
    hmdPoll.restype = ctypes.POINTER(ctypes.c_float)
    pos = hmdPoll()
    print(pos[0], pos[1], pos[2] ,pos[3])
    bge.logic.rotation = mathutils.Quaternion((pos[0], pos[1], pos[2], pos[3]))

poll()

But I get this error:

Python script error - object 'Camera', controller 'Python1':
Traceback (most recent call last):
  File "rift.py", line 21, in <module>
    poll()
  File "rift.py", line 12, in poll
    if hmd == None:
UnboundLocalError: local variable 'hmd' referenced before assignment

Answer 1

It's because your variable hmd isn't global...
You can declare it as global, with global hmd in your function:

hmd = None

def poll():
    # declare hmd as global so that the function has (write) access to the global var.
    global hmd
    if hmd is None:
        hmd = ctypes.WinDLL ("C:\\Program Files\\Blender Foundation\\Blender\\2.68\\scripts\\addons\\game_engine_rift\\openhmd.dll")

Or send it as parameter when your call poll() (you have to declare it in the function too):

def poll(hmd):
    if hmd == None:
        # (...)

poll(hmd)

Answer 2

The existing answer from @Polosson is correct, however Im a bit biased against globals since I have had to debug other peoples code with many globals - it can become difficult, if the code becomes complex and there are more then 2-3 of them used across multiple functions. It's a pain to keep track of them, forgetting to add a global keyword, it can fail in a non-obvious way.

Store in a global dictionary

Heres an alternative, which I prefer in some cases.

# store all runtime variables here.
runtime = {}
runtime["hmd"] = None

def poll():
    # declare hmd as global so that the function has (write) access to the global var.
    if runtime["hmd"] is None:
        runtime["hmd"] = ctypes.WinDLL("C:\\Program Files\\Blender Foundation\\Blender\\2.68\\scripts\\addons\\game_engine_rift\\openhmd.dll")

You can store the runtime state in a dictionary, and it has some advantages that you can easily print(runtime), runtime.clear()... etc. and pass it to other modules if you end up splitting your code across files.

Because the dictionary its self is never re-assigned, you don't have to define it as global.

Store in the function

Another trick, is you can store the variable in the function (and avoid using globals)

Note that this is not the functions local namespace, which is why it has to be accessed as an attribute of the function, even when inside the function body.

def poll():
    # declare hmd as global so that the function has (write) access to the global var.
    if poll.hmd is None:
        poll.hmd = ctypes.WinDLL("C:\\Program Files\\Blender Foundation\\Blender\\2.68\\scripts\\addons\\game_engine_rift\\openhmd.dll")
poll.hmd = None

Sometimes I use this for global variables that only the function ever accesses.

For more info on function attributes see:
Q: Python function attributes - uses and abuses

Answer 3

Rather than testing values, it's more pythonic to just try and deal with exception(s) when they arise (EAFP). You can also declare and assign your global variable in one step like so:

def poll():
    try:
        hmdPoll = hmd.poll
    except NameError:
        globals()["hmd"] = ctypes.WinDLL("/path/to/dll")
        return poll() # Retry
    # ...

Warning: Catching NameError exceptions in general is a bad idea, use with care.

Personally I'd recommend explicitly initialising hmd outside of the poll function.