utility functions within a class?

[jeffshannon at gmail.com]

You do *NOT* want to put double-underscores before and after a method
name.  That does not indicate a private method, it indicates a "magic
method" -- something that has special meaning to Python.  Thus, you
have special methods like __init__(), __len__(), __getattr__(),
__setattr__(), etc; all of these methods may be called *by Python* in
certain specific circumstances, and allow you to customize how your
objects respond to those circumstances.

Naming methods that are *not* special "magic methods" using this naming
convention is a very bad idea.

On the other hand, methods with only a single or double *leading*
underscore, and no trailing underscore(s), can be considered to express
some degree of privacy.  A single underscore, by convention, indicates
an internal method or attribute, and that name will typically not be
exported.  A double underscore will trigger minimal name mangling; not
only will the name not be exported, but it will be converted to
_<classname>__<name>, making it a bit more difficult to access from
outside the class.  (Access inside the class is via the unmangled
name.)

In this circumstance, I'd probably have methods _generate_head(self)
and _generate_body(self).  Don't mess with making them class/static
methods unless it's important to be able to access them when you don't
have any instance of the class available (and if you're calling them
from inside a regular method, then you *do* have an instance
available).  Even if you don't end up referring to self or any instance
attributes within the method, it's simpler to keep it as a normal
method.

--Jeff Shannon