lambda in python

Question

Ich überprüfe gerade einige Schema-Übungen in Python (falls das Sinn macht), um herauszufinden, was Python in Bezug auf FP leisten kann. Mein Problem betrifft lambda in python: Kann ich eine allgemeine Funktion in Python mit einem Operator als eines der Argumente definieren?

Denken Sie daran:

def f (op,x,y):
    #return some lambda function that combines x and y in the appropriate way
    #i.e if op is +, then return x+y, if op is -, then return x-y etc

#Edit : added usage
#this should be called like this:
f(+, 1,2) #should return 3

Ich weiß, dass dies in Schema möglich ist, aber gibt es etwas Gleichwertiges in Python? Ich habe den Eindruck, dass Lambda in Python nur eine kürzere Art der Definition einer Methode ist, und ich habe keine Möglichkeit gefunden, eine allgemeine Combiner-Funktion in Python zu definieren.

Answer 1

Ich sehe einige Punkte in Ihrer Frage, gehen wir sie der Reihe nach durch:

1. Kann ich eine Funktion als Parameter an jemanden übergeben?

Ja:

def f(op, x, y):
    return op(x, y)

def add(x, y):
    return x + y

f(add, 10, 7) #gives 17

2. Was ist dann mit den Betreibern?

Im Gegensatz zu Schema sind Python-Operatoren keine Funktionen, so dass Sie sie nicht direkt als Parameter übergeben können. Sie können die Wrapper-Funktionen entweder selbst erstellen oder Sie können die Betreiber Modul aus der Standardbibliothek.

import operator

operator.add(1, 2)
(lambda x,y : x+y)(1, 2)

---

Dass Operatoren keine echten Funktionen sind, ist in den meisten Fällen ein bisschen traurig, aber wenigstens bietet Python uns verkettete Vergleiche wie 10 <= x < 100 im Gegenzug...

3. Was ist also der Unterschied zwischen Python und Scheme?

Im Allgemeinen sind die Funktionen in Python genauso mächtig wie die Funktionen in Scheme, aber es gibt einige Dinge zu beachten:

Das Schlüsselwort lambda ist begrenzt

Sie können nur einen einzigen Ausdruck als Funktionskörper verwenden

f = lambda x, y: x + y

Da es in Python eine Reihe von Dingen gibt, die Anweisungen und keine Ausdrücke sind (Zuweisungen, die 2.x print , ...), müssen Sie stattdessen oft auf benannte Funktionen zurückgreifen.

Es gibt Schließungen

def make_printer(msg):
    def printer():
        print msg
    return printer

printer('a message')()

Aber das Mutieren von Variablen in ihnen ist mühsam

Das klappt nicht. Es wird versucht, ein neues n für die innere Funktion zu binden, anstatt die äußere zu verwenden

def make_counter(n):
    def inc():
        n = n + 1
        return n
    return inc

neues 3.x nicht-lokales Schlüsselwort

def make_counter(n):
    def inc():
        nonlocal n
        n = n + 1
        return n
    return inc

Umgehung mit veränderbaren Objekten

def make_counter(n):
    nw = [n]
    def inc():
       nw[0] = nw[0] + 1
       return nw[0]
    return inc

Objekte anstelle von Verschlüssen. Verwendet die magische __call__ Methode, um so zu tun, als sei sie eine Funktion

class Counter:
    def __init__(self, n):
        self.n = n
    def __call__(self):
        self.n += 1
        return self.n

Answer 2

Operatoren sind in Python nicht wirklich Funktionen, sondern eher Methoden -- x + y ist die Abkürzung für x.__add__(y) o y.__radd__(x) . Sie können die Funktionen im Abschnitt operator Modul um das gewünschte Verhalten nachzuahmen.

Answer 3

Ich denke, die beste Möglichkeit ist, eine Funktion zu erstellen, die den Operator ausführt, und diese zu übergeben:

def f(op, x, y):
    return op(x, y)

f(lambda x, y: x + y, 1, 2)

Sieht ein bisschen überflüssig aus, wenn man das auch kann:

f = lambda x, y: x + y

f(1, 2)

Answer 4

In Python kann man einen Operator nicht syntaktisch übergeben. Z.B.. f(+) ist ein Syntaxfehler. Wenn Sie jedoch op als eine beliebige Funktion betrachten, können Sie def oder lambda verwenden:

def f(op, x, y):
  def op_func():
    return op(x, y)

  return op_func

or

def f(op, x, y):
  op_func = lambda: op(x, y)

  return op_func

In Ihrem Fall möchten Sie die Funktion auswerten:

def f(op, x, y):
    return op(x, y)

Denken Sie daran, dass Python interpretiert wird, so dass auch def-Anweisungen zur Laufzeit ausgewertet werden.

[Falls es aus irgendeinem Grund notwendig sein sollte, können Sie mit dem Operator-Modul auf die eingebauten Operatoren als Funktionen zugreifen: http://docs.python.org/library/operator.html ]

Answer 5

Siehe operator Modul. Alle Python-Operatoren sind dort in Form von Funktionen verfügbar. Beispiel:

import operator    
operate = lambda op, x, y: op(x, y)
operate(operator.add, 1, 2)