Get started learning Python with DataCamp's free Intro to Python tutorial. Learn Data Science by completing interactive coding challenges and watching videos by expert instructors. Start Now!
This site is generously supported by DataCamp. DataCamp offers online interactive Python Tutorials for Data Science. Join 11 million other learners and get started learning Python for data science today!
Good news! You can save 25% off your Datacamp annual subscription with the code LEARNPYTHON23ALE25 - Click here to redeem your discount
Dekoratoren
Dekoratoren ermöglichen es Ihnen, einfache Modifikationen an aufrufbaren Objekten wie Funktionen, Methoden oder Klassen vorzunehmen. In diesem Tutorial werden wir uns mit Funktionen beschäftigen. Die Syntax
@decorator
def functions(arg):
return "value"
ist äquivalent zu:
def function(arg):
return "value"
function = decorator(function) # dies übergibt die Funktion an den Dekorator und weist sie der Funktion wieder zu
Wie Sie vielleicht gesehen haben, ist ein Dekorator nur eine weitere Funktion, die eine Funktion nimmt und eine zurückgibt. Zum Beispiel könnten Sie dies tun:
def repeater(old_function):
def new_function(*args, **kwds): # Siehe learnpython.org/en/Multiple%20Function%20Arguments, um zu verstehen, wie *args und **kwds funktionieren
old_function(*args, **kwds) # wir führen die alte Funktion aus
old_function(*args, **kwds) # wir machen das zwei Mal
return new_function # wir müssen die new_function zurückgeben, sonst würde sie nicht der Funktion zugewiesen
Dies würde eine Funktion zweimal ausführen.
>>> @repeater
def multiply(num1, num2):
print(num1 * num2)
>>> multiply(2, 3)
6
6
Sie können auch den Ausgabe ändern
def double_out(old_function):
def new_function(*args, **kwds):
return 2 * old_function(*args, **kwds) # den Rückgabewert modifizieren
return new_function
oder den Input ändern
def double_Ii(old_function):
def new_function(arg): # funktioniert nur, wenn die alte Funktion ein Argument hat
return old_function(arg * 2) # das übergebene Argument modifizieren
return new_function
und Überprüfungen durchführen.
def check(old_function):
def new_function(arg):
if arg < 0: raise (ValueError, "Negative Argument") # Dies verursacht einen Fehler, was besser ist, als wenn es das Falsche tut
old_function(arg)
return new_function
Angenommen, Sie möchten die Ausgabe mit einem variablen Betrag multiplizieren. Sie könnten den Dekorator definieren und wie folgt verwenden:
def multiply(multiplier):
def multiply_generator(old_function):
def new_function(*args, **kwds):
return multiplier * old_function(*args, **kwds)
return new_function
return multiply_generator # es gibt den neuen Generator zurück
# Verwendung
@multiply(3) # multiply ist kein Generator, aber multiply(3) ist es
def return_num(num):
return num
# Jetzt ist return_num dekoriert und wieder zu sich selbst zugewiesen
return_num(5) # sollte 15 zurückgeben
Sie können mit der alten Funktion alles machen, was Sie wollen, sie sogar komplett ignorieren! Fortgeschrittene Dekoratoren können auch die doc-Strings und Argumentzahlen manipulieren. Für einige tolle Dekoratoren besuchen Sie http://wiki.python.org/moin/PythonDecoratorLibrary.
Übung
Erstellen Sie eine Dekorator-Fabrik, die einen Dekorator zurückgibt, der Funktionen mit einem Argument dekoriert. Die Fabrik sollte ein Argument vom Typ annehmen und dann einen Dekorator zurückgeben, der prüft, ob die Eingabe von der richtigen Art ist. Wenn sie falsch ist, sollte sie print("Bad Type") ausgeben (In Wirklichkeit sollte ein Fehler ausgelöst werden, aber Fehlerauslösung ist nicht Teil dieses Tutorials). Schauen Sie sich den Tutorial-Code und die erwartete Ausgabe an, um zu sehen, was gemeint ist, falls Sie verwirrt sind (ich wäre es jedenfalls). Die Verwendung von isinstance(object, type_of_object) oder type(object) könnte hilfreich sein.
def type_check(correct_type):
#put code here
@type_check(int)
def times2(num):
return num*2
print(times2(2))
times2('Not A Number')
@type_check(str)
def first_letter(word):
return word[0]
print(first_letter('Hello World'))
first_letter(['Not', 'A', 'String'])
def type_check(correct_type):
def check(old_function):
def new_function(arg):
if (isinstance(arg, correct_type)):
return old_function(arg)
else:
print("Bad Type")
return new_function
return check
@type_check(int)
def times2(num):
return num*2
print(times2(2))
times2('Not A Number')
@type_check(str)
def first_letter(word):
return word[0]
print(first_letter('Hello World'))
first_letter(['Not', 'A', 'String'])
test_output_contains("4")
test_output_contains("Bad Type")
test_output_contains("H")
test_output_contains("Bad Type")
success_msg("Good job!")
This site is generously supported by DataCamp. DataCamp offers online interactive Python Tutorials for Data Science. Join over a million other learners and get started learning Python for data science today!