根据正则表达式选择要调用的 Python 函数

Question

是否可以将函数放入数据结构中，而无需先用def 为其命名？

# This is the behaviour I want. Prints "hi".
def myprint(msg):
    print msg
f_list = [ myprint ]
f_list[0]('hi')
# The word "myprint" is never used again. Why litter the namespace with it?

lambda 函数的主体受到严格限制，所以我不能使用它们。

编辑：作为参考，这更像是我遇到问题的真实代码。

def handle_message( msg ):
    print msg
def handle_warning( msg ):
    global num_warnings, num_fatals
    num_warnings += 1
    if ( is_fatal( msg ) ):
        num_fatals += 1
handlers = (
    ( re.compile( '^<\w+> (.*)' ), handle_message ),
    ( re.compile( '^\*{3} (.*)' ), handle_warning ),
)
# There are really 10 or so handlers, of similar length.
# The regexps are uncomfortably separated from the handler bodies,
# and the code is unnecessarily long.

for line in open( "log" ):
    for ( regex, handler ) in handlers:
        m = regex.search( line )
        if ( m ): handler( m.group(1) )

Answer 1

这是基于Udi's nice answer。

我认为创建匿名函数的难度有点像红鲱鱼。您真正想做的是将相关代码保持在一起，并使代码整洁。所以我认为装饰器可能适合你。

import re

# List of pairs (regexp, handler)
handlers = []

def handler_for(regexp):
    """Declare a function as handler for a regular expression."""
    def gethandler(f):
        handlers.append((re.compile(regexp), f))
        return f
    return gethandler

@handler_for(r'^<\w+> (.*)')
def handle_message(msg):
    print msg

@handler_for(r'^\*{3} (.*)')
def handle_warning(msg):
    global num_warnings, num_fatals
    num_warnings += 1
    if is_fatal(msg):
        num_fatals += 1

Answer 2

更好的 DRY 方法来解决您的实际问题：

def message(msg):
    print msg
message.re = '^<\w+> (.*)'

def warning(msg):
    global num_warnings, num_fatals
    num_warnings += 1
    if ( is_fatal( msg ) ):
        num_fatals += 1
warning.re = '^\*{3} (.*)'

handlers = [(re.compile(x.re), x) for x in [
        message,
        warning,
        foo,
        bar,
        baz,
    ]]

Answer 3

继续使用Gareth's 清洁方法和模块化独立解决方案：

import re

# in util.py
class GenericLogProcessor(object):

    def __init__(self):
      self.handlers = [] # List of pairs (regexp, handler)

    def register(self, regexp):
        """Declare a function as handler for a regular expression."""
        def gethandler(f):
            self.handlers.append((re.compile(regexp), f))
            return f
        return gethandler

    def process(self, file):
        """Process a file line by line and execute all handlers by registered regular expressions"""
        for line in file:
            for regex, handler in self.handlers:
                m = regex.search(line)
                if (m):
                  handler(m.group(1))      

# in log_processor.py
log_processor = GenericLogProcessor()

@log_processor.register(r'^<\w+> (.*)')
def handle_message(msg):
    print msg

@log_processor.register(r'^\*{3} (.*)')
def handle_warning(msg):
    global num_warnings, num_fatals
    num_warnings += 1
    if is_fatal(msg):
        num_fatals += 1

# in your code
with open("1.log") as f:
  log_processor.process(f)

Answer 4

如果你想保持一个干净的命名空间，使用 del:

def myprint(msg):
    print msg
f_list = [ myprint ]
del myprint
f_list[0]('hi')

Answer 5

正如你所说，这是不可能的。但是你可以近似它。

def create_printer():
  def myprint(x):
    print x
  return myprint

x = create_printer()

myprint 在这里实际上是匿名的，因为调用者不再可以访问创建它的变量范围。 （见closures in Python。）

Answer 6

如果您担心会污染命名空间，请在另一个函数中创建您的函数。那么你只是在“污染”create_functions 函数的本地命名空间，而不是外部命名空间。

def create_functions():
    def myprint(msg):
        print msg
    return [myprint]

f_list = create_functions()
f_list[0]('hi')

Answer 7

你不应该这样做，因为 eval 是邪恶的，但你可以在运行时使用 FunctionType 和 compile 编译函数代码：

>>> def f(msg): print msg
>>> type(f)
 <type 'function'>
>>> help(type(f))
...
class function(object)
 |  function(code, globals[, name[, argdefs[, closure]]])
 |
 |  Create a function object from a code object and a dictionary.
 |  The optional name string overrides the name from the code object.
 |  The optional argdefs tuple specifies the default argument values.
 |  The optional closure tuple supplies the bindings for free variables.    
...

>>> help(compile)
Help on built-in function compile in module __builtin__:

compile(...)
    compile(source, filename, mode[, flags[, dont_inherit]]) -> code object

    Compile the source string (a Python module, statement or expression)
    into a code object that can be executed by the exec statement or eval().
    The filename will be used for run-time error messages.
    The mode must be 'exec' to compile a module, 'single' to compile a
    single (interactive) statement, or 'eval' to compile an expression.
    The flags argument, if present, controls which future statements influence
    the compilation of the code.
    The dont_inherit argument, if non-zero, stops the compilation inheriting
    the effects of any future statements in effect in the code calling
    compile; if absent or zero these statements do influence the compilation,
    in addition to any features explicitly specified.

Answer 8

创建匿名函数的唯一方法是使用lambda，如您所知，它们只能包含一个表达式。

您可以创建多个具有相同名称的函数，这样至少您不必为每个函数考虑新名称。

拥有真正的匿名函数会很棒，但 Python 的语法不能轻易支持它们。

Answer 9

正如大家所说的 lambda 是唯一的方法，但你必须考虑的不是 lambda 限制，而是如何避免它们 - 例如，你可以使用列表、字典、理解等来做你想做的事：

funcs = [lambda x,y: x+y, lambda x,y: x-y, lambda x,y: x*y, lambda x: x]
funcs[0](1,2)
>>> 3
funcs[1](funcs[0](1,2),funcs[0](2,2))
>>> -1
[func(x,y) for x,y in zip(xrange(10),xrange(10,20)) for func in funcs]

使用打印编辑（尝试查看pprint module）和控制流：

add = True
(funcs[0] if add else funcs[1])(1,2)
>>> 3

from pprint import pprint
printMsg = lambda isWarning, msg: pprint('WARNING: ' + msg) if isWarning else pprint('MSG:' + msg)

Answer 10

Python 真的，真的不想这样做。不仅没有办法定义多行匿名函数，而且函数定义也不返回函数，所以即使这在语法上是有效的......

mylist.sort(key=def _(v):
                    try:
                        return -v
                    except:
                        return None)

... 还是不行。 （虽然我猜如果它在语法上是有效的，他们会让函数定义返回函数，所以它会工作。）

因此，您可以编写自己的函数来从字符串创建函数（当然使用exec）并传入一个三引号字符串。这在语法上有点难看，但它确实有效：

def function(text, cache={}):

    # strip everything before the first paren in case it's "def foo(...):"
    if not text.startswith("("):
        text = text[text.index("("):]

    # keep a cache so we don't recompile the same func twice
    if text in cache:
        return cache[text]

    exec "def func" + text
    func.__name__ = "<anonymous>"

    cache[text] = func
    return func

    # never executed; forces func to be local (a tiny bit more speed)
    func = None

用法：

mylist.sort(key=function("""(v):
                                try:
                                    return -v
                                except:
                                    return None"""))

Answer 11

就我个人而言，我只是将它命名为使用它的东西，而不是担心它“闲逛”。通过使用建议（例如稍后重新定义它或使用del 将名称从命名空间中删除），您将获得的唯一好处是，如果有人稍后出现并移动一些代码而不了解您的内容，则可能会造成混淆或错误正在做。

Answer 12

你可以使用exec:

def define(arglist, body):
    g = {}
    exec("def anonfunc({0}):\n{1}".format(arglist,
                                     "\n".join("    {0}".format(line)
                                               for line in body.splitlines())), g)
    return g["anonfunc"]

f_list = [define("msg", "print(msg)")]
f_list[0]('hi')

Answer 13

唯一的选择是使用 lambda 表达式，就像你提到的那样。没有它，这是不可能的。这就是python的工作方式。

Answer 14

如果您的函数足够复杂以至于无法放入 lambda 函数中，那么，为了便于阅读，最好还是在普通块中定义它。