Closure & Decorator#

LEGB rules#

• Local, Enclosing, Gloable, Built-in

Local function#

• Useful for specialized, one-off functions
• Aid in code organization and readability
• Similar to lambdas, but more general
• May contain multiple expressions
• May contain statements

Closure#

• Closure maintain references to objects from earlier scopes

• LEGB does not apply when making new bindings

• Usage of nonlocal

  • Example

    def make_timer():
        last_called = None
    
        def elapsed():
            nonlocal last_called
            now = time.time()
            if last_called is None:
                last_called = now
                return None
            result = now - last_called
            last_called = now
            return result
        return elapsed
    
    
    if __name__ == "__main__":
        mt = make_timer()
        print(mt ())
        print('-----------------------------')
        print(mt ())
        print('-----------------------------')
        print(mt ())

• Use as function factory

  • Example

    
    def raise_to(exp):
        def raise_to_exp(x):
            return pow(x, exp)
        return raise_to_exp
    
    if __name__ == "__main__":
        square=raise_to(2)
        cube= raise_to(3)
        print(square(2))
        print(cube(2))
    
    ## test result:
    ## 4
    ## 8

Decorator#

• Replace, enhance, or modify existing functions

• Does not change the original function definition

• Calling code does not need to change

• Decorator mechanism uses the modified function’s original name

• Example

  • use function as decorator

    def escape_unicode(f):
        def wrap(*args, **kwargs):
            x = f(*args, **kwargs)
            return ascii(x)
        return wrap
    
    
    @escape_unicode
    def hello_greek():
        return 'γειά σου κόσμος'    
    
    if __name__ == "__main__":
        print(hello_greek())
    
    ## test result:
    ## '\u03b3\u03b5\u03b9\u03ac \u03c3\u03bf\u03c5 \u03ba\u03cc\u03c3\u03bc\u03bf\u03c2'

  • Example: multiple decorators including function and instance

    class Trace:
        def __init__(self):
            self.enabled = True
    
        def __call__(self, f):
            @functools.wraps(f)
            def wrap(*args, **kwargs):
                if self.enabled:
                    print('Calling {}'.format(f.__name__))
                return f(*args, **kwargs)
            return wrap
    
    def escape_unicode(f):
        @functools.wraps(f)
        def wrap(*args, **kwargs):
            x = f(*args, **kwargs)
            return ascii(x)
        return wrap
    
    @tracer
    @escape_unicode
    def hello_greek():
        return 'γειά σου κόσμος'    
    
    ## test result
    ## Calling hello_greek
    ## '\u03b3\u03b5\u03b9\u03ac \u03c3\u03bf\u03c5 \u03ba\u03cc\u03c3\u03bc\u03bf\u03c2'

  • Use as validator

    def check_non_negative(index):
        def validator(f):
            def wrap(*args):
                if args[index] < 0:
                    raise ValueError(
                        'Arg {} must be non-negative'.format(index)
                    )
                return f(*args)
            return wrap
        return validator
    
    @check_non_negative(1)
    def create_seq(value, size):
        return [value]*size  
    
    if __name__ == "__main__":
        create_seq('0', -3)
    
    ## test result
    ....
    'Arg {} must be non-negative'.format(index)
    ValueError: Arg 1 must be non-negative

  Properties & Class#

  @staticmethod#

  • No access needed to either class or instance objects.
  • Most likely an implementation detail of the class.
  • May be able to be moved to become a module-scope function

  @classmethod#

  • Requires access to the class object to call other class methods or the constructor
  • Always use self for the first argument to instance methods.
  • Always use cls for the first argument to class methods.
  • Use case: use as named constructors

  class FileStream(object):
  
      @classmethod
      def from_file(cls, filepath, ignore_comments=False, *args, **kwargs):   
          with open(filepath, 'r') as fileobj:
              for obj in cls(fileobj, ignore_comments, *args, **kwargs):
                  yield obj
  
      @classmethod
      def from_socket(cls, socket, ignore_comments=False, *args, **kwargs):
          raise NotImplemented ## Placeholder until implemented
  
      def __init__(self, iterable, ignore_comments=False, *args, **kwargs):
          ...

@property#

• Encapsulation

  • Example

    class A
        @property
        def  prop(self):
            return self._prop
    
        @prop.setter
        def prop(self, value):
            self._prop = value