Bir fonksiyon dekorat├Âr├╝ zinciri nas─▒l yap─▒l─▒r?


Al─▒nan cevaba git


Python'da a┼ča─č─▒dakileri yapan iki dekorat├Âr├╝ nas─▒l yapabilirim?

 @makebold
@makeitalic
def say():
   return "Hello"
 

... ki geri d├Ânmeli:

 "<b><i>Hello</i></b>"
 

HTML Bu yolu ger├žek bir uygulamada yapmaya ├žal─▒┼čm─▒yorum - sadece dekorat├Ârlerin ve dekorat├Âr zincirinin nas─▒l ├žal─▒┼čt─▒─č─▒n─▒ anlamaya ├žal─▒┼č─▒yorum.


2626









Cevap say─▒s─▒n─▒ say: 17






Check out belgelere dekorat├Ârler nas─▒l ├žal─▒┼čt─▒─č─▒n─▒ g├Ârmek i├žin. ─░┼čte istedi─čin ┼čey:

 from functools import wraps

def makebold(fn):
    @wraps(fn)
    def wrapped(*args, **kwargs):
        return "<b>" + fn(*args, **kwargs) + "</b>"
    return wrapped

def makeitalic(fn):
    @wraps(fn)
    def wrapped(*args, **kwargs):
        return "<i>" + fn(*args, **kwargs) + "</i>"
    return wrapped

@makebold
@makeitalic
def hello():
    return "hello world"

@makebold
@makeitalic
def log(s):
    return s

print hello()        # returns "<b><i>hello world</i></b>"
print hello.__name__ # with functools.wraps() this returns "hello"
print log('hello')   # returns "<b><i>hello</i></b>"
 

2842







Uzun a├ž─▒klamalarda de─čilseniz, Paolo Bergentino'nun cevab─▒n─▒ g├Âr├╝n .

Dekorat├Âr Temelleri

Python'un i┼člevleri nesnelerdir

Dekorat├Ârleri anlamak i├žin, ├Âncelikle i┼člevlerin Python'da nesneler oldu─čunu anlamal─▒s─▒n─▒z. Bunun ├Ânemli sonu├žlar─▒ var. Neden basit bir ├Ârnekle g├Ârelim:

 def shout(word="yes"):
    return word.capitalize()+"!"

print(shout())
# outputs : 'Yes!'

# As an object, you can assign the function to a variable like any other object 
scream = shout

# Notice we don't use parentheses: we are not calling the function,
# we are putting the function "shout" into the variable "scream".
# It means you can then call "shout" from "scream":

print(scream())
# outputs : 'Yes!'

# More than that, it means you can remove the old name 'shout',
# and the function will still be accessible from 'scream'

del shout
try:
    print(shout())
except NameError as e:
    print(e)
    #outputs: "name 'shout' is not defined"

print(scream())
# outputs: 'Yes!'
 

Bunu akl─▒nda tut. K─▒sa s├╝re sonra geri d├Ânece─čiz.

Python fonksiyonlar─▒n─▒n bir ba┼čka ilgin├ž ├Âzelli─či ise ba┼čka bir fonksiyon i├žinde tan─▒mlanabilmeleridir!

 def talk():

    # You can define a function on the fly in "talk" ...
    def whisper(word="yes"):
        return word.lower()+"..."

    # ... and use it right away!
    print(whisper())

# You call "talk", that defines "whisper" EVERY TIME you call it, then
# "whisper" is called in "talk". 
talk()
# outputs: 
# "yes..."

# But "whisper" DOES NOT EXIST outside "talk":

try:
    print(whisper())
except NameError as e:
    print(e)
    #outputs : "name 'whisper' is not defined"*
    #Python's functions are objects
 

─░┼člev referanslar─▒

Tamam, hala burada m─▒s─▒n? ┼×imdi e─členceli k─▒s─▒m ...

─░┼člevlerin nesne oldu─čunu g├Ârd├╝n├╝z. Bu nedenle, i┼člevler:

  • de─či┼čkene atanabilir
  • ba┼čka bir fonksiyonda tan─▒mlanabilir

Bu, bir i┼člevin return ba┼čka bir i┼čleve sahip olabilece─či anlam─▒na gelir .

 def getTalk(kind="shout"):

    # We define functions on the fly
    def shout(word="yes"):
        return word.capitalize()+"!"

    def whisper(word="yes") :
        return word.lower()+"...";

    # Then we return one of them
    if kind == "shout":
        # We don't use "()", we are not calling the function,
        # we are returning the function object
        return shout  
    else:
        return whisper

# How do you use this strange beast?

# Get the function and assign it to a variable
talk = getTalk()      

# You can see that "talk" is here a function object:
print(talk)
#outputs : <function shout at 0xb7ea817c>

# The object is the one returned by the function:
print(talk())
#outputs : Yes!

# And you can even use it directly if you feel wild:
print(getTalk("whisper")())
#outputs : yes...
 

Fazlas─▒ var!

return Bir i┼člev yapabilirseniz , birini parametre olarak iletebilirsiniz:

 def doSomethingBefore(func): 
    print("I do something before then I call the function you gave me")
    print(func())

doSomethingBefore(scream)
#outputs: 
#I do something before then I call the function you gave me
#Yes!
 

Dekorat├Ârleri anlamak i├žin gereken her ┼čeye sahipsin. G├Âr├╝yorsunuz, dekorat├Ârler ÔÇťsarmalay─▒c─▒ÔÇŁ d─▒r, yani fonksiyonun kendisini de─či┼čtirmeden dekore ettikleri fonksiyondan ├Ânce ve sonra kod ├žal─▒┼čt─▒rman─▒za izin verirler .

El i┼či dekorat├Ârler

Manuel olarak nas─▒l yapars─▒n─▒z:

 # A decorator is a function that expects ANOTHER function as parameter
def my_shiny_new_decorator(a_function_to_decorate):

    # Inside, the decorator defines a function on the fly: the wrapper.
    # This function is going to be wrapped around the original function
    # so it can execute code before and after it.
    def the_wrapper_around_the_original_function():

        # Put here the code you want to be executed BEFORE the original function is called
        print("Before the function runs")

        # Call the function here (using parentheses)
        a_function_to_decorate()

        # Put here the code you want to be executed AFTER the original function is called
        print("After the function runs")

    # At this point, "a_function_to_decorate" HAS NEVER BEEN EXECUTED.
    # We return the wrapper function we have just created.
    # The wrapper contains the function and the code to execute before and after. ItÔÇÖs ready to use!
    return the_wrapper_around_the_original_function

# Now imagine you create a function you don't want to ever touch again.
def a_stand_alone_function():
    print("I am a stand alone function, don't you dare modify me")

a_stand_alone_function() 
#outputs: I am a stand alone function, don't you dare modify me

# Well, you can decorate it to extend its behavior.
# Just pass it to the decorator, it will wrap it dynamically in 
# any code you want and return you a new function ready to be used:

a_stand_alone_function_decorated = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function_decorated()
#outputs:
#Before the function runs
#I am a stand alone function, don't you dare modify me
#After the function runs
 

┼×imdi, muhtemelen ├ža─čr─▒ her zaman bunu istiyorum a_stand_alone_function , a_stand_alone_function_decorated bunun yerine denir. Bu kolay, sadece a_stand_alone_function i┼člevinin d├Ând├╝rd├╝─č├╝ fonksiyonun ├╝zerine yaz my_shiny_new_decorator :

 a_stand_alone_function = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function()
#outputs:
#Before the function runs
#I am a stand alone function, don't you dare modify me
#After the function runs

# ThatÔÇÖs EXACTLY what decorators do!
 

Dekorat├Ârler par├žalanm─▒┼č

Dekorat├Âr s├Âzdizimini kullanan ├Ânceki ├Ârnek:

 @my_shiny_new_decorator
def another_stand_alone_function():
    print("Leave me alone")

another_stand_alone_function()  
#outputs:  
#Before the function runs
#Leave me alone
#After the function runs
 

Evet, hepsi bu kadar basit. @decorator sadece bir k─▒sayol:

 another_stand_alone_function = my_shiny_new_decorator(another_stand_alone_function)
 

Dekorat├Ârler, dekorat├Âr tasar─▒m modelinin yaln─▒zca bir pitonik varyant─▒d─▒r . Geli┼čtirmeyi kolayla┼čt─▒rmak i├žin Python'da yerle┼čik birka├ž klasik tasar─▒m deseni vard─▒r (yineleyiciler gibi).

Elbette, dekorat├Ârler biriktirebilirsiniz:

 def bread(func):
    def wrapper():
        print("</''''''\>")
        func()
        print("<\______/>")
    return wrapper

def ingredients(func):
    def wrapper():
        print("#tomatoes#")
        func()
        print("~salad~")
    return wrapper

def sandwich(food="--ham--"):
    print(food)

sandwich()
#outputs: --ham--
sandwich = bread(ingredients(sandwich))
sandwich()
#outputs:
#</''''''\>
# #tomatoes#
# --ham--
# ~salad~
#<\______/>
 

Python dekorat├Âr s├Âzdizimini kullanarak:

 @bread
@ingredients
def sandwich(food="--ham--"):
    print(food)

sandwich()
#outputs:
#</''''''\>
# #tomatoes#
# --ham--
# ~salad~
#<\______/>
 

Dekorat├Ârleri ayarlad─▒─č─▒n─▒z s─▒rayla MATTERS:

 @ingredients
@bread
def strange_sandwich(food="--ham--"):
    print(food)

strange_sandwich()
#outputs:
##tomatoes#
#</''''''\>
# --ham--
#<\______/>
# ~salad~
 

┼×imdi: soruyu cevaplamak i├žin ...

Sonu├ž olarak, soruyu nas─▒l cevaplayaca─č─▒n─▒z─▒ kolayca g├Ârebilirsiniz:

 # The decorator to make it bold
def makebold(fn):
    # The new function the decorator returns
    def wrapper():
        # Insertion of some code before and after
        return "<b>" + fn() + "</b>"
    return wrapper

# The decorator to make it italic
def makeitalic(fn):
    # The new function the decorator returns
    def wrapper():
        # Insertion of some code before and after
        return "<i>" + fn() + "</i>"
    return wrapper

@makebold
@makeitalic
def say():
    return "hello"

print(say())
#outputs: <b><i>hello</i></b>

# This is the exact equivalent to 
def say():
    return "hello"
say = makebold(makeitalic(say))

print(say())
#outputs: <b><i>hello</i></b>
 

Art─▒k sadece mutlu b─▒rakabilirsiniz veya beyninizi biraz daha yakabilir ve dekorat├Ârlerin geli┼čmi┼č kullan─▒mlar─▒n─▒ g├Ârebilirsiniz.


Dekorat├Ârleri bir sonraki seviyeye ├ž─▒karmak

Dekore edilmi┼č i┼čleve arg├╝manlar g├Ânderme

 # ItÔÇÖs not black magic, you just have to let the wrapper 
# pass the argument:

def a_decorator_passing_arguments(function_to_decorate):
    def a_wrapper_accepting_arguments(arg1, arg2):
        print("I got args! Look: {0}, {1}".format(arg1, arg2))
        function_to_decorate(arg1, arg2)
    return a_wrapper_accepting_arguments

# Since when you are calling the function returned by the decorator, you are
# calling the wrapper, passing arguments to the wrapper will let it pass them to 
# the decorated function

@a_decorator_passing_arguments
def print_full_name(first_name, last_name):
    print("My name is {0} {1}".format(first_name, last_name))

print_full_name("Peter", "Venkman")
# outputs:
#I got args! Look: Peter Venkman
#My name is Peter Venkman
 

Dekorasyon y├Ântemleri

Python ile ilgili ilgin├ž bir ┼čey, y├Ântem ve fonksiyonlar─▒n ger├žekten ayn─▒ olmas─▒d─▒r. Tek fark, y├Ântemlerin ilk arg├╝manlar─▒n─▒n o anki nesneye bir referans olmas─▒n─▒ beklemesidir self .

Bu, ayn─▒ ┼čekilde y├Ântemler i├žin bir dekorat├Âr kurabilece─činiz anlam─▒na gelir! Sadece self dikkate almay─▒ unutmay─▒n :

 def method_friendly_decorator(method_to_decorate):
    def wrapper(self, lie):
        lie = lie - 3 # very friendly, decrease age even more :-)
        return method_to_decorate(self, lie)
    return wrapper


class Lucy(object):

    def __init__(self):
        self.age = 32

    @method_friendly_decorator
    def sayYourAge(self, lie):
        print("I am {0}, what did you think?".format(self.age + lie))

l = Lucy()
l.sayYourAge(-3)
#outputs: I am 26, what did you think?
 

Genel ama├žl─▒ bir dekorat├Âr yap─▒yorsan─▒z - biri ne olursa olsun arg├╝manlar─▒na bak─▒lmaks─▒z─▒n herhangi bir i┼čleve veya y├Ânteme uygulan─▒r - o zaman ┼čunu kullan─▒n *args, **kwargs :

 def a_decorator_passing_arbitrary_arguments(function_to_decorate):
    # The wrapper accepts any arguments
    def a_wrapper_accepting_arbitrary_arguments(*args, **kwargs):
        print("Do I have args?:")
        print(args)
        print(kwargs)
        # Then you unpack the arguments, here *args, **kwargs
        # If you are not familiar with unpacking, check:
        # http://www.saltycrane.com/blog/2008/01/how-to-use-args-and-kwargs-in-python/
        function_to_decorate(*args, **kwargs)
    return a_wrapper_accepting_arbitrary_arguments

@a_decorator_passing_arbitrary_arguments
def function_with_no_argument():
    print("Python is cool, no argument here.")

function_with_no_argument()
#outputs
#Do I have args?:
#()
#{}
#Python is cool, no argument here.

@a_decorator_passing_arbitrary_arguments
def function_with_arguments(a, b, c):
    print(a, b, c)

function_with_arguments(1,2,3)
#outputs
#Do I have args?:
#(1, 2, 3)
#{}
#1 2 3 

@a_decorator_passing_arbitrary_arguments
def function_with_named_arguments(a, b, c, platypus="Why not ?"):
    print("Do {0}, {1} and {2} like platypus? {3}".format(a, b, c, platypus))

function_with_named_arguments("Bill", "Linus", "Steve", platypus="Indeed!")
#outputs
#Do I have args ? :
#('Bill', 'Linus', 'Steve')
#{'platypus': 'Indeed!'}
#Do Bill, Linus and Steve like platypus? Indeed!

class Mary(object):

    def __init__(self):
        self.age = 31

    @a_decorator_passing_arbitrary_arguments
    def sayYourAge(self, lie=-3): # You can now add a default value
        print("I am {0}, what did you think?".format(self.age + lie))

m = Mary()
m.sayYourAge()
#outputs
# Do I have args?:
#(<__main__.Mary object at 0xb7d303ac>,)
#{}
#I am 28, what did you think?
 

Dekorat├Âre arg├╝manlar g├Ânderme

Harika, ┼čimdi arg├╝manlar─▒n dekorat├Âre ge├žmesi hakk─▒nda ne s├Âylersin?

Bir dekorat├Âr bir arg├╝man olarak bir i┼člevi kabul etmek zorunda kald─▒─č─▒ndan, bu biraz b├╝k├╝lebilir. Bu nedenle, dekore edilmi┼č fonksiyonun arg├╝manlar─▒n─▒ do─črudan dekorat├Âre iletemezsiniz.

├ç├Âz├╝m i├žin acele etmeden ├Ânce, k├╝├ž├╝k bir hat─▒rlatma yazal─▒m:

 # Decorators are ORDINARY functions
def my_decorator(func):
    print("I am an ordinary function")
    def wrapper():
        print("I am function returned by the decorator")
        func()
    return wrapper

# Therefore, you can call it without any "@"

def lazy_function():
    print("zzzzzzzz")

decorated_function = my_decorator(lazy_function)
#outputs: I am an ordinary function

# It outputs "I am an ordinary function", because thatÔÇÖs just what you do:
# calling a function. Nothing magic.

@my_decorator
def lazy_function():
    print("zzzzzzzz")

#outputs: I am an ordinary function
 

Tamamen ayn─▒. " my_decorator " denir. ├ľyleyse @my_decorator , Python'a '' " my_decorator " de─či┼čkeni ile etiketlenmi┼č i┼člevi ├ža─č─▒rmas─▒n─▒ s├Âyl├╝yorsunuz .

Bu ├Ânemli! Verdi─činiz etiket do─črudan dekorat├Âre i┼čaret edebilir - ya da g├Âsteremez .

K├Ât├╝l├╝k alal─▒m. Ôś║

 def decorator_maker():

    print("I make decorators! I am executed only once: "
          "when you make me create a decorator.")

    def my_decorator(func):

        print("I am a decorator! I am executed only when you decorate a function.")

        def wrapped():
            print("I am the wrapper around the decorated function. "
                  "I am called when you call the decorated function. "
                  "As the wrapper, I return the RESULT of the decorated function.")
            return func()

        print("As the decorator, I return the wrapped function.")

        return wrapped

    print("As a decorator maker, I return a decorator")
    return my_decorator

# LetÔÇÖs create a decorator. ItÔÇÖs just a new function after all.
new_decorator = decorator_maker()       
#outputs:
#I make decorators! I am executed only once: when you make me create a decorator.
#As a decorator maker, I return a decorator

# Then we decorate the function

def decorated_function():
    print("I am the decorated function.")

decorated_function = new_decorator(decorated_function)
#outputs:
#I am a decorator! I am executed only when you decorate a function.
#As the decorator, I return the wrapped function

# LetÔÇÖs call the function:
decorated_function()
#outputs:
#I am the wrapper around the decorated function. I am called when you call the decorated function.
#As the wrapper, I return the RESULT of the decorated function.
#I am the decorated function.
 

Burada s├╝rpriz yok.

Tam olarak ayn─▒ ┼čeyi yapal─▒m, ancak t├╝m sinir bozucu ara de─či┼čkenleri atlay─▒n:

 def decorated_function():
    print("I am the decorated function.")
decorated_function = decorator_maker()(decorated_function)
#outputs:
#I make decorators! I am executed only once: when you make me create a decorator.
#As a decorator maker, I return a decorator
#I am a decorator! I am executed only when you decorate a function.
#As the decorator, I return the wrapped function.

# Finally:
decorated_function()    
#outputs:
#I am the wrapper around the decorated function. I am called when you call the decorated function.
#As the wrapper, I return the RESULT of the decorated function.
#I am the decorated function.
 

Daha da k─▒saltal─▒m :

 @decorator_maker()
def decorated_function():
    print("I am the decorated function.")
#outputs:
#I make decorators! I am executed only once: when you make me create a decorator.
#As a decorator maker, I return a decorator
#I am a decorator! I am executed only when you decorate a function.
#As the decorator, I return the wrapped function.

#Eventually: 
decorated_function()    
#outputs:
#I am the wrapper around the decorated function. I am called when you call the decorated function.
#As the wrapper, I return the RESULT of the decorated function.
#I am the decorated function.
 

Hey, g├Ârd├╝n m├╝? " @ " S├Âzdiziminde i┼člev ├ža─čr─▒s─▒ kulland─▒k ! :-)

Yani, ba─č─▒ms─▒z de─či┼čkenlerle dekorat├Ârlere geri d├Ânelim. Dekorat├Âr├╝ an─▒nda olu┼čturmak i├žin i┼člevleri kullanabilirsek, bu i┼čleve arg├╝manlar─▒ iletebiliriz, de─čil mi?

 def decorator_maker_with_arguments(decorator_arg1, decorator_arg2):

    print("I make decorators! And I accept arguments: {0}, {1}".format(decorator_arg1, decorator_arg2))

    def my_decorator(func):
        # The ability to pass arguments here is a gift from closures.
        # If you are not comfortable with closures, you can assume itÔÇÖs ok,
        # or read: https://stackoverflow.com/questions/13857/can-you-explain-closures-as-they-relate-to-python
        print("I am the decorator. Somehow you passed me arguments: {0}, {1}".format(decorator_arg1, decorator_arg2))

        # Don't confuse decorator arguments and function arguments!
        def wrapped(function_arg1, function_arg2) :
            print("I am the wrapper around the decorated function.\n"
                  "I can access all the variables\n"
                  "\t- from the decorator: {0} {1}\n"
                  "\t- from the function call: {2} {3}\n"
                  "Then I can pass them to the decorated function"
                  .format(decorator_arg1, decorator_arg2,
                          function_arg1, function_arg2))
            return func(function_arg1, function_arg2)

        return wrapped

    return my_decorator

@decorator_maker_with_arguments("Leonard", "Sheldon")
def decorated_function_with_arguments(function_arg1, function_arg2):
    print("I am the decorated function and only knows about my arguments: {0}"
           " {1}".format(function_arg1, function_arg2))

decorated_function_with_arguments("Rajesh", "Howard")
#outputs:
#I make decorators! And I accept arguments: Leonard Sheldon
#I am the decorator. Somehow you passed me arguments: Leonard Sheldon
#I am the wrapper around the decorated function. 
#I can access all the variables 
#   - from the decorator: Leonard Sheldon 
#   - from the function call: Rajesh Howard 
#Then I can pass them to the decorated function
#I am the decorated function and only knows about my arguments: Rajesh Howard
 

─░┼čte burada: arg├╝manlar─▒ olan bir dekorat├Âr. Arg├╝manlar de─či┼čken olarak ayarlanabilir:

 c1 = "Penny"
c2 = "Leslie"

@decorator_maker_with_arguments("Leonard", c1)
def decorated_function_with_arguments(function_arg1, function_arg2):
    print("I am the decorated function and only knows about my arguments:"
           " {0} {1}".format(function_arg1, function_arg2))

decorated_function_with_arguments(c2, "Howard")
#outputs:
#I make decorators! And I accept arguments: Leonard Penny
#I am the decorator. Somehow you passed me arguments: Leonard Penny
#I am the wrapper around the decorated function. 
#I can access all the variables 
#   - from the decorator: Leonard Penny 
#   - from the function call: Leslie Howard 
#Then I can pass them to the decorated function
#I am the decorated function and only know about my arguments: Leslie Howard
 

G├Ârd├╝─č├╝n├╝z gibi, bu numaray─▒ kullanan herhangi bir i┼člev gibi, dekorat├Âre arg├╝manlar iletebilirsiniz. ─░sterseniz bile kullanabilirsiniz *args, **kwargs . Ancak dekorat├Ârlerin sadece bir kez ├ža─čr─▒ld─▒─č─▒n─▒ unutmay─▒n . Python sadece beti─či ald─▒─č─▒nda. Arg├╝manlar─▒ daha sonra dinamik olarak ayarlayamazs─▒n─▒z. "X'i" i├že aktard─▒─č─▒n─▒zda , i┼člev zaten dekore edilmi┼čtir , bu nedenle hi├žbir ┼čeyi de─či┼čtiremezsiniz.


Hadi pratik yapal─▒m: bir dekorat├Âr dekore etmek

Tamam, bir bonus olarak, herhangi bir dekorat├Âr├╝n genel olarak herhangi bir tart─▒┼čmay─▒ kabul etmesi i├žin bir pasaj verece─čim. Sonu├žta, arg├╝manlar─▒ kabul etmek i├žin, dekorat├Âr├╝m├╝z├╝ ba┼čka bir fonksiyon kullanarak yaratt─▒k.

Dekorat├Âr├╝ sard─▒k.

Yak─▒n zamanda bu sar─▒lm─▒┼č i┼člevi g├Ârd├╝─č├╝m├╝z ba┼čka bir ┼čey var m─▒?

Ah evet, dekorat├Ârler!

Biraz e─členelim ve dekorat├Ârler i├žin bir dekorat├Âr yazal─▒m:

 def decorator_with_args(decorator_to_enhance):
    """ 
    This function is supposed to be used as a decorator.
    It must decorate an other function, that is intended to be used as a decorator.
    Take a cup of coffee.
    It will allow any decorator to accept an arbitrary number of arguments,
    saving you the headache to remember how to do that every time.
    """

    # We use the same trick we did to pass arguments
    def decorator_maker(*args, **kwargs):

        # We create on the fly a decorator that accepts only a function
        # but keeps the passed arguments from the maker.
        def decorator_wrapper(func):

            # We return the result of the original decorator, which, after all, 
            # IS JUST AN ORDINARY FUNCTION (which returns a function).
            # Only pitfall: the decorator must have this specific signature or it won't work:
            return decorator_to_enhance(func, *args, **kwargs)

        return decorator_wrapper

    return decorator_maker
 

A┼ča─č─▒daki gibi kullan─▒labilir:

 # You create the function you will use as a decorator. And stick a decorator on it :-)
# Don't forget, the signature is "decorator(func, *args, **kwargs)"
@decorator_with_args 
def decorated_decorator(func, *args, **kwargs): 
    def wrapper(function_arg1, function_arg2):
        print("Decorated with {0} {1}".format(args, kwargs))
        return func(function_arg1, function_arg2)
    return wrapper

# Then you decorate the functions you wish with your brand new decorated decorator.

@decorated_decorator(42, 404, 1024)
def decorated_function(function_arg1, function_arg2):
    print("Hello {0} {1}".format(function_arg1, function_arg2))

decorated_function("Universe and", "everything")
#outputs:
#Decorated with (42, 404, 1024) {}
#Hello Universe and everything

# Whoooot!
 

Biliyorum, en son bu hissi duydu─čunda, bir adam─▒n ┼č├Âyle dinlemesinden sonrayd─▒: "├Âzyinelemeyi anlamadan ├Ânce ├Âzyinelemeyi anlamal─▒s─▒n─▒z". Ama ┼čimdi, bunu ustala┼čt─▒rma konusunda kendini iyi hissetmiyor musun?


En iyi uygulamalar: dekorat├Ârler

  • Dekorat├Ârler Python 2.4'te tan─▒t─▒ld─▒, bu nedenle kodunuzun> = 2.4'te ├žal─▒┼čt─▒r─▒laca─č─▒ndan emin olun.
  • Dekorat├Ârler fonksiyon ├ža─čr─▒s─▒n─▒ yava┼člat─▒r. Bunu akl─▒nda tut.
  • Bir i┼člevi ├ž├Âzemezsiniz. (Orada olan kald─▒r─▒labilir dekorat├Ârler olu┼čturmak i├žin kesmek, ama kimse bunlar─▒ kullan─▒r.) Bir fonksiyonu s├╝sl├╝d├╝r Yani bir kez, o dekore t├╝m kodu .
  • Dekorat├Ârler, hata ay─▒klamalar─▒n─▒ zorla┼čt─▒rabilen i┼člevleri sarar. (Bu Python> = 2.5'ten daha iyi olur; a┼ča─č─▒ya bak─▒n─▒z.)

functools Mod├╝l Python 2.5 kullan─▒lmaya ba┼čland─▒. functools.wraps() Dekore edilmi┼č i┼člevin ad─▒n─▒, mod├╝l├╝n├╝ ve belgesini paketleyicisine kopyalayan i┼člevi i├žerir .

(E─členceli ger├žek: functools.wraps() bir dekorat├Âr! Ôś║)

 # For debugging, the stacktrace prints you the function __name__
def foo():
    print("foo")

print(foo.__name__)
#outputs: foo

# With a decorator, it gets messy    
def bar(func):
    def wrapper():
        print("bar")
        return func()
    return wrapper

@bar
def foo():
    print("foo")

print(foo.__name__)
#outputs: wrapper

# "functools" can help for that

import functools

def bar(func):
    # We say that "wrapper", is wrapping "func"
    # and the magic begins
    @functools.wraps(func)
    def wrapper():
        print("bar")
        return func()
    return wrapper

@bar
def foo():
    print("foo")

print(foo.__name__)
#outputs: foo
 

Dekorat├Ârler nas─▒l faydal─▒ olabilir?

┼×imdi b├╝y├╝k soru: Dekorat├Ârleri ne i├žin kullanabilirim?

Serin ve g├╝├žl├╝ g├Âr├╝nmek, ancak pratik bir ├Ârnek harika olurdu. Eh, 1000 olas─▒l─▒k var. Klasik kullan─▒mlar, bir fonksiyon davran─▒┼č─▒n─▒ harici bir k├╝t├╝phaneden geni┼čletir (de─či┼čtiremezsiniz) veya hata ay─▒klamak i├žin (ge├žici oldu─ču i├žin de─či┼čtirmek istemezsiniz).

Bunlar─▒, bir DRY y├Ântemiyle bir├žok i┼člevi geni┼čletmek i├žin kullanabilirsiniz, ┼č├Âyle:

 def benchmark(func):
    """
    A decorator that prints the time a function takes
    to execute.
    """
    import time
    def wrapper(*args, **kwargs):
        t = time.clock()
        res = func(*args, **kwargs)
        print("{0} {1}".format(func.__name__, time.clock()-t))
        return res
    return wrapper


def logging(func):
    """
    A decorator that logs the activity of the script.
    (it actually just prints it, but it could be logging!)
    """
    def wrapper(*args, **kwargs):
        res = func(*args, **kwargs)
        print("{0} {1} {2}".format(func.__name__, args, kwargs))
        return res
    return wrapper


def counter(func):
    """
    A decorator that counts and prints the number of times a function has been executed
    """
    def wrapper(*args, **kwargs):
        wrapper.count = wrapper.count + 1
        res = func(*args, **kwargs)
        print("{0} has been used: {1}x".format(func.__name__, wrapper.count))
        return res
    wrapper.count = 0
    return wrapper

@counter
@benchmark
@logging
def reverse_string(string):
    return str(reversed(string))

print(reverse_string("Able was I ere I saw Elba"))
print(reverse_string("A man, a plan, a canoe, pasta, heros, rajahs, a coloratura, maps, snipe, percale, macaroni, a gag, a banana bag, a tan, a tag, a banana bag again (or a camel), a crepe, pins, Spam, a rut, a Rolo, cash, a jar, sore hats, a peon, a canal: Panama!"))

#outputs:
#reverse_string ('Able was I ere I saw Elba',) {}
#wrapper 0.0
#wrapper has been used: 1x 
#ablE was I ere I saw elbA
#reverse_string ('A man, a plan, a canoe, pasta, heros, rajahs, a coloratura, maps, snipe, percale, macaroni, a gag, a banana bag, a tan, a tag, a banana bag again (or a camel), a crepe, pins, Spam, a rut, a Rolo, cash, a jar, sore hats, a peon, a canal: Panama!',) {}
#wrapper 0.0
#wrapper has been used: 2x
#!amanaP :lanac a ,noep a ,stah eros ,raj a ,hsac ,oloR a ,tur a ,mapS ,snip ,eperc a ,)lemac a ro( niaga gab ananab a ,gat a ,nat a ,gab ananab a ,gag a ,inoracam ,elacrep ,epins ,spam ,arutaroloc a ,shajar ,soreh ,atsap ,eonac a ,nalp a ,nam A
 

Elbette dekorat├Ârlerdeki en iyi ┼čey, onlar─▒ hemen hemen herhangi bir ┼čey ├╝zerinde yeniden yazmadan hemen kullanabilmenizdir. KURU dedim ki:

 @counter
@benchmark
@logging
def get_random_futurama_quote():
    from urllib import urlopen
    result = urlopen("http://subfusion.net/cgi-bin/quote.pl?quote=futurama").read()
    try:
        value = result.split("<br><b><hr><br>")[1].split("<br><br><hr>")[0]
        return value.strip()
    except:
        return "No, I'm ... doesn't!"


print(get_random_futurama_quote())
print(get_random_futurama_quote())

#outputs:
#get_random_futurama_quote () {}
#wrapper 0.02
#wrapper has been used: 1x
#The laws of science be a harsh mistress.
#get_random_futurama_quote () {}
#wrapper 0.01
#wrapper has been used: 2x
#Curse you, merciful Poseidon!
 

Python kendisi birka├ž dekorat├Ârler sa─člamaktad─▒r: property , staticmethod vb

  • Django, ├Ânbelle─če almay─▒ y├Ânetmek ve izinleri g├Âr├╝nt├╝lemek i├žin dekorat├Ârler kullan─▒r.
  • E┼čzamans─▒z inlining asenkron fonksiyon ├ža─čr─▒lar─▒ yapmak i├žin b├╝k├╝lm├╝┼č.

Bu ger├žekten b├╝y├╝k bir oyun alan─▒.


4081







Alternatif olarak, dekore edilmi┼č i┼člevin geri d├Ân├╝┼č de─čerini fabrika i┼čleve ge├žirilen bir etikette saran bir dekorat├Âr d├Ând├╝ren bir fabrika i┼člevi yazabilirsiniz. ├ľrne─čin:

 from functools import wraps

def wrap_in_tag(tag):
    def factory(func):
        @wraps(func)
        def decorator():
            return '<%(tag)s>%(rv)s</%(tag)s>' % (
                {'tag': tag, 'rv': func()})
        return decorator
    return factory
 

Bu yazman─▒za olanak sa─člar:

 @wrap_in_tag('b')
@wrap_in_tag('i')
def say():
    return 'hello'
 

veya

 makebold = wrap_in_tag('b')
makeitalic = wrap_in_tag('i')

@makebold
@makeitalic
def say():
    return 'hello'
 

┼×ahsen dekorat├Âr├╝ biraz farkl─▒ yazm─▒┼č olurdum:

 from functools import wraps

def wrap_in_tag(tag):
    def factory(func):
        @wraps(func)
        def decorator(val):
            return func('<%(tag)s>%(val)s</%(tag)s>' %
                        {'tag': tag, 'val': val})
        return decorator
    return factory
 

hangi verim:

 @wrap_in_tag('b')
@wrap_in_tag('i')
def say(val):
    return val
say('hello')
 

Dekorat├Âr s├Âzdiziminin bir steno oldu─ču in┼čaat─▒ unutmay─▒n:

 say = wrap_in_tag('b')(wrap_in_tag('i')(say)))
 

141







G├Âr├╝n├╝┼če g├Âre di─čer insanlar size sorunu nas─▒l ├ž├Âzece─činizi s├Âylemi┼člerdi. Umar─▒m bu, dekorat├Ârlerin ne oldu─čunu anlaman─▒za yard─▒mc─▒ olur.

Dekorat├Ârler sadece s├Âzdizimsel ┼čeker.

Bu

 @decorator
def func():
    ...
 

i├žin geni┼čler

 def func():
    ...
func = decorator(func)
 

112







Ve tabii ki bir dekorat├Âr i┼člevinden de lambdalar─▒ geri getirebilirsiniz:

 def makebold(f): 
    return lambda: "<b>" + f() + "</b>"
def makeitalic(f): 
    return lambda: "<i>" + f() + "</i>"

@makebold
@makeitalic
def say():
    return "Hello"

print say()
 

62







Python dekorat├Ârleri ba┼čka bir i┼čleve ekstra i┼člevsellik ekler

Bir italik dekorat├Âr olabilir

 def makeitalic(fn):
    def newFunc():
        return "<i>" + fn() + "</i>"
    return newFunc
 

Bir fonksiyonun i├žinde bir fonksiyon tan─▒mland─▒─č─▒na dikkat edin. Temel olarak yapt─▒─č─▒, yeni tan─▒mlanm─▒┼č olanla bir fonksiyonun yerini almakt─▒r. Mesela bu s─▒n─▒fa sahibim

 class foo:
    def bar(self):
        print "hi"
    def foobar(self):
        print "hi again"
 

┼×imdi, her iki fonksiyonun da i┼člemden ├Ânce ve sonra "---" yazd─▒rmas─▒n─▒ istiyorum. Her bask─▒ ifadesinden ├Ânce ve sonra "---" bir bask─▒ ekleyebilirim. Ama kendimi tekrarlamaktan ho┼članmad─▒─č─▒m i├žin dekorat├Âr yapaca─č─▒m

 def addDashes(fn): # notice it takes a function as an argument
    def newFunction(self): # define a new function
        print "---"
        fn(self) # call the original function
        print "---"
    return newFunction
    # Return the newly defined function - it will "replace" the original
 

┼×imdi s─▒n─▒f─▒m─▒ de─či┼čtirebilirim.

 class foo:
    @addDashes
    def bar(self):
        print "hi"

    @addDashes
    def foobar(self):
        print "hi again"
 

Dekorat├Ârler hakk─▒nda daha fazla bilgi i├žin http://www.ibm.com/developerworks/linux/library/l-cpdecor.html adresini ziyaret edin.


60







─░stedi─činiz ┼čeyi do─črudan a┼ča─č─▒da g├Âsterildi─či gibi yapan iki ayr─▒ dekorat├Âr yapabilirsiniz. Birden fazla arg├╝man i├žeren dekore edilmi┼č i┼člevi destekleyen i┼člev *args, **kwargs bildiriminin kullan─▒m─▒na dikkat edin wrapped() (bu, ├Ârnek say() i┼člev i├žin ger├žekten gerekli de─čildir ancak genelli─če dahil edilmi┼čtir).

Benzer nedenlerden dolay─▒, functools.wraps dekorat├Âr sar─▒lm─▒┼č fonksiyonun meta ├Âzelliklerini, dekore edilmi┼č olan─▒nkiler olarak de─či┼čtirmek i├žin kullan─▒l─▒r. Bu hata mesajlar─▒n─▒ ve g├Âm├╝l├╝ i┼člev belgelendirmesini ( func.__doc__ ) wrapped() 'nin yerine dekore edilmi┼č i┼člevinkileri yapar.

 from functools import wraps

def makebold(fn):
    @wraps(fn)
    def wrapped(*args, **kwargs):
        return "<b>" + fn(*args, **kwargs) + "</b>"
    return wrapped

def makeitalic(fn):
    @wraps(fn)
    def wrapped(*args, **kwargs):
        return "<i>" + fn(*args, **kwargs) + "</i>"
    return wrapped

@makebold
@makeitalic
def say():
    return 'Hello'

print(say())  # -> <b><i>Hello</i></b>
 

Hassasla┼čt─▒rmalar

G├Ârd├╝─č├╝n├╝z gibi bu iki dekorat├Ârde bir├žok kod var. Bu benzerlik g├Âz ├Ân├╝ne al─▒nd─▒─č─▒nda, bunun yerine, asl─▒nda bir dekorat├Âr fabrikas─▒ olan ba┼čka bir deyi┼čle ba┼čka dekorat├Ârler yapan bir dekorat├Âr i┼člevi olan jenerik bir ├╝r├╝n ├╝retmeniz daha iyi olur. Bu ┼čekilde daha az kod tekrar─▒ olur ve DRY ilkesinin izlenmesine izin verilir .

 def html_deco(tag):
    def decorator(fn):
        @wraps(fn)
        def wrapped(*args, **kwargs):
            return '<%s>' % tag + fn(*args, **kwargs) + '</%s>' % tag
        return wrapped
    return decorator

@html_deco('b')
@html_deco('i')
def greet(whom=''):
    return 'Hello' + (' ' + whom) if whom else ''

print(greet('world'))  # -> <b><i>Hello world</i></b>
 

Kodu daha okunakl─▒ hale getirmek i├žin, fabrikada ├╝retilen dekorat├Ârlere daha a├ž─▒klay─▒c─▒ bir ad atayabilirsiniz:

 makebold = html_deco('b')
makeitalic = html_deco('i')

@makebold
@makeitalic
def greet(whom=''):
    return 'Hello' + (' ' + whom) if whom else ''

print(greet('world'))  # -> <b><i>Hello world</i></b>
 

hatta onlar─▒ ┼ču ┼čekilde birle┼čtirin:

 makebolditalic = lambda fn: makebold(makeitalic(fn))

@makebolditalic
def greet(whom=''):
    return 'Hello' + (' ' + whom) if whom else ''

print(greet('world'))  # -> <b><i>Hello world</i></b>
 

verim

Yukar─▒daki ├Ârnekler t├╝m i┼či yaparken, olu┼čturulan kod bir kerede birden fazla dekorat├Âr uyguland─▒─č─▒nda, harici fonksiyon ├ža─čr─▒lar─▒ bi├žiminde adil bir miktar ek y├╝k i├žermektedir. Tam kullan─▒ma ba─čl─▒ olarak (├Ârne─čin I / O'ya ba─čl─▒ olabilir) bu ├Ânemli olmayabilir.

Dekore edilmi┼č fonksiyonun h─▒z─▒ ├Ânemliyse, ek y├╝k, t├╝m etiketleri bir kerede eklemeyi uygulayan biraz farkl─▒ bir dekorat├Âr fabrikas─▒ fonksiyonunu yazarak tek bir ekstra fonksiyon ├ža─čr─▒s─▒na tutulabilir, b├Âylece yap─▒lan ilave fonksiyon ├ža─čr─▒lar─▒ndan ka├ž─▒nan kod ├╝retebilir. Her etiket i├žin ayr─▒ dekorat├Ârler kullanarak.

Bu, dekorat├Âr├╝n kendisinde daha fazla kod gerektirir, ancak bu yaln─▒zca i┼člev tan─▒mlar─▒na uyguland─▒─č─▒nda ├žal─▒┼č─▒r, daha sonra kendileri ├ža─čr─▒ld─▒─č─▒nda de─čil. Bu ayn─▒ zamanda daha lambda ├Ânce g├Âsterildi─či gibi i┼člevleri kullanarak daha okunabilir isimler olu┼čtururken de ge├žerlidir . Numune:

 def multi_html_deco(*tags):
    start_tags, end_tags = [], []
    for tag in tags:
        start_tags.append('<%s>' % tag)
        end_tags.append('</%s>' % tag)
    start_tags = ''.join(start_tags)
    end_tags = ''.join(reversed(end_tags))

    def decorator(fn):
        @wraps(fn)
        def wrapped(*args, **kwargs):
            return start_tags + fn(*args, **kwargs) + end_tags
        return wrapped
    return decorator

makebolditalic = multi_html_deco('b', 'i')

@makebolditalic
def greet(whom=''):
    return 'Hello' + (' ' + whom) if whom else ''

print(greet('world'))  # -> <b><i>Hello world</i></b>
 

33







Ayn─▒ ┼čeyi yapman─▒n ba┼čka bir yolu:

 class bol(object):
  def __init__(self, f):
    self.f = f
  def __call__(self):
    return "<b>{}</b>".format(self.f())

class ita(object):
  def __init__(self, f):
    self.f = f
  def __call__(self):
    return "<i>{}</i>".format(self.f())

@bol
@ita
def sayhi():
  return 'hi'
 

Veya daha esnek bir ┼čekilde:

 class sty(object):
  def __init__(self, tag):
    self.tag = tag
  def __call__(self, f):
    def newf():
      return "<{tag}>{res}</{tag}>".format(res=f(), tag=self.tag)
    return newf

@sty('b')
@sty('i')
def sayhi():
  return 'hi'
 

19


2011-12-26





Python'da a┼ča─č─▒dakileri yapan iki dekorat├Âr├╝ nas─▒l yapabilirim?

├ça─čr─▒ld─▒─č─▒nda a┼ča─č─▒daki i┼člevi istiyorsunuz:

 @makebold
@makeitalic
def say():
    return "Hello"
 

Geri vermek:

 <b><i>Hello</i></b>
 

Basit ├ž├Âz├╝m

Bunu en basit ┼čekilde yapmak i├žin, i┼člevi kapatan lambdalar─▒ (anonim i┼člevler) d├Ând├╝ren dekorat├Ârler yap─▒n ve bunu adland─▒r─▒n:

 def makeitalic(fn):
    return lambda: '<i>' + fn() + '</i>'

def makebold(fn):
    return lambda: '<b>' + fn() + '</b>'
 

┼×imdi bunlar─▒ istedi─činiz gibi kullan─▒n:

 @makebold
@makeitalic
def say():
    return 'Hello'
 

ve ┼čimdi:

 >>> say()
'<b><i>Hello</i></b>'
 

Basit ├ž├Âz├╝mle ilgili sorunlar

Ancak orijinal i┼člevi neredeyse kaybediyor gibiyiz.

 >>> say
<function <lambda> at 0x4ACFA070>
 

Bunu bulmak i├žin, biri di─čerine g├Âm├╝lm├╝┼č olan her lambda kapanmas─▒na dikkat etmemiz gerekir:

 >>> say.__closure__[0].cell_contents
<function <lambda> at 0x4ACFA030>
>>> say.__closure__[0].cell_contents.__closure__[0].cell_contents
<function say at 0x4ACFA730>
 

Dolay─▒s─▒yla, bu fonksiyonun dok├╝mantasyonunu koyarsak veya birden fazla arg├╝man alan fonksiyonlar─▒ dekore edebilmek istiyorsak veya sadece bir hata ay─▒klama oturumunda hangi fonksiyona bakt─▒─č─▒m─▒z─▒ bilmek istiyorsak, sarg─▒.

Tam ├Âzellikli ├ž├Âz├╝m - bu sorunlar─▒n ├žo─čunun ├╝stesinden gelmek

Standart k├╝t├╝phanedeki mod├╝lden wraps gelen dekorat├Âr bizde functools !

 from functools import wraps

def makeitalic(fn):
    # must assign/update attributes from wrapped function to wrapper
    # __module__, __name__, __doc__, and __dict__ by default
    @wraps(fn) # explicitly give function whose attributes it is applying
    def wrapped(*args, **kwargs):
        return '<i>' + fn(*args, **kwargs) + '</i>'
    return wrapped

def makebold(fn):
    @wraps(fn)
    def wrapped(*args, **kwargs):
        return '<b>' + fn(*args, **kwargs) + '</b>'
    return wrapped
 

Hala bir kazan plakas─▒n─▒n olmas─▒ talihsiz bir durum, ancak bu yapabilece─čimiz kadar basit.

Python 3'te ayr─▒ca varsay─▒lan olarak elde edilir __qualname__ ve __annotations__ atan─▒r.

Peki ┼čimdi:

 @makebold
@makeitalic
def say():
    """This function returns a bolded, italicized 'hello'"""
    return 'Hello'
 

Ve ┼čimdi:

 >>> say
<function say at 0x14BB8F70>
>>> help(say)
Help on function say in module __main__:

say(*args, **kwargs)
    This function returns a bolded, italicized 'hello'
 

Sonu├ž

Bu nedenle wraps , sarma i┼člevinin hemen hemen her ┼čeyi yapmas─▒n─▒ sa─člad─▒─č─▒n─▒ g├Âr├╝yoruz, ancak fonksiyonun arg├╝man olarak ne ald─▒─č─▒n─▒ bize anlat─▒yor.

Sorunu ├ž├Âzmeyi deneyebilecek ba┼čka mod├╝ller var, ancak ├ž├Âz├╝m hen├╝z standart k├╝t├╝phanede de─čil.


18







Bir dekorat├Âr fonksiyon tan─▒m─▒n─▒ al─▒r ve bu fonksiyonu yerine getiren ve sonucu d├Ân├╝┼čt├╝ren yeni bir fonksiyon yarat─▒r.

 @deco
def do():
    ...
 

e┼čittir:

 do = deco(do)
 

├ľrnek:

 def deco(func):
    def inner(letter):
        return func(letter).upper()  #upper
    return inner
 

Bu

 @deco
def do(number):
    return chr(number)  # number to letter
 

buna e┼čittir

 def do2(number):
    return chr(number)

do2 = deco(do2)
 

65 <=> 'a'

 print(do(65))
print(do2(65))
>>> B
>>> B
 

Dekorat├Âr├╝n anla┼č─▒lmas─▒ i├žin, dekorat├Âr├╝n fonksiyonu yerine getiren ve sonucu d├Ân├╝┼čt├╝ren i├žte yeni bir fonksiyon yaratt─▒─č─▒n─▒ fark etmek ├Ânemlidir.


12







Dekorat├Âr├╝ daha basit bir ┼čekilde a├ž─▒klamak i├žin:

─░le:

 @decor1
@decor2
def func(*args, **kwargs):
    pass
 

Ne zaman yapal─▒m:

 func(*args, **kwargs)
 

Ger├žekten yap─▒yorsun:

 decor1(decor2(func))(*args, **kwargs)
 

10







 #decorator.py
def makeHtmlTag(tag, *args, **kwds):
    def real_decorator(fn):
        css_class = " class='{0}'".format(kwds["css_class"]) \
                                 if "css_class" in kwds else ""
        def wrapped(*args, **kwds):
            return "<"+tag+css_class+">" + fn(*args, **kwds) + "</"+tag+">"
        return wrapped
    # return decorator dont call it
    return real_decorator

@makeHtmlTag(tag="b", css_class="bold_css")
@makeHtmlTag(tag="i", css_class="italic_css")
def hello():
    return "hello world"

print hello()
 

Ayr─▒ca dekorat├Âr s─▒n─▒fta yazabilirsiniz.

 #class.py
class makeHtmlTagClass(object):
    def __init__(self, tag, css_class=""):
        self._tag = tag
        self._css_class = " class='{0}'".format(css_class) \
                                       if css_class != "" else ""

    def __call__(self, fn):
        def wrapped(*args, **kwargs):
            return "<" + self._tag + self._css_class+">"  \
                       + fn(*args, **kwargs) + "</" + self._tag + ">"
        return wrapped

@makeHtmlTagClass(tag="b", css_class="bold_css")
@makeHtmlTagClass(tag="i", css_class="italic_css")
def hello(name):
    return "Hello, {}".format(name)

print hello("Your name")
 

7







─░┼čte zincirleme dekorat├Ârlerin basit bir ├Ârne─či. Son sat─▒r─▒ not edin - kapaklar─▒n alt─▒nda neler oldu─čunu g├Âsterir.

 ############################################################
#
#    decorators
#
############################################################

def bold(fn):
    def decorate():
        # surround with bold tags before calling original function
        return "<b>" + fn() + "</b>"
    return decorate


def uk(fn):
    def decorate():
        # swap month and day
        fields = fn().split('/')
        date = fields[1] + "/" + fields[0] + "/" + fields[2]
        return date
    return decorate

import datetime
def getDate():
    now = datetime.datetime.now()
    return "%d/%d/%d" % (now.day, now.month, now.year)

@bold
def getBoldDate(): 
    return getDate()

@uk
def getUkDate():
    return getDate()

@bold
@uk
def getBoldUkDate():
    return getDate()


print getDate()
print getBoldDate()
print getUkDate()
print getBoldUkDate()
# what is happening under the covers
print bold(uk(getDate))()
 

├ç─▒kt─▒ ┼č├Âyle g├Âr├╝n├╝r:

 17/6/2013
<b>17/6/2013</b>
6/17/2013
<b>6/17/2013</b>
<b>6/17/2013</b>
 

6







Bu cevap uzun zaman ├Ânce yan─▒tland─▒, ancak yeni dekorat├Ârler yazmay─▒ kolay ve kompakt yapan Dekorat├Âr s─▒n─▒f─▒m─▒ payla┼čaca─č─▒m─▒ d├╝┼č├╝nd├╝m.

 from abc import ABCMeta, abstractclassmethod

class Decorator(metaclass=ABCMeta):
    """ Acts as a base class for all decorators """

    def __init__(self):
        self.method = None

    def __call__(self, method):
        self.method = method
        return self.call

    @abstractclassmethod
    def call(self, *args, **kwargs):
        return self.method(*args, **kwargs)
 

Birincisi, dekorat├Ârlerin davran─▒┼č─▒n─▒ ├žok net bir hale getirdi─čini d├╝┼č├╝n├╝yorum, ancak ayn─▒ zamanda yeni dekorat├Ârleri ├žok ├Âzl├╝ bir ┼čekilde tan─▒mlamay─▒ da kolayla┼čt─▒r─▒yor. Yukar─▒da listelenen ├Ârnek i├žin, daha sonra ┼ču ┼čekilde ├ž├Âzebilirsiniz:

 class MakeBold(Decorator):
    def call():
        return "<b>" + self.method() + "</b>"

class MakeItalic(Decorator):
    def call():
        return "<i>" + self.method() + "</i>"

@MakeBold()
@MakeItalic()
def say():
   return "Hello"
 

Ayr─▒ca daha karma┼č─▒k g├Ârevleri yapmak i├žin de kullanabilirsiniz, ├Ârne─čin, i┼člevi bir yineleyici i├žinde t├╝m arg├╝manlara otomatik olarak yinelemeli olarak uygulayan bir dekorat├Âr gibi:

 class ApplyRecursive(Decorator):
    def __init__(self, *types):
        super().__init__()
        if not len(types):
            types = (dict, list, tuple, set)
        self._types = types

    def call(self, arg):
        if dict in self._types and isinstance(arg, dict):
            return {key: self.call(value) for key, value in arg.items()}

        if set in self._types and isinstance(arg, set):
            return set(self.call(value) for value in arg)

        if tuple in self._types and isinstance(arg, tuple):
            return tuple(self.call(value) for value in arg)

        if list in self._types and isinstance(arg, list):
            return list(self.call(value) for value in arg)

        return self.method(arg)


@ApplyRecursive(tuple, set, dict)
def double(arg):
    return 2*arg

print(double(1))
print(double({'a': 1, 'b': 2}))
print(double({1, 2, 3}))
print(double((1, 2, 3, 4)))
print(double([1, 2, 3, 4, 5]))
 

Hangi yazd─▒r─▒r:

 2
{'a': 2, 'b': 4}
{2, 4, 6}
(2, 4, 6, 8)
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
 

Bu ├Ârne─čin list , dekorat├Âr├╝n ba┼člat─▒lmas─▒nda t├╝r├╝ i├žermedi─čine dikkat edin, bu nedenle son bask─▒ ifadesinde y├Ântem listenin ├Â─čelerini de─čil listenin kendisine uygulan─▒r.


6







Say─▒c─▒ ├Ârne─činden bahsetmi┼čken - yukar─▒da belirtildi─či gibi, saya├ž, dekorat├Âr├╝ kullanan t├╝m i┼člevler aras─▒nda payla┼č─▒lacakt─▒r:

 def counter(func):
    def wrapped(*args, **kws):
        print 'Called #%i' % wrapped.count
        wrapped.count += 1
        return func(*args, **kws)
    wrapped.count = 0
    return wrapped
 

Bu ┼čekilde, dekorat├Âr├╝n├╝z farkl─▒ i┼člevler i├žin yeniden kullan─▒labilir (veya ayn─▒ i┼člevi bir├žok kez dekore etmek i├žin kullan─▒labilir:) func_counter1 = counter(func); func_counter2 = counter(func) ve saya├ž de─či┼čkeni her biri i├žin ├Âzel kal─▒r.


4







─░┼člevleri farkl─▒ arg├╝manlarla dekore etme:

 def frame_tests(fn):
    def wrapper(*args):
        print "\nStart: %s" %(fn.__name__)
        fn(*args)
        print "End: %s\n" %(fn.__name__)
    return wrapper

@frame_tests
def test_fn1():
    print "This is only a test!"

@frame_tests
def test_fn2(s1):
    print "This is only a test! %s" %(s1)

@frame_tests
def test_fn3(s1, s2):
    print "This is only a test! %s %s" %(s1, s2)

if __name__ == "__main__":
    test_fn1()
    test_fn2('OK!')
    test_fn3('OK!', 'Just a test!')
 

Sonu├ž:

 Start: test_fn1  
This is only a test!  
End: test_fn1  


Start: test_fn2  
This is only a test! OK!  
End: test_fn2  


Start: test_fn3  
This is only a test! OK! Just a test!  
End: test_fn3  
 

4







Paolo BergantinÔÇÖin cevab─▒ sadece stdlib kullanman─▒n b├╝y├╝k avantaj─▒na sahiptir ve dekorat├Âr arg├╝manlar─▒n─▒n ve dekore edilmi┼č fonksiyon arg├╝manlar─▒n─▒n olmad─▒─č─▒ bu basit ├Ârnek i├žin i┼če yarar .

Bununla birlikte, daha genel vakalarla m├╝cadele etmek istiyorsan─▒z, 3 ana s─▒n─▒rlamas─▒ vard─▒r:

  • Birka├ž cevapta daha ├Ânce belirtildi─či gibi, iste─če ba─čl─▒ dekorat├Âr arg├╝manlar─▒ eklemek i├žin kodu kolayca de─či┼čtiremezsiniz . ├ľrne─čin makestyle(style='bold') , bir dekorat├Âr olu┼čturmak ├Ânemsiz de─čildir.
  • Bunun yan─▒nda, yarat─▒lm─▒┼č olan paketler @functools.wraps imzay─▒ korumaz , bu nedenle hatal─▒ arg├╝manlar verilirse uygulamaya ba┼člar ve normalden farkl─▒ bir t├╝r hataya yol a├žabilir TypeError .
  • Nihayet, bu olu┼čturulan sarma olduk├ža zordur @functools.wraps etmek ad─▒na ba─čl─▒ bir arg├╝man─▒ eri┼čmek . Asl─▒nda arg├╝man i├žinde *args , i├žinde **kwargs veya hi├ž g├Âr├╝nmeyebilir (iste─če ba─čl─▒ysa).

Yazd─▒─č─▒m decopatch ilk sorunu ├ž├Âzmek i├žin, ve yazd─▒─č─▒ makefun.wraps di─čer ikisini ├ž├Âzmek i├žin. Unutmay─▒n makefun , ayn─▒ numaray─▒ ├╝nl├╝ decorator lib ile ayn─▒ ┼čekilde kullan─▒yor .

Bu, ger├žekten imza koruyan sarmalay─▒c─▒lar─▒ iade eden, arg├╝manlara sahip bir dekorat├Âr yaratma ┼čeklinizdir:

 from decopatch import function_decorator, DECORATED
from makefun import wraps

@function_decorator
def makestyle(st='b', fn=DECORATED):
    open_tag = "<%s>" % st
    close_tag = "</%s>" % st

    @wraps(fn)
    def wrapped(*args, **kwargs):
        return open_tag + fn(*args, **kwargs) + close_tag

    return wrapped
 

decopatch tercihlerinize ba─čl─▒ olarak, ├že┼čitli python kavramlar─▒n─▒ gizleyen veya g├Âsteren iki geli┼čtirme stili daha sunar. En kompakt stil a┼ča─č─▒daki gibidir:

 from decopatch import function_decorator, WRAPPED, F_ARGS, F_KWARGS

@function_decorator
def makestyle(st='b', fn=WRAPPED, f_args=F_ARGS, f_kwargs=F_KWARGS):
    open_tag = "<%s>" % st
    close_tag = "</%s>" % st
    return open_tag + fn(*f_args, **f_kwargs) + close_tag
 

Her iki durumda da, dekorat├Âr├╝n beklendi─či gibi ├žal─▒┼čt─▒─č─▒n─▒ kontrol edebilirsiniz:

 @makestyle
@makestyle('i')
def hello(who):
    return "hello %s" % who

assert hello('world') == '<b><i>hello world</i></b>'    
 

L├╝tfen ayr─▒nt─▒lar i├žin belgelere bak─▒n.


4



─░lgili yay─▒nlar


Node.js kullan─▒larak bir geri ├ža─čr─▒ ├ža─čr─▒l─▒ncaya kadar bir i┼člevi nas─▒l beklersiniz?

Backtrace () / backtrace_symbols () i┼člev isimlerini nas─▒l yazd─▒r─▒r?

Kullan─▒c─▒ tan─▒ml─▒ fonksiyon tan─▒mlar─▒n─▒n (ÔÇťdok├╝manlarÔÇŁ) julia REPL i├žin nas─▒l kullan─▒labilir hale getirilir?

├çal─▒┼čma zaman─▒nda android Bold metninin bir par├žas─▒ nas─▒l yap─▒l─▒r?

Clojure fonksiyonunun de─či┼čken say─▒da parametre almas─▒ nas─▒l sa─član─▒r?

De─či┼čken bir ┼čablon fonksiyonunun heterojen arg├╝man paketleri ├╝zerinde jenerik hesaplamalar nas─▒l yap─▒l─▒r?

C# sat─▒r i├ži i┼člevler nas─▒l yap─▒l─▒r

├ľny├╝kleme 3: Nas─▒l a├ž─▒l─▒r men├╝ ba─člant─▒s─▒n─▒n gezinti ├žubu─čunda t─▒klat─▒labilir hale getirilir

Genel T├╝r D├Âkme i┼člevi nas─▒l yap─▒l─▒r [├žo─čalt─▒l─▒r]

Bir i┼člevin bir i┼čleve i┼čaret├ži d├Ând├╝rmesi nas─▒l yap─▒l─▒r? (C ++)

Etiketle ilgili di─čer sorular [python]


JavaScript kar┼č─▒la┼čt─▒rmalar─▒nda hangi e┼čittir operat├Âr├╝ (== vs ===) kullan─▒lmal─▒d─▒r?

Bir JavaScript nesnesi dizisini ├Âzelli─če g├Âre s─▒ralama

JQuery'yi JavaScript Konsoluna dahil et

Bir .NET 4.0 projesinde bir .NET 2.0 karma mod derlemesine ba┼čvurmak i├žin hangi 'ek yap─▒land─▒rma' gereklidir?

Treesset vs Hashset

Programlama ba─člam─▒nda ÔÇťk├Âm├╝rbilimÔÇŁ ne demektir?

Javascript .map dosyalar─▒ - javascript kaynak haritalar─▒

NodeJS / Express: ÔÇťapp.useÔÇŁ nedir?

PhoneGap ve Cordova komutlar─▒ aras─▒nda bir fark var m─▒?

Normal arg├╝manlar vs. anahtar kelime arg├╝manlar─▒