TypeError: 'int' object is not callable
Nachdem abs auf 10 gezeigt wurde, kann die Funktion nicht über abs(-10) aufgerufen werden! Denn die abs-Variable zeigt nicht mehr auf die Absolutwertfunktion, sondern auf eine Ganzzahl 10!
Natürlich darf der eigentliche Code nicht so geschrieben werden. Dies soll verdeutlichen, dass der Funktionsname auch eine Variable ist. Um die abs-Funktion wiederherzustellen, starten Sie die interaktive Python-Umgebung neu.
Hinweis: Da die abs-Funktion tatsächlich im Import-Builtins-Modul definiert ist, verwenden Sie importbuiltins.abs = 10, um den Zeiger der Abs-Variablen so zu ändern, dass er in anderen Modulen wirksam wird.
Funktion übergeben
Da Variablen auf Funktionen verweisen können und die Parameter von Funktionen Variablen empfangen können, kann eine Funktion eine andere Funktion als Parameter empfangen. Diese Art von Funktion wird als höhere Funktion bezeichnet. Bestellfunktion.
Die einfachste Funktion höherer Ordnung:
def add(x, y, f): return f(x) + f(y)
when When Wir rufen add(-5, 6, abs) auf, die Parameter x, y und f erhalten jeweils -5, 6 und abs. Gemäß der Funktionsdefinition können wir den Berechnungsprozess wie folgt ableiten:
x = -5
y = 6
f = abs
f(x) + f(y) ==> abs(-5) + abs(6) ==> 🎜>
Überprüfen Sie es mit dem Code:
>>> add(-5, 6, abs)11
Das Schreiben einer Funktion höherer Ordnung bedeutet, dass die Parameter der Funktion können von anderen Funktionen empfangen werden.
Zusammenfassung
Übergabefunktionen als Parameter werden als Funktionen höherer Ordnung bezeichnet.
map/reduce
Python verfügt über integrierte Map()- und Reduce()-Funktionen.
Wenn Sie Googles berühmtes Papier „MapReduce: Simplified Data Processing on Large Clusters“ gelesen haben, können Sie das Konzept von Map/Reduce grob verstehen.
Schauen wir uns zuerst die Karte an. Die Funktion „map()“ empfängt zwei Parameter, einer ist eine Funktion und der andere ist eine iterierbare Karte, wendet die übergebene Funktion nacheinander auf jedes Element der Sequenz an und gibt das Ergebnis als neuen Iterator zurück.
Zum Beispiel haben wir eine Funktion f(x)=x2, und wir möchten diese Funktion auf eine Liste [1, 2, 3, 4, 5, 6, 7, 8, 9]. Sie können map() verwenden, um es wie folgt zu implementieren:
Jetzt verwenden wir Python-Code, um es zu implementieren:
>> > def f(x): ... return x * x
...>>> 9])>>> ; list(r)[1, 4, 9, 16, 25, 36, 49, 64, 81]
Der erste übergebene Parameter map() ist f, das heißt Das Funktionsobjekt selbst. Da das Ergebnis r ein Iterator ist und Iterator eine Lazy-Sequenz ist, wird die Funktion list() verwendet, um die gesamte Sequenz berechnen und eine Liste zurückgeben zu können.
Sie denken vielleicht, dass Sie die Funktion „map()“ nicht benötigen. Sie können eine Schleife schreiben und das Ergebnis berechnen:
L = []für n in [1, 2, 3 , 4, 5, 6, 7, 8, 9]:
L.append(f(n))print(L)
ist zwar möglich, aber aus dem Können Sie auf einen Blick verstehen, wie „f(x) auf jedes Element der Liste angewendet wird und als Ergebnis eine neue Liste generiert wird“?
map() als Funktion höherer Ordnung abstrahiert also tatsächlich die Operationsregeln. Daher können wir nicht nur einfache f(x)=x2 berechnen, sondern auch jede komplexe Funktion, wie zum Beispiel: Konvertieren Sie alle Zahlen in dieser Liste in Zeichenfolgen:
>>> 1‘, ‚2‘, ‚3‘, ‚4‘, ‚5‘, ‚6‘, ‚7‘, ‚8‘, ‚9‘]
Nur eine Codezeile.
Schauen Sie sich die Verwendung von Reduzieren an. Reduce wendet eine Funktion auf eine Sequenz an [x1, x2, x3, ...]. Diese Funktion muss zwei Parameter erhalten. Reduce setzt die kumulative Berechnung des Ergebnisses mit dem nächsten Element der Sequenz fort 🎜>reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
Summieren Sie beispielsweise eine Sequenz kann Reduce verwenden, um Folgendes zu implementieren:
>>> from functools import Reduce>>> >> Reduce(add, [1, 3, 5, 7, 9])25
Natürlich kann die Summenoperation direkt mit der in Python integrierten Funktion sum() durchgeführt werden. Es besteht keine Notwendigkeit, Reduce zu verwenden.
Aber wenn Sie die Sequenz [1, 3, 5, 7, 9] in die Ganzzahl 13579 umwandeln möchten, kann Reduzieren nützlich sein:
>>> import Reduce>>> def fn(x, y):... return x * 10 + y...>>> ]) 13579
Dieses Beispiel selbst ist nicht sehr nützlich, aber wenn wir bedenken, dass die Zeichenfolge str auch eine Sequenz ist, können wir das obige Beispiel leicht ändern und map() verwenden, um das zu schreiben Konvertierung der str-Funktion für int:
>>> from functools import Reduce>>>... return x * 10 + y
. .> ;>> def char2num(s):... return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5 ': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
...>>> , ' 13579'))13579
ist in einer str2int-Funktion organisiert:
aus functools import Reducedef str2int(s): def fn(x, y): return x * 10 + y def char2num(s): return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s] return Reduce( fn, map(char2num, s))
kann auch mit der Lambda-Funktion weiter vereinfacht werden:
from functools import reduziertef char2num(s): return {'0': 0 , '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, ' 9 ': 9}[s]def str2int(s): return Reduce(lambda x, y: x * 10 + y, map(char2num, s))
Mit anderen Worten, unter der Annahme von Python Wenn Sie die Funktion int() nicht bereitstellen, können Sie selbst eine Funktion schreiben, um eine Zeichenfolge in eine Ganzzahl umzuwandeln. Dafür sind nur wenige Codezeilen erforderlich!
Die Verwendung der Lambda-Funktion wird später vorgestellt.
filter
Pythons integrierte Funktion filter() wird zum Filtern von Sequenzen verwendet.
Ähnlich wie map() erhält auch filter() eine Funktion und eine Sequenz. Im Gegensatz zu map() wendet filter() die übergebene Funktion nacheinander auf jedes Element an und entscheidet dann, ob das Element beibehalten oder verworfen wird, je nachdem, ob der Rückgabewert True oder False ist.
Um beispielsweise in einer Liste gerade Zahlen zu löschen und nur ungerade Zahlen beizubehalten, können Sie schreiben:
def is_odd(n): return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))# Ergebnis: [1, 5, 9, 15]
Setzen Sie a Sequenz in Um die leere Zeichenfolge zu löschen, können Sie schreiben:
def not_empty(s): return s and s.strip()
list(filter(not_empty, ['A', ' ' , 'B', None, 'C', ' ']))# Ergebnis: ['A', 'B', 'C']
Es ist ersichtlich, dass je höher- Wenn die Funktion filter() verwendet wird, besteht der Schlüssel darin, eine „Filter“-Funktion korrekt zu implementieren.
Beachten Sie, dass die Funktion filter() einen Iterator zurückgibt, bei dem es sich um eine verzögerte Sequenz handelt. Um filter() also zu zwingen, die Berechnungsergebnisse abzuschließen, müssen Sie die Funktion list() verwenden, um alle Ergebnisse zu erhalten und die Liste zurückgeben.
sortiert
Sortieralgorithmus
Sortieren ist ebenfalls ein Algorithmus, der häufig in Programmen verwendet wird. Unabhängig davon, ob Blasensortierung oder Schnellsortierung verwendet wird, besteht der Kern der Sortierung darin, die Größe zweier Elemente zu vergleichen. Wenn es eine Zahl ist, können wir sie direkt vergleichen, aber was ist, wenn es eine Zeichenfolge oder zwei Diktate ist? Der direkte Vergleich mathematischer Größen ist bedeutungslos, daher muss der Vergleichsprozess durch Funktionen abstrahiert werden.
Pythons integrierte Funktion sorted() kann die Liste sortieren:
>>> sorted([36, 5, -12, 9, -21])[- 21 , -12, 5, 9, 36]
Darüber hinaus ist die Funktion sorted() auch eine Funktion höherer Ordnung. Sie kann auch eine Schlüsselfunktion erhalten, um eine benutzerdefinierte Sortierung zu implementieren, z. B. nach absolute Wertgrößensortierung:
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21 , 36 ]
Die durch key angegebene Funktion wirkt sich auf jedes Element der Liste aus und wird entsprechend dem von der key-Funktion zurückgegebenen Ergebnis sortiert. Vergleichen Sie die Originalliste und die mit key=abs verarbeitete Liste:
list = [36, 5, -12, 9, -21]keys = [36, 5, 12, 9, 21]
Dann sortiert die Funktion sorted() nach Schlüsseln und gibt die entsprechenden Elemente der Liste entsprechend der entsprechenden Beziehung zurück:
keys sorting result => [5, 9, 12, 21, 36 ]
>
>>> sorted(['bob', 'about', 'Zoo', 'Credit'])['Credit', 'Zoo', 'about', 'bob' ]
Standardmäßig basiert die Zeichenfolgensortierung auf dem ASCII-Größenvergleich. Da „Z“
Jetzt schlagen wir vor, dass die Sortierung die Groß-/Kleinschreibung ignorieren und in alphabetischer Reihenfolge sortieren sollte. Um diesen Algorithmus zu implementieren, müssen keine größeren Änderungen am vorhandenen Code vorgenommen werden, solange wir eine Schlüsselfunktion verwenden können, um die Zeichenfolge einer Sortierung zuzuordnen, bei der die Groß- und Kleinschreibung ignoriert wird. Der Vergleich zweier Zeichenfolgen unter Ignorieren der Groß-/Kleinschreibung bedeutet eigentlich, die Zeichenfolgen zunächst in Großbuchstaben (oder Kleinbuchstaben) umzuwandeln und sie dann zu vergleichen.
Auf diese Weise übergeben wir die Schlüsselfunktion an sorted, um eine Sortierung zu erreichen, die die Groß-/Kleinschreibung ignoriert: >>> , 'Credit'], key=str.lower)['about', 'bob', 'Credit', 'Zoo']
Um die Sortierung umzukehren, sind keine Änderungen erforderlich Funktion können Sie den dritten Parameter reverse=True übergeben:
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str. Lower , reverse=True)
['Zoo', 'Credit', 'bob', 'about']
Wie aus den obigen Beispielen ersichtlich ist, ist die Abstraktionsfähigkeit höherer Ordnung Die Funktionen sind sehr leistungsstark und der Kerncode kann sehr einfach gehalten werden.
Zusammenfassung
sorted() ist ebenfalls eine Funktion höherer Ordnung. Der Schlüssel zum Sortieren mit sorted() liegt in der Implementierung einer Zuordnungsfunktion.
Rückgabefunktion
Funktion als Rückgabewert
Funktionen höherer Ordnung können nicht nur Funktionen als Parameter akzeptieren, sondern auch Funktionen als Ergebniswerte zurückgeben.
Lassen Sie uns die Summierung eines variablen Parameters implementieren. Normalerweise ist die Summationsfunktion wie folgt definiert:
def calc_sum(*args):
ax = 0 für n in args:
ax = ax + n return ax
Was aber, wenn die Summe nicht sofort berechnet werden muss, sondern nach Bedarf im nachfolgenden Code berechnet wird? Anstatt das Summationsergebnis zurückzugeben, können Sie die Summationsfunktion zurückgeben:
def lazy_sum(*args): def sum():
ax = 0 for n in args:
ax = ax + n return ax return sum
Wenn wir lazy_sum() aufrufen, wird nicht das Summierungsergebnis zurückgegeben, sondern die Summationsfunktion:
>>> (1, 3, 5, 7, 9)
>>> f
.sum at 0x101c6ed90>
Das Ergebnis von Die Summe wird tatsächlich berechnet, wenn die Funktion f aufgerufen wird:
>>> f()25
In diesem Beispiel definieren wir sie in der Funktion lazy_sum, Funktion sum , und die interne Funktionssumme kann auf die Parameter und lokalen Variablen der externen Funktion lazy_sum verweisen. Wenn lazy_sum die Funktionssumme zurückgibt, werden die relevanten Parameter und Variablen in der zurückgegebenen Funktion gespeichert. Dies wird als „Abschluss“ bezeichnet Leistung.
Bitte beachten Sie noch etwas: Wenn wir lazy_sum() aufrufen, gibt jeder Aufruf eine neue Funktion zurück, auch wenn dieselben Parameter übergeben werden:
>>> lazy_sum(1, 3, 5, 7, 9)>>> f2 = lazy_sum(1, 3, 5, 7, 9)>>> >Die Aufrufergebnisse von f1() und f2() beeinflussen sich gegenseitig nicht.
Abschluss Beachten Sie, dass die zurückgegebene Funktion in ihrer Definition auf die lokalen Variablen args verweist. Wenn eine Funktion eine Funktion zurückgibt, werden daher auch ihre internen lokalen Variablen referenziert Der Verschluss ist einfach zu verwenden, aber nicht einfach umzusetzen. Ein weiteres zu beachtendes Problem besteht darin, dass die zurückgegebene Funktion nicht sofort ausgeführt wird, sondern erst ausgeführt wird, wenn f() aufgerufen wird. Schauen wir uns ein Beispiel an: def count(): fs = [] for i in range(1, 4): def f(): return i*i
fs.append( f) fs zurückgeben
f1, f2, f3 = count()
Im obigen Beispiel wird bei jeder Schleife eine neue Funktion erstellt und dann das erstellte Ganze Drei Funktionen sind zurückgekehrt.
Sie denken vielleicht, dass die Ergebnisse des Aufrufs von f1(), f2() und f3() 1, 4, 9 sein sollten, aber die tatsächlichen Ergebnisse sind: >>> ; f1() 9>>> f2()9>>> f3()9
Alle sind 9! Der Grund dafür ist, dass die zurückgegebene Funktion auf die Variable i verweist, diese aber nicht sofort ausgeführt wird. Wenn alle drei Funktionen zurückkehren, ist die Variable i, auf die sie sich beziehen, zu 3 geworden, sodass das Endergebnis 9 ist.
Bei der Rückgabe eines Abschlusses ist Folgendes zu beachten: Die Rückgabefunktion sollte keine Schleifenvariablen oder Variablen referenzieren, die sich später ändern. Was passiert, wenn Sie auf eine Schleifenvariable verweisen müssen? Die Methode besteht darin, eine weitere Funktion zu erstellen und die Parameter der Funktion zu verwenden, um den aktuellen Wert der Schleifenvariablen zu binden. Unabhängig davon, wie sich die Schleifenvariable anschließend ändert, bleibt der an den Funktionsparameter gebundene Wert unverändert: def count(): def f(j): def g(): ’ to ’ s. ’ s ’ s ‐ ‐ ‐ to ) wird sofort ausgeführt, sodass der aktuelle Wert von i an f() übergeben wird, return fs
Sehen Sie sich das Ergebnis noch einmal an:
>>> f1, f2, f3 = count()>>> )4>>> f3()9
Der Nachteil ist, dass der Code länger ist und die Lambda-Funktion verwendet werden kann. Verkürzen Sie den Code.
Zusammenfassung
Eine Funktion kann ein Berechnungsergebnis oder eine Funktion zurückgeben. Bedenken Sie bei der Rückgabe einer Funktion, dass die Funktion nicht ausgeführt wird, und verweisen Sie nicht auf Variablen, die sich in der zurückgegebenen Funktion ändern könnten. Anonyme FunktionWenn wir eine Funktion übergeben, müssen wir die Funktion manchmal nicht explizit definieren. Es ist bequemer, die anonyme Funktion direkt zu übergeben. In Python gibt es begrenzte Unterstützung für anonyme Funktionen. Nehmen wir immer noch die Funktion map() als Beispiel: Bei der Berechnung von f(x)=x2 können Sie zusätzlich zur Definition einer Funktion von f(x) auch direkt eine anonyme Funktion übergeben: > >> list (map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))[1, 4, 9, 16, 25, 36, 49 , 64, 81]
Wie aus dem Vergleich hervorgeht, ist die anonyme Funktion Lambda x: x * x tatsächlich:
def f(x): return x * x
Das Schlüsselwort Lambda repräsentiert eine anonyme Funktion und das x vor dem Doppelpunkt repräsentiert Funktionsparameter.
Anonyme Funktionen haben eine Einschränkung, das heißt, sie können nur einen Ausdruck haben. Es ist nicht erforderlich, einen Rückgabewert zu schreiben.
Die Verwendung anonymer Funktionen bietet einen Vorteil, da die Funktion keinen Namen hat, sodass Sie sich keine Sorgen über Funktionsnamenkonflikte machen müssen. Darüber hinaus ist die anonyme Funktion auch ein Funktionsobjekt. Sie können die anonyme Funktion auch einer Variablen zuweisen und diese dann zum Aufrufen der Funktion verwenden:
>>> * x
>>> f
>>> f(5)
In ähnlicher Weise können Sie anonyme Funktionen als Rückgabewerte zurückgeben, zum Beispiel: def build(x, y): return lambda: x * x + y * y
Summary Python bietet nur begrenzte Unterstützung für anonyme Funktionen und nur einige einfache Situationen können anonyme Funktionen verwenden. Teilfunktion Das Functools-Modul von Python bietet viele nützliche Funktionen, darunter eine Teilfunktion. Es ist zu beachten, dass sich die Teilfunktion hier von der Teilfunktion im mathematischen Sinne unterscheidet. Bei der Einführung von Funktionsparametern haben wir erwähnt, dass durch Festlegen der Standardwerte von Parametern die Schwierigkeit des Funktionsaufrufs verringert werden kann. Teilfunktionen können dies auch tun. Beispiel: Die Funktion int() kann eine Zeichenfolge in eine Ganzzahl umwandeln. Wenn nur eine Zeichenfolge übergeben wird, verwendet die Funktion int() standardmäßig die Dezimalkonvertierung: >> > int('12345')12345
Aber die Funktion int() stellt auch einen zusätzlichen Basisparameter bereit, der Standardwert ist 10. Wenn Sie den Basisparameter übergeben, können Sie eine N-Basis-Konvertierung durchführen: >>> ' 12345', 16)74565
Unter der Annahme, dass wir eine große Anzahl binärer Zeichenfolgen konvertieren möchten, ist es sehr mühsam, jedes Mal int(x, base=2) zu übergeben, so dachten wir Damit wir eine int2( )-Funktion definieren können, wird standardmäßig base=2 übergeben:
def int2(x, base=2): return int(x, base)
Auf diese Weise konvertieren wir binär Sehr praktisch:
>>> int2('1000000')64>>> int2('1010101')85
functools.partial soll uns helfen, eine Teilfunktion zu erstellen. Wir müssen int2() nicht selbst definieren. Wir können den folgenden Code direkt verwenden, um eine neue Funktion int2 zu erstellen:
>>> ;import functools>>> int2('1010101')85
Eine kurze Zusammenfassung von functools.partial Die Funktion besteht darin, bestimmte Parameter einer Funktion festzulegen (dh Standardwerte festzulegen) und eine neue Funktion zurückzugeben. Es wird einfacher sein, diese neue Funktion aufzurufen.
Beachten Sie, dass die neue int2-Funktion oben nur den Basisparameter auf den Standardwert 2 zurücksetzt, aber beim Aufruf der Funktion können auch andere Werte übergeben werden: >> ; > int2('1000000', base=10)1000000
Schließlich können Sie beim Erstellen einer Teilfunktion tatsächlich drei Parameter erhalten: Funktionsobjekt, *args und **kw in :
int2 = functools.partial(int, base=2)
legt tatsächlich die Schlüsselwortparameterbasis der int()-Funktion fest, das heißt:
int2('10010')
entspricht:
kw = { 'base': 2 }int('10010', **kw) Wenn Folgendes übergeben wird:
max2 = functools.partial(max, 10)
fügt tatsächlich automatisch 10 links als Teil von *args hinzu, das heißt:
max2(5, 6, 7)
entspricht:
args = (10, 5, 6, 7)max(* args )
Das Ergebnis ist 10.
ZusammenfassungWenn eine Funktion zu viele Parameter hat und vereinfacht werden muss, können Sie functools.partial verwenden, um eine neue Funktion zu erstellen. Diese neue Funktion kann einige der Parameter des Originals korrigieren Funktion, daher ist es einfacher beim Aufrufen.
