Question: I have a class that needs auxiliary functions, e.g. one to calculate a checksum that just uses the passed in arguments and not any properties of the class. This function is only called by the class's methods. So I dont need to pass in the 'self' as the first formal of the function.

How should I implement these functions? Can I have non-method functions in a class? Should I define them outside the class (even though they are not used by anything else)? Or is it ok for them to be regular methods?

Answer: 
If you want a function inside a class that doesn't take self as an argument, use the `@staticmethod` decorator:

```
 class Awesomeness(object):
     def method(self, *args):
         pass

     @staticmethod
     def another_method(*args):
         pass

```

However, from a conceptual standpoint I would definitely consider putting it at module scope, especially if it's a checksum function that doesn't use instance or class properties.
tldr define a function outside the class

```
class myclass():
    def __init__(self):
        myfunc()

def myfunc():
    print('f')

myclass() # prints f

```

from best to worst:

1. define outside the class
2. use staticmethod decorator
3. define a method, but ignore self

the disadvantage of 2 & 3 is that the "function" is still a method as it can applied to an object the regular way: self.myfunc()