Question

This is not really language-specific, but I’ll use Python to explain my question.

My program has several nearly self-contained functions. The command line arguments select one of these functions, and provide the input file name. The function is then executed:

# main.py:
import functions
def main():
  filename = sys.argv[1]
  function_name = sys.argv[2]
  function = getattr(functions, function_name)
  result = function(filename)
  # do something with result

# function.py contains all the functions:
def function1(filename):
  # ...

I had a feeling that I should probably use classes rather than functions, so I wrapped each function in a class. But now each class looks pretty silly: it’s only instantiated once, and all it does is execute its constructor, which does exactly what my old functions did. Then I can call a certain method to retrieve the return value:

# new version of main.py:
import classes
def main():
  filename = sys.argv[1]
  cls_name = sys.argv[2]
  cls = getattr(classes, cls_name)
  calculation = cls(filename)
  result = calculation.result()
  # do something with result

# classes.py:
import functions
class Class1:
  def __init__(self, filename):
    self.result = functions.function1(filename)
  def result(self):
    return self.result

# functions.py is unchanged

This doesn’t seem to be any better than when I had functions. Is there a way to make my code object-oriented in a more useful way?

Answer 1

If you were writing Java or C# then you would implement these functions as static methods. In those languages all methods have to be part of a class due to the design of the language. In Python, whilst you can emulate a static method, there is absolutely no need to do so for this example.

Python’s creator, Guido van Rossum, has argued in favour of the use of functions rather than methods.

First of all, I chose len(x) over x.len() for HCI reasons (def
__len__() came much later). There are two intertwined reasons
actually, both HCI:

(a) For some operations, prefix notation just reads better than
postfix — prefix (and infix!) operations have a long tradition in
mathematics which likes notations where the visuals help the
mathematician thinking about a problem. Compare the easy with which we
rewrite a formula like x*(a+b) into x*a + x*b to the clumsiness of
doing the same thing using a raw OO notation.

(b) When I read code that says len(x) I know that it is asking for the
length of something. This tells me two things: the result is an
integer, and the argument is some kind of container. To the contrary,
when I read x.len(), I have to already know that x is some kind of
container implementing an interface or inheriting from a class that
has a standard len(). Witness the confusion we occasionally have when
a class that is not implementing a mapping has a get() or keys()
method, or something that isn’t a file has a write() method.

Saying the same thing in another way, I see ‘len‘ as a built-in
operation. I’d hate to lose that. /…/

Whilst this is not directly related to your question it does challenge the sometimes dogmatic stance that methods are always to be preferred to functions.

In my opinion, in Python, using functions is a better solution than creating classes.