Can we design any function using a decorator?

Question

During my interview they asked me a implement a function to reverse each word in a sentence and create final sentence from it. For example:

s = 'my life is beautiful'
output - `ym efil si lufituaeb`

I know the question is pretty simple so solved it in few minutes:

s = 'my life is beautiful'

def reverse_sentence(s):

    string_reverse = []

    for i in s.split():
        string_reverse.append("".join(list((reversed(i)))))

    print " ".join(string_reverse)

reverse_sentence(s)

Then they asked to implement the same function using a decorator, and I got confused here. I know the basics of decorator how it used, and when it used. They didn't mention what part of the function they want to wrap using decorator. They told me to implement this using args and kwargs, and I was not able to solve it. Could anyone help me here? How can I convert any function into decorator?

As my per knowledge, you use decorator when you want to wrap your function or you want to modify the some functionality. Is my understanding correct?

Possible duplicate of [Python - Decorators](http://stackoverflow.com/questions/20945366/python-decorators) — Colin Schoen, Nov 13 '15 at 00:24
I'm not sure I understand the task to be performed. How would a decorator even help? — 200_success, Nov 13 '15 at 00:25
Are you sure they didn't say "generator"? There doesn't seem to be any way in which decorators are a natural tool to use here. — user2357112, Nov 13 '15 at 00:26
By the way, `s[::-1]` would be a simpler way to reverse the string. — 200_success, Nov 13 '15 at 00:26
Here we have to implement the same`functionality (reversing a word)` using `decorator` — python, Nov 13 '15 at 00:26
Hey its not a duplicate question. My question is `whether can we convert any function into a decorator` The question interviewer asked seems weird. — python, Nov 13 '15 at 00:28

Joran Beasley · Accepted Answer · 2015-11-13T00:35:53.797

2

def reverse_sentence(fn): # a decorator accepts a function as its argument
    def __inner(s,*args,**kwargs): #it will return this modified function
       string_reverse = []
       for i in s.split():
           string_reverse.append("".join(list((reversed(i)))))          
       return fn(" ".join(string_reverse),*args,**kwargs) 
    return __inner # return the modified function which does your string reverse on its first argument

I guess...

@reverse_sentence
def printer(s):
    print(s)

printer("hello world")

edited Nov 13 '15 at 00:35

answered Nov 13 '15 at 00:31

Joran Beasley

110,522
12
160
179

1

Why did you use @decorator here? – python Nov 13 '15 at 00:32
Your answer seems to be correct, could you elaborate it little more :) – python Nov 13 '15 at 00:34
Accepting your answer, it seems to be the way they are looking for. Thank you sir – python Nov 13 '15 at 00:37

score 1 · Answer 2 · answered Nov 13 '15 at 00:55

1

Here is a different take -- it defines a decorator which takes a function which sends strings to strings and returns another function which maps the passed function over a split string and then rejoins:

def string_map(f): #accepts a function on strings, splits the string, maps the function, then rejoins
    def __f(s,*args,**kwargs):    
       return " ".join(f(t,*args,**kwargs) for t in s.split()) 
    return __f

@string_map
def reverse_string(s):
    return s[::-1]

typical output:

>>> reverse_string("Hello World")
'olleH dlroW'

answered Nov 13 '15 at 00:55

John Coleman

51,337
7
54
119

Nice, how did you guys master `decorator`? It seems so much work – python Nov 13 '15 at 01:02
1

I definitely haven't mastered decorators -- but what I do know I have learned from the excellent book "Guide to: Learning Python Decorators" by Matt Harrision. Also -- if you do some reading in functional programming then you realize that decorators are just Python-style higher-order functions. – John Coleman Nov 13 '15 at 01:29

score 1 · Answer 3 · answered Nov 13 '15 at 01:31

How about this:

# decorator method
def my_decorator(old_func):
    def new_func(*args):
        newargs = (' '.join(''.join(list(args[0])[::-1]).split()[::-1]),)
        old_func(*newargs)  # call the 'real' function

    return new_func  # return the new function object


@my_decorator
def str_rev(mystr):
    print mystr

str_rev('my life is beautiful')
# ym efil si lufituaeb

Can we design any function using a decorator?

3 Answers3