将其他项目的值替换为子字符串

Question

In a dictionary

{'A':'x', 'B':'y', 'C':'{A}_foo', 'D':'bar_{B}'}

, how would you perform a substitution producing

{'A':'x', 'B':'y', 'C':'x_foo', 'D':'bar_y'}

? No nesting like 'C':'{A}_foo', 'D':'oops_{C}' , no recursion.

(This is a reduced example. In reality, it needs to happen row by row in a pandas dataframe)

Answer 1

Just use Python string formatting and expand the d1 dict as the arguments:

d1={'A':'x', 'B':'y', 'C':'{A}_foo', 'D':'bar_{B}'}
d2={k:v.format(v,**d1) for k,v in d1.items()}

>>> d2
{'A': 'x', 'B': 'y', 'C': 'x_foo', 'D': 'bar_y'}

However, there is a potential of key errors here. Consider:

>>> d1={'A':'x', 'B':'y', 'C':'{A}_foo', 'D':'bar_{B}', 'E':'no-key_{Z}'}
>>> d2={k:v.format(v,**d1) for k,v in d1.items()}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in <dictcomp>
KeyError: 'Z'

If you want to gracefully handle key errors, you can subclass Formatter like so:

import string
class PartialFormatter(string.Formatter):
    def __init__(self, missing='~~', bad_fmt='!!'):
        self.missing, self.bad_fmt=missing, bad_fmt

    def get_field(self, field_name, args, kwargs):
        # Handle a key not found
        try:
            val=super(PartialFormatter, self).get_field(field_name, args, kwargs)
            # Python 3, 'super().get_field(field_name, args, kwargs)' works
        except (KeyError, AttributeError):
            val=None,field_name 
        return val 

    def format_field(self, value, spec):
        # handle an invalid format
        if value==None: return self.missing
        try:
            return super(PartialFormatter, self).format_field(value, spec)
        except ValueError:
            if self.bad_fmt is not None: return self.bad_fmt   
            else: raise

d1={'A':'x', 'B':'y', 'C':'{A}_foo', 'D':'bar_{B}', 'E':'no-key_{Z}'}
d2={}

fmt=PartialFormatter()
for k,v in d1.items():
    if '{' in v:
        d2[k]=fmt.format(v,**d1)
    else:
        d2[k]=v   

Then you just silently get ~~ instead of a KeyError :

>>> d2
{'A': 'x', 'B': 'y', 'C': 'x_foo', 'D': 'bar_y', 'E': 'no-key_~~'}

Which can be modified to the behavior you desire...

---

Or, perhaps better still, use try / except :

d1={'A':'x', 'B':'y', 'C':'{A}_foo', 'D':'bar_{B}', 'E':'bad-fmt_{:B}', 'F':'no-key_{Z}'}
d2={}

for k,v in d1.items():
    if '{' in v:
        try:
            d2[k]=v.format(v,**d1)
        except (KeyError, ValueError):
            d2[k]=v 
    else:
        d2[k]=v    

>>> d2
{'A': 'x', 'B': 'y', 'C': 'x_foo', 'D': 'bar_y', 'E': 'bad-fmt_{:B}', 'F': 'no-key_{Z}'}

Answer 2

With a list comprehension on d.items , we can apply val.format(**d) on each value to interpolate the values with the dict itself:

 >>> d = {'A':'x', 'B':'y', 'C':'{A}_foo', 'D':'bar_{B}'} >>> o = dict([ (key, val.format(**d)) for key,val in d.items() ]) >>> print (o) {'A': 'x', 'B': 'y', 'C': 'x_foo', 'D': 'bar_y'}