str.format（）与懒惰的字典？

Question

I want to use str.format() and pass it a custom lazy dictionary.

str.format() should only access the key in the lazy dict it needs.

Is this possible?

Which interface needs to be implemented by the lazy_dict?

Update

This is not what I want:

'{0[a]}'.format(d)

I need something like this:

'{a}'.format(**d)

Need to run on Python2.7

Answer 1

For doing '{a}'.format(**d) , especially the **d part, the "lazy" dict is transformed into a regular one. Here happens the access to all keys, and format() can't do anything about it.

You could craft some proxy objects which are put in place of the elements, and on string access they do the "real" work.

Something like

class LazyProxy(object):
    def __init__(self, prx):
        self.prx = prx
    def __format__(self, fmtspec):
        return format(self.prx(), fmtspec)
    def __repr__(self):
        return repr(self.prx())
    def __str__(self):
        return str(self.prx())

You can put these elements into a dict, such as

interd = { k, LazyProxy(lambda: lazydict[k]) for i in lazydict.iterkeys()}

I didn't test this, but I think this fulfills your needs.

After the last edit, it now works with !r and !s as well.

Answer 2

You can use the __format__ method (Python 3 only). See the doc here .

Answer 3

If I understand your question correctly, you want to pass a custom dictionary, that would compute values only when needed. First, we're looking for implementation of __getitem__() :

>>> class LazyDict(object):
...    def __init__(self, d):
...        self.d = d
...    def __getitem__(self, k):
...        print k             # <-- tracks the needed keys
...        return self.d[k]
...
>>> d = D({'a': 19, 'b': 20})
>>> '{0[a]}'.format(d)
a
'19'

This shows that only key 'a' is accessed; 'b' is not, so you already have your lazy access.

But also, any object attribute is usable for str.format this way, and using @property decorator, you can access function results:

class MyObject(object):
    def __init__(self):
        self.a = 19
        self.b = 20
    def __getitem__(self, var): 
        return getattr(self, var)
        # this command lets you able to call any attribute of your instance,
        # or even the result of a function if it is decorated by @property:
    @property
    def c(self):
        return 21

Example of usage:

>>> m = MyObject()
>>> '{0[c]}'.format(m)
'21'

But note that this also works, making the formating string a little bit specific, but avoid the need for __getitem__() implementation.

>>> '{0.c}'.format(m)
'21'