Wählen Sie die Python-Funktion zum Aufrufen basierend auf einer Regex

Diese basiert auf Udi ' s nette Antwort.

Ich denke, dass die Schwierigkeit der Erstellung von anonymen Funktionen ist ein bisschen ein Ablenkungsmanöver. Was Sie wirklich wollen, zu tun zu halten von den zugehörigen code zusammen, und machen den code ordentlich. Also ich denke, Dekorateure kann für Sie arbeiten.

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

InformationsquelleAutor der Antwort Gareth Rees

Weiterhin Gareth ist sauberen Ansatz mit einem modularen self contained Lösung:

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)

InformationsquelleAutor der Antwort Udi

Wie gesagt, dies kann nicht getan werden. Sie können aber annähernd.

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

x = create_printer()

myprint ist effektiv anonym hier, da der variable Bereich, in dem es erstellt wurde ist nicht mehr erreichbar für den Anrufer. (Siehe closures in Python.)

InformationsquelleAutor der Antwort robert

Sollten Sie es nicht tun, verursachen eval ist böse, aber Sie können die Funktion kompilieren von code zur Laufzeit mit FunctionType und kompilieren:

>>> 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.

InformationsquelleAutor der Antwort Udi

Python wirklich, wirklich nicht wollen, dies zu tun. Nicht nur, dass es keine Möglichkeit zur Definition einer multi-line-anonyme Funktion, aber Funktion Definitionen nicht wieder die Funktion, also auch wenn dies syntaktisch gültig ist...

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

... es immer noch nicht funktionieren würde. (Obwohl ich denke, wenn es syntaktisch gültig, Sie würde machen Funktionsdefinitionen Rückkehr der Funktion, so dass es würde Arbeit.)

So schreiben Sie Ihre eigene Funktion, um eine Funktion aus einem string (mit exec natürlich) und pass in einer dreifach-quoted string. Es ist irgendwie hässlich syntaktisch, aber es funktioniert:

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

Verwendung:

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

InformationsquelleAutor der Antwort kindall

Persönlich würde ich nur nennen Sie es etwas verwenden, und nicht ärgern über Sie "hängen herum". Das einzige, was Sie gewinnen, indem Sie Vorschläge wie die Neudefinition später, oder mit del fallen die Namen aus dem namespace ist ein potential für Verwirrung und Fehler, wenn später jemand kommt und bewegt sich einige code, um ohne groking, was du tust.

InformationsquelleAutor der Antwort John Gaines Jr.

Die einzige option ist die Verwendung eines lambda-Ausdrucks, wie Sie erwähnen. Ohne dass, es ist nicht möglich. Das ist die Art, wie python funktioniert.

InformationsquelleAutor der Antwort thunderflower