Python：给定两个预制函数，如何有效选择要使用的函数？

Question

Let us say I have a module myfunctions with two functions:

def functionA():
    return'Function A chosen.'

def functionB():
    return 'Function B chosen.'

Then, I have a module silly which does something with these functions:

def sillyprinter():
    print chosen_function
    print chosen_function()

Then, In my main script, I have:

import myfunctions
import silly

class FunctionChooser():
    def __init__(function_choice="A"):
        self.choose_function_given_choice(function_choice)

    def do_something_many_times(self):
        for i in range(1000):
            silly.sillyprinter()

The idea of FunctionChooser is that it is initialized with some user given information regarding which function (A or B) I want to use from myfunctions . Then, after this choice is made, the user can call do_something_many_times , which makes use of yet another module, which will use the chosen function from myfunctions many times.

In order to be efficient, I'd like to avoid the following:

1) Choosing which function to use again and again -- so I'd like to make the choice once (during initialization), and then have it "saved" somehow. This requirement disqualifies designs like:

def sillyprinter(chosen_function):
    print chosen_function
    print chosen_function()

# =================================

class FunctionChooser():
    def __init__(function_choice="A"):
        self.function_choice = function_choice

    def choose_function_given_choice(self):
        if self.function_choice == "A":
            return myfunctions.functionA
        elif self.function_choice == "B":
            return myfunctions.functionB

    def do_something_many_times(self):
        for i in range(1000):
            silly.silly_printer(self.choose_function_given_choice())

2) storing the function I'd like to choose as a class attribute, since self calls are expensive, and the use case is numerical . This requirements disqualifies designs like:

def sillyprinter(chosen_function):
    print chosen_function
    print chosen_function()

# =================================

class FunctionChooser():
    def __init__(function_choice="A"):
        self.function_choice = function_choice

    def choose_function_given_choice(self):
        if self.function_choice == "A":
            self.chosen_function = myfunctions.functionA
        elif self.function_choice == "B":
            self.chosen_function = myfunctions.functionB

    def do_something_many_times(self):
        for i in range(1000):
            silly.silly_printer(self.chosen_function)

---

My current idea is to do the following:

def sillyprinter(chosen_function):
    print chosen_function
    print chosen_function()

# =================================

class FunctionChooser():
    def __init__(function_choice="A"):
        self.function_choice = function_choice

    def choose_function_given_choice(self):
        if self.function_choice == "A":
            self.chosen_function = myfunctions.functionA
        elif self.function_choice == "B":
            self.chosen_function = myfunctions.functionB

    def do_something_many_times(self):
        chosen_function = self.chosen_function
        for i in range(1000):
            silly.silly_printer(chosen_function)

It is only very slightly different than the design I disqualified in 2) , in that it makes a self call once and then stores that function for use as a local variable.

Is this the best way to design such "function choice" in Python, given my requirements? (see below)

EDIT: I figure I should make requirements clearer, in order to make the question less general

1. The "function choice string" does not have to be a string -- it could be any variable that encodes for some sort of function choice.
2. I want to avoid self. access calls (but perhaps . access calls in general?) due to issues with numba optimizing code with access calls: Design heuristics for writing Python classes that interact with `scipy.integrate.odeint`?
3. The "function choice" variable is only given once, so we can consider it to effectively be a constant.

Answer 1

No. Functions in Python are first-class objects; treat them as such.

class FunctionChooser():
    def __init__(function_choice=myfunctions.functionA):
        self.function_choice = function_choice

    def do_something_many_times(self):
        chosen_function = self.chosen_function
        printer = silly.silly_printer
        for i in range(1000):
            printer(chosen_function)

Answer 2

The fundamental answer is that any of these three options may be the "best," depending on circumstances. But the differences between the options you've chosen are subtle, and not likely to affect performance significantly most of the time. Instead of worrying about efficiency here, you should worry about conceptual elegance. Then, if you need efficiency, optimize.

I could imagine situations when any of these three options would be preferable, conceptually.

1. Suppose the choice of function will depend on a value that changes frequently. You'll have to check its state frequently, so what will you gain by storing it? It makes more sense simply to look it up every time. In this case, (1) is the best option.

2. Suppose the choice of function won't be based on a value that changes often, or that is easy to "invert control" with (ie the code that pays attention to the variable knows to change the function selection as well). Unless you have an overriding reason to worry about the extra overhead of a single . access, just store this as an attribute. (And note that looking up an attribute in self is no more costly than looking up an attribute in some other object. The operation is exactly the same; there's nothing special about self !) In this case, (2) is the best option.

3. Suppose, as you have, that the choice of function won't be based on a value that changes often, but that the function will itself be called frequently. Furthermore, you are certain that the . access is slowing down your code, because you have done rigorous tests . Then it makes sense to cache the result of the . access in a local variable, as in option (3). (But note that in option (3) you're still using another . operation -- that should be cached as well, as in Ignacio's answer.) But beware premature optimization! Every local variable imposes an additional cognitive load on you and your fellow developers -- you must be sure it's worth it. Only choose this option if you've actually done tests, and it makes a significant speed difference.

A final note: there's also some extra complexity in your example code that I am assuming is supposed to be evocative of complexity rather than specifically purposeful in this particular case. For example, given the code you've actually posted, the choose_function_given_choice function is quite useless. But I think you know that already. Still, to restate the obvious -- you should make all of this happen in the simplest way possible.