如何创建一个新的线程来执行一个Action (How to create a new Thread to execute an Action)

 给定一个函数，你可以像这样创建一个LazyComparer类： 
 
def lazy_func(func):
    class LazyComparer(object):
        def __init__(self, x):
            self.x = x
        def __lt__(self, other):
            return func(self.x) < func(other.x)
        def __eq__(self, other):
            return func(self.x) == func(other.x)
    return lambda x: LazyComparer(x)
 
 要从多个函数中创建一个懒惰的关键函数，您可以创建一个实用程序函数： 
 
def make_lazy(*funcs):
    def wrapper(x):
        return [lazy_func(f)(x) for f in funcs]
    return wrapper
 
 一起他们可以像这样使用： 
 
def countcalls(f):
    "Decorator that makes the function count calls to it."
    def _f(*args, **kwargs):
        _f._count += 1
        return f(*args, **kwargs)
    _f._count = 0
    return _f

@countcalls
def g(x): return x

@countcalls
def f1(x): return 0

@countcalls
def f2(x): return x

def report_calls(*funcs):
    print(' | '.join(['{} calls to {}'.format(f._count, f.func_name)
                      for f in funcs]))

L = range(10)[::-1]

L.sort(key=make_lazy(f1, g))
report_calls(f1, g)

g._count = 0
L.sort(key=make_lazy(f2, g))
report_calls(f2, g) 
 
 这产生了 
 
18 calls to f1 | 36 calls to g
36 calls to f2 | 0 calls to g
 
 上面的@countcalls装饰器用于确认当f1返回很多关系时，调用g来中断关系，但是当f2返回不同的值时， g不会被调用。 
 
 
 NPE的解决方案在Key类中增加了记忆。 通过上面的解决方案，您可以在LazyComparer类的外部（独立于）添加记忆： 
 
def memo(f):
    # Author: Peter Norvig
    """Decorator that caches the return value for each call to f(args).
    Then when called again with same args, we can just look it up."""
    cache = {}
    def _f(*args):
        try:
            return cache[args]
        except KeyError:
            cache[args] = result = f(*args)
            return result
        except TypeError:
            # some element of args can't be a dict key
            return f(*args)
    _f.cache = cache
    return _f

L.sort(key=make_lazy(memo(f1), memo(g)))
report_calls(f1, g)
 
 这样可以减少对g的呼叫： 
 
10 calls to f1 | 10 calls to g

Given a function, you could create a LazyComparer class like this:
 
def lazy_func(func):
    class LazyComparer(object):
        def __init__(self, x):
            self.x = x
        def __lt__(self, other):
            return func(self.x) < func(other.x)
        def __eq__(self, other):
            return func(self.x) == func(other.x)
    return lambda x: LazyComparer(x)
 
To make a lazy key function out of multiple functions, you could create a utility function:
 
def make_lazy(*funcs):
    def wrapper(x):
        return [lazy_func(f)(x) for f in funcs]
    return wrapper
 
And together they could be used like this:
 
def countcalls(f):
    "Decorator that makes the function count calls to it."
    def _f(*args, **kwargs):
        _f._count += 1
        return f(*args, **kwargs)
    _f._count = 0
    return _f

@countcalls
def g(x): return x

@countcalls
def f1(x): return 0

@countcalls
def f2(x): return x

def report_calls(*funcs):
    print(' | '.join(['{} calls to {}'.format(f._count, f.func_name)
                      for f in funcs]))

L = range(10)[::-1]

L.sort(key=make_lazy(f1, g))
report_calls(f1, g)

g._count = 0
L.sort(key=make_lazy(f2, g))
report_calls(f2, g) 
 
which yields
 
18 calls to f1 | 36 calls to g
36 calls to f2 | 0 calls to g
 
The @countcalls decorator above is used to connfirm that when f1 returns a lot of ties, g is called to break the ties, but when f2 returns distinct values, g does not get called.
 
 
NPE's solution adds memoization within the Key class. With the solution above, you could add memoization outside (independent of) the LazyComparer class:
 
def memo(f):
    # Author: Peter Norvig
    """Decorator that caches the return value for each call to f(args).
    Then when called again with same args, we can just look it up."""
    cache = {}
    def _f(*args):
        try:
            return cache[args]
        except KeyError:
            cache[args] = result = f(*args)
            return result
        except TypeError:
            # some element of args can't be a dict key
            return f(*args)
    _f.cache = cache
    return _f

L.sort(key=make_lazy(memo(f1), memo(g)))
report_calls(f1, g)
 
which results in fewer calls to g:
 
10 calls to f1 | 10 calls to g