title: Using class/static methods as default parameter values within methods of the same class
body: <p>I'd like to do something like this:</p>
  
  <pre><code>class SillyWalk(object):
      @staticmethod
      def is_silly_enough(walk):
          return (False, "It's never silly enough")
      def walk(self, appraisal_method=is_silly_enough):
          self.do_stuff()
          (was_good_enough, reason) = appraisal_method(self)
          if not was_good_enough:
              self.execute_self_modifying_code(reason)
          return appraisal_method
      def do_stuff(self):
          pass
      def execute_self_modifying_code(self, problem):
          from __future__ import deepjuju
          deepjuju.kiss_booboo_better(self, problem)
  </code></pre>
  
  <p>with the idea being that someone can do</p>
  
  <pre><code>&gt;&gt;&gt; silly_walk = SillyWalk()
  &gt;&gt;&gt; appraise = walk()
  &gt;&gt;&gt; is_good_walk = appraise(silly_walk)
  </code></pre>
  
  <p>and also get some magical machine learning happening; this last bit is not of particular interest to me, it was just the first thing that occurred to me as a way to exemplify the use of the static method in both an in-function context and from the caller's perspective.</p>
  
  <p>Anyway, this doesn't work, because <code>is_silly_enough</code> is not actually a function: it is an object whose <code>__get__</code> method will return the original <code>is_silly_enough</code> function.  This means that it only works in the "normal" way when it's referenced as an object attribute.  The object in question is created by the <code>staticmethod()</code> function that the decorator puts in between <code>SillyWalk</code>'s <code>is_silly_enough</code> attribute and the function that's originally defined with that name.</p>
  
  <p>This means that in order to use the default value of <code>appraisal_method</code> from within <em>either</em> <code>SillyWalk.walk</code> <em>or</em> its caller, we have to either</p>
  
  <ul>
  <li>call <code>appraisal_method.__get__(instance, owner)(...)</code> instead of just calling <code>appraisal_method(...)</code></li>
  <li>or assign it as the attribute of some object, then reference that object property as a method that we call as we would call <code>appraisal_method</code>.</li>
  </ul>
  
  <p>Given that neither of these solutions seem particularly Pythonic™, I'm wondering if there is perhaps a better way to get this sort of functionality.  I essentially <strong>want a way to specify that a method should, by default, use a particular class or static method defined within the scope of the same class to carry out some portion of its daily routine.</strong></p>
  
  <p>I'd prefer not to use <code>None</code>, because I'd like to allow <code>None</code> to convey the message that that particular function should not be called.  I guess I could use some other value, like <code>False</code> or <code>NotImplemented</code>, but it seems a) hackety b) annoying to have to write an extra couple of lines of code, as well as otherwise-redundant documentation, for something that seems like it could be expressed quite succinctly as a default parameter.</p>
  
  <p>What's the best way to do this?</p>