'Nested contexts trees for implementing nested scopes (static or dynamic)'fromcollectionsimportMutableMappingfromitertoolsimportchain,imapclassContext(MutableMapping):''' Nested contexts -- a chain of mapping objects.    c = Context()           Create root context    d = c.new_child()       Create nested child context. Inherit enable_nonlocal    e = c.new_child()       Child of c, independent from d    e.root                  Root context -- like Python's globals()    e.map                   Current context dictionary -- like Python's locals()    e.parent                Enclosing context chain -- like Python's nonlocals    d['x']                  Get first key in the chain of contexts    d['x'] = 1              Set value in current context    del['x']                Delete from current context    list(d)                 All nested values    k in d                  Check all nested values    len(d)                  Number of nested values    d.items()               All nested items    Mutations (such as sets and deletes) are restricted to the current context    when "enable_nonlocal" is set to False (the default).  So c[k]=v will always    write to self.map, the current context.    But with "enable_nonlocal" set to True, variable in the enclosing contexts    can be mutated.  For example, to implement writeable scopes for nonlocals:        nonlocals = c.parent.new_child(enable_nonlocal=True)        nonlocals['y'] = 10     # overwrite existing entry in a nested scope    To emulate Python's globals(), read and write from the the root context:        globals = c.root        # look-up the outermost enclosing context        globals['x'] = 10       # assign directly to that context    To implement dynamic scoping (where functions can read their caller's    namespace), pass child contexts as an argument in a function call:        def f(ctx):            ctx.update(x=3, y=5)            g(ctx.new_child())        def g(ctx):            ctx['z'] = 8                    # write to local context            print ctx['x'] * 10 + ctx['y']  # read from the caller's context    '''def__init__(self,enable_nonlocal=False,parent=None):'Create a new root context'self.parent=parentself.enable_nonlocal=enable_nonlocalself.map={}self.maps=[self.map]ifparentisnotNone:self.maps+=parent.mapsdefnew_child(self,enable_nonlocal=None):'Make a child context, inheriting enable_nonlocal unless specified'enable_nonlocal=self.enable_nonlocalifenable_nonlocalisNoneelseenable_nonlocalreturnself.__class__(enable_nonlocal=enable_nonlocal,parent=self)@propertydefroot(self):'Return root context (highest level ancestor)'returnselfifself.parentisNoneelseself.parent.rootdef__getitem__(self,key):forminself.maps:ifkeyinm:breakreturnm[key]def__setitem__(self,key,value):ifself.enable_nonlocal:forminself.maps:ifkeyinm:m[key]=valuereturnself.map[key]=valuedef__delitem__(self,key):ifself.enable_nonlocal:forminself.maps:ifkeyinm:delm[key]returndelself.map[key]def__len__(self,len=len,sum=sum,imap=imap):returnsum(imap(len,self.maps))def__iter__(self,chain_from_iterable=chain.from_iterable):returnchain_from_iterable(self.maps)def__contains__(self,key,any=any):returnany(keyinmforminself.maps)def__repr__(self,repr=repr):return' -> '.join(imap(repr,self.maps))if__name__=='__main__':c=Context()c['a']=1c['b']=2d=c.new_child()d['c']=3print'd:  ',dassertrepr(d)=="{'c': 3} -> {'a': 1, 'b': 2}"e=d.new_child()e['d']=4e['b']=5print'e:  ',eassertrepr(e)=="{'b': 5, 'd': 4} -> {'c': 3} -> {'a': 1, 'b': 2}"f=d.new_child(enable_nonlocal=True)f['d']=4f['b']=5print'f:  ',fassertrepr(f)=="{'d': 4} -> {'c': 3} -> {'a': 1, 'b': 5}"printlen(f)assertlen(f)==4assertlen(list(f))==4assertall(kinfforkinf)assertf.root==c# dynanmic scoping exampledeff(ctx):printctx['a'],'f:  reading "a" from the global context'print'f: setting "a" in the global context'ctx['a']*=999print'f: reading "b" from globals and setting "c" in locals'ctx['c']=ctx['b']*50print'f: ',ctxg(ctx.new_child())print'f: ',ctxdefg(ctx):print'g: setting "d" in the local context'ctx['d']=44print'''g: setting "c" in f's context'''ctx['c']=-1print'g: ',ctxglobal_context=Context(enable_nonlocal=True)global_context.update(a=10,b=20)f(global_context.new_child())