06. Декоратори

31 март 2014

Предговор

Какво различава функцията от всеки друг обект?
__call__
Какви типове обекти може да връща една функция?
Всякакви.

Области на видимост

global_one = 1


def foo():
    local_one = 2
    print(locals())


print(globals())    # {..., 'global_one': 1}
foo()               # {'local_one': 2}

Области на видимост(2)

Всяка функция си има своя област на видимост, в която стоят локално дефинираните параметри
Ако една функция не може да намери дадена променлива в локалния си скоуп, търси в глобалния за променлива със същото име

global_one = 1


def foo():
    print(global_one)

foo()

Области на видимост(3)

А какво ще изведе следния код?

global_one = 1


def foo():
    global_one = 2
    print(global_one)
    print(locals())


foo()

Животът на една променлива

Една променлива "умира", заедно със своя скоуп

Аргументи

Можем да ги подаваме като позиционни или като именовани
След именован аргумент не можем да подадем позиционен
Подадените аргументи отиват в locals
Очевидно умират с приключването на функцията си

Вложени функции

Вече знаете, че можете да дефинирате функция във функцията
Друга тема е кога това е добра идея
Какво се случва тогава с променливите на двете функции и къде отиват?

def outer(x):
    print(x)
    def inner():
        x = 0
        print(x)
    inner()
    print(x)

Функциите са първокласни обекти

Те са като всички останали обекти
Наследяват от object
Можем да ги подаваме като аргументи
Можем да ги връщаме като резултат
Можем да ги записваме в колекции
Можем да ги присвояваме на променлива
Имат идентитет

Closures

def start(x):
    def increment(y):
        return x + y
    return increment

first_inc = start(0)
second_inc = start(8)

first_inc(3)
second_inc(3)

first_inc(1)
second_inc(2)

Фибоначи.

def fibonacci(x):
    if x in [0,1]:
        return 1
    return fibonacci(x-1) + fibonacci(x-2)

Рекурсивната версия на fibonacci, освен че е бавна, е много бавна. особено когато x >= 40.

Проблемът е, че fibonacci се извиква стотици пъти с един и същ аргумент. Можем спокойно да прегенерираме първите стотина резултати в един речник или...

Да изчисляваме всеки резултата само по веднъж...

if x not in memory:
    memory[x] = fibonacci(x)
print(memory[x])

Разбира се тази идея може да се използва и на много повече места! Можем да я направим още по-елегантно.

Функции които опаковат други функции

f(функция) -> функция
резултатът е нова ф-я, която "опакова" старата и може да разшири нейната функционалност

memoize

def memoize(func):
    memory = {}
    def memoized(*args):
        if args in memory:
            return memory[args]
        result = func(*args)
        memory[args] = result
        return result
    return memoized

fibonacci = memoize(fibonacci)

Красивият синтаксис

def fibonacci(x):
    if x in [0,1]:
        return 1
    return fibonacci(x-1) + fibonacci(x-2)

fibonacci = memoize(fibonacci)

Декорацията става след дефиницията на функцията, което е малко объркващо.

@memoize
def fibonacci(x):
    if x in [0,1]:
        return 1
    return fibonacci(x-1) + fibonacci(x-2)

Клинт Ийстууд

@memoize
def fibonacci(x):
    if x in [0,1]:
        return 1
    return fibonacci(x-1) + fibonacci(x-2)

Друг пример за декоратор

def notifyme(f):
    def logged(*args, **kwargs):
        print(f.__name__, ' called with', args, 'and', kwargs)
        return f(*args, **kwargs)
    return logged

@notifyme
def square(x):
    return x * x

res = square(25) # 625
#square was called with (25,) and {}.

Няколко декоратора на една функция

class Mityo:
    @staticmethod
    @notifyme
    def work(): pass

Mityo.work()
work was called with () and {}

Първо се извикват най-вътрешните декоратори.

Прави същото като:

def work(): pass
work = notifyme(work)
work = staticmethod(work)

work = staticmethod(notifyme(work))

Какво правим, ако искаме да му подаваме аргументи?

На лов за патици

Всъщност, защо да не си направим следния декоратор:

@accepts(int, int)
def add(a, b):
    return a+b

Превод на недекораторски:

add = accepts(int, int)(add)

код > думи

def accepts(*types):
    def accepter(f):
        def decorated(*args):
            for (i, (arg, t)) in enumerate(zip(args, types)):
                if not isinstance(arg, t):
                    raise TypeError(
                        """Argument #{0} of '{1}' is not {2}""".format(
                            i,
                            f.__name__,
                            t.__name__))
            #TODO: more complex checks
            return f(*args)
        return decorated
    return accepter

За патиците с любов

duck typing е много важна част от философията на Python. @accepts е забавен пример и дори има някои употреби, но избягвайте да го ползвате масово. В повечето случаи губите, а не печелите.

Полезни декоратори

classmethod — прави метода класов (приема клас, а не обект като първи аргумент)
staticmethod — прави метода статичен
property

@property

class Battery(object):
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

Това превръща voltage в getter към атрибут само за четене със същото име

@property си има и setter

@voltage.setter
def voltage(self, value):
    self._voltage = value

Вече сме ги виждали

@staticmethod
def register(name)
    Person.people.append(name)
    print(len(Person.people), "people are registered now")
[...]
@classmethod
def greet(cls, someone)
    print(someone, "was greeted from", cls)