blocks|key|2728220|text|如果您使用的是Python+3.2%2B，则可以使用str.format_map()。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2728221|对于bond,++bond|style|CODE|2728222|>>>+from+collections+import+defaultdict
>>>+'{bond},+{james}+{bond}'.format_map(defaultdict(str,+bond='bond'))
'bond,++bond'|code-block|syntax|javascript|2728223|对于bond,+{james}+bond|2728224|>>>+class+SafeDict(dict):
...+++++def+__missing__(self,+key):
...+++++++++return+'{'+%2B+key+%2B+'}'
...
>>>+'{bond},+{james}+{bond}'.format_map(SafeDict(bond='bond'))
'bond,+{james}+bond'|2728225|在Python+2.6/2.7中|2728226|对于bond,++bond|2728227|>>>+from+collections+import+defaultdict
>>>+import+string
>>>+string.Formatter().vformat('{bond},+{james}+{bond}',+(),+defaultdict(str,+bond='bond'))
'bond,++bond'|2728228|对于bond,+{james}+bond|2728229|>>>+from+collections+import+defaultdict
>>>+import+string
>>>
>>>+class+SafeDict(dict):
...+++++def+__missing__(self,+key):
...+++++++++return+'{'+%2B+key+%2B+'}'
...
>>>+string.Formatter().vformat('{bond},+{james}+{bond}',+(),+SafeDict(bond='bond'))
'bond,+{james}+bond'|2728230|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/3/library/stdtypes.html#str.format_map^0|O|G|0|0|2|B|0|0|2|I|0|0|0|2|B|0|0|2|I|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@$A|19|B|1A|1|1B]]|C|$]]|$1|D|3|E|5|6|7|1C|8|@$A|1D|B|1E|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|1F|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1G|8|@$A|1H|B|1I|F|G]]|9|@]|C|$]]|$1|O|3|P|5|J|7|1J|8|@]|9|@]|C|$K|L]]|$1|Q|3|R|5|6|7|1K|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|1L|8|@$A|1M|B|1N|F|G]]|9|@]|C|$]]|$1|U|3|V|5|J|7|1O|8|@]|9|@]|C|$K|L]]|$1|W|3|X|5|6|7|1P|8|@$A|1Q|B|1R|F|G]]|9|@]|C|$]]|$1|Y|3|Z|5|J|7|1S|8|@]|9|@]|C|$K|L]]|$1|10|3|-4|5|6|7|1T|8|@]|9|@]|C|$]]]|11|$12|$5|13|14|15|C|$16|17]]]]

<h2>If you are using Python 3.2+, use can use <a href="http://docs.python.org/3/library/stdtypes.html#str.format_map">str.format_map()</a>.</h2>

For <code>bond, bond</code>:

<pre><code>&gt;&gt;&gt; from collections import defaultdict
&gt;&gt;&gt; '{bond}, {james} {bond}'.format_map(defaultdict(str, bond='bond'))
'bond, bond'
</code></pre>

For <code>bond, {james} bond</code>:

<pre><code>&gt;&gt;&gt; class SafeDict(dict):
... def __missing__(self, key):
... return '{' + key + '}'
...
&gt;&gt;&gt; '{bond}, {james} {bond}'.format_map(SafeDict(bond='bond'))
'bond, {james} bond'
</code></pre>

<h2>In Python 2.6/2.7</h2>

For <code>bond, bond</code>:

<pre><code>&gt;&gt;&gt; from collections import defaultdict
&gt;&gt;&gt; import string
&gt;&gt;&gt; string.Formatter().vformat('{bond}, {james} {bond}', (), defaultdict(str, bond='bond'))
'bond, bond'
</code></pre>

For <code>bond, {james} bond</code>:

<pre><code>&gt;&gt;&gt; from collections import defaultdict
&gt;&gt;&gt; import string
&gt;&gt;&gt;
&gt;&gt;&gt; class SafeDict(dict):
... def __missing__(self, key):
... return '{' + key + '}'
...
&gt;&gt;&gt; string.Formatter().vformat('{bond}, {james} {bond}', (), SafeDict(bond='bond'))
'bond, {james} bond'
</code></pre>

blocks|key|43420|text|您可以在safe_substitute方法中使用template+string。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|43421|from+string+import+Template

tpl+=+Template('$bond,+$james+$bond')
action+=+tpl.safe_substitute({'bond':+'bond'})|code-block|syntax|javascript|43422|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/2/library/string.html#template-strings^0|4|F|O|F|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

You could use a <a href="http://docs.python.org/2/library/string.html#template-strings">template string</a> with the <code>safe_substitute</code> method.

<pre><code>from string import Template

tpl = Template('$bond, $james $bond')
action = tpl.safe_substitute({'bond': 'bond'})
</code></pre>

blocks|key|2728238|text|您可以遵循PEP+3101和子类格式化程序中的建议：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2728239|from+__future__+import+print_function
import+string

class+MyFormatter(string.Formatter):
++++def+__init__(self,+default='{{{0}}}'):
++++++++self.default=default

++++def+get_value(self,+key,+args,+kwds):
++++++++if+isinstance(key,+str):
++++++++++++return+kwds.get(key,+self.default.format(key))
++++++++else:
++++++++++++return+string.Formatter.get_value(key,+args,+kwds)|code-block|syntax|javascript|2728240|现在试一下：|2728241|>>>+fmt=MyFormatter()
>>>+fmt.format("{bond},+{james}+{bond}",+bond='bond',+james='james')
'bond,+james+bond'
>>>+fmt.format("{bond},+{james}+{bond}",+bond='bond')
'bond,+{james}+bond'|2728242|您可以通过将self.default中的文本更改为您希望在KeyErrors中显示的文本来更改标记关键错误的方式：|style|CODE|2728243|>>>+fmt=MyFormatter('">>{{{0}}}+KeyError<<"')
>>>+fmt.format("{bond},+{james}+{bond}",+bond='bond',+james='james')
'bond,+james+bond'
>>>+fmt.format("{bond},+{james}+{bond}",+bond='bond')
'bond,+">>{james}+KeyError<<"+bond'|2728244|该代码在Python2.6、2.7和3.0%2B上运行不变|2728245|entityMap|0|LINK|mutability|MUTABLE|url|http://www.python.org/dev/peps/pep-3101/^0|5|8|0|0|0|0|0|6|C|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|18|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|19|8|@$A|1A|B|1B|O|P]]|9|@]|C|$]]|$1|Q|3|R|5|F|7|1C|8|@]|9|@]|C|$G|H]]|$1|S|3|T|5|6|7|1D|8|@]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1E|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]]]

You can follow the recommendation in <a href="http://www.python.org/dev/peps/pep-3101/" rel="noreferrer">PEP 3101</a> and subclass Formatter:

<pre><code>from __future__ import print_function
import string

class MyFormatter(string.Formatter):
 def __init__(self, default='{{{0}}}'):
 self.default=default

 def get_value(self, key, args, kwds):
 if isinstance(key, str):
 return kwds.get(key, self.default.format(key))
 else:
 return string.Formatter.get_value(key, args, kwds)
</code></pre>

Now try it:

<pre><code>&gt;&gt;&gt; fmt=MyFormatter()
&gt;&gt;&gt; fmt.format("{bond}, {james} {bond}", bond='bond', james='james')
'bond, james bond'
&gt;&gt;&gt; fmt.format("{bond}, {james} {bond}", bond='bond')
'bond, {james} bond'
</code></pre>

You can change how key errors are flagged by changing the text in <code>self.default</code> to what you would like to show for KeyErrors:

<pre><code>&gt;&gt;&gt; fmt=MyFormatter('"&gt;&gt;{{{0}}} KeyError&lt;&lt;"')
&gt;&gt;&gt; fmt.format("{bond}, {james} {bond}", bond='bond', james='james')
'bond, james bond'
&gt;&gt;&gt; fmt.format("{bond}, {james} {bond}", bond='bond')
'bond, "&gt;&gt;{james} KeyError&lt;&lt;" bond'
</code></pre>

The code works unchanged on Python 2.6, 2.7, and 3.0+

blocks|key|2728295|text|falsetru's+answer巧妙地使用了默认字典和vformat()，dawg's+answer可能更符合Python文档，但都不能处理复合字段名称(例如，使用显式转换(!r)或格式规范(:%2B10g)+)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2728296|例如，使用falsetru的SafeDict：|2728297|>>>+string.Formatter().vformat('{one}+{one:x}+{one:10f}+{two!r}+{two[0]}',+(),+SafeDict(one=215,+two=['James',+'Bond']))
"215+d7+215.000000+['James',+'Bond']+James"
>>>+string.Formatter().vformat('{one}+{one:x}+{one:10f}+{two!r}+{two[0]}',+(),+SafeDict(one=215))
"215+d7+215.000000+'{two}'+{"|code-block|syntax|javascript|2728298|使用dawg的MyFormatter：|2728299|>>>+MyFormatter().format('{one}+{one:x}+{one:10f}+{two!r}+{two[0]}',+one=215,+two=['James',+'Bond'])
"215+d7+215.000000+['James',+'Bond']+James"
>>>+MyFormatter().format('{one}+{one:x}+{one:10f}+{two!r}+{two[0]}',+one=215)
"215+d7+215.000000+'{two}'+{"|2728300|在第二种情况下，这两种方法都不能很好地工作，因为值查找(在get_value()中)已经去掉了格式规范。相反，您可以重新定义vformat()或parse()，以便这些规范可用。我下面的解决方案通过重新定义vformat()来实现这一点，这样它就执行键查找，如果缺少键，则用双花括号(例如{{two!r}})转义格式字符串，然后执行正常的vformat()。|2728301|class+SafeFormatter(string.Formatter):
++++def+vformat(self,+format_string,+args,+kwargs):
++++++++args_len+=+len(args)++#+for+checking+IndexError
++++++++tokens+=+[]
++++++++for+(lit,+name,+spec,+conv)+in+self.parse(format_string):
++++++++++++#+re-escape+braces+that+parse()+unescaped
++++++++++++lit+=+lit.replace('{',+'{{').replace('}',+'}}')
++++++++++++#+only+lit+is+non-None+at+the+end+of+the+string
++++++++++++if+name+is+None:
++++++++++++++++tokens.append(lit)
++++++++++++else:
++++++++++++++++#+but+conv+and+spec+are+None+if+unused
++++++++++++++++conv+=+'!'+%2B+conv+if+conv+else+''
++++++++++++++++spec+=+':'+%2B+spec+if+spec+else+''
++++++++++++++++#+name+includes+indexing+([blah])+and+attributes+(.blah)
++++++++++++++++#+so+get+just+the+first+part
++++++++++++++++fp+=+name.split('[')[0].split('.')[0]
++++++++++++++++#+treat+as+normal+if+fp+is+empty+(an+implicit
++++++++++++++++#+positional+arg),+a+digit+(an+explicit+positional
++++++++++++++++#+arg)+or+if+it+is+in+kwargs
++++++++++++++++if+not+fp+or+fp.isdigit()+or+fp+in+kwargs:
++++++++++++++++++++tokens.extend([lit,+'{',+name,+conv,+spec,+'}'])
++++++++++++++++#+otherwise+escape+the+braces
++++++++++++++++else:
++++++++++++++++++++tokens.extend([lit,+'{{',+name,+conv,+spec,+'}}'])
++++++++format_string+=+''.join(tokens)++#+put+the+string+back+together
++++++++#+finally+call+the+default+formatter
++++++++return+string.Formatter.vformat(self,+format_string,+args,+kwargs)|2728302|这就是它的实际作用：|2728303|>>>+SafeFormatter().format('{one}+{one:x}+{one:10f}+{two!r}+{two[0]}',+one=215,+two=['James',+'Bond'])
"215+d7+215.000000+['James',+'Bond']+James"
>>>+SafeFormatter().format('{one}+{one:x}+{one:10f}+{two!r}+{two[0]}',+one=215)
'215+d7+215.000000+{two!r}+{two[0]}'
>>>+SafeFormatter().format('{one}+{one:x}+{one:10f}+{two!r}+{two[0]}')
'{one}+{one:x}+{one:10f}+{two!r}+{two[0]}'
>>>+SafeFormatter().format('{one}+{one:x}+{one:10f}+{two!r}+{two[0]}',+two=['James',+'Bond'])
"{one}+{one:x}+{one:10f}+['James',+'Bond']+James"|2728304|这个解决方案有点太老套了(也许重新定义parse()会有更少的杂乱无章的东西)，但应该适用于更多的格式化字符串。|2728305|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/17215533/1441112|1|https://stackoverflow.com/a/33621609/1441112^0|S|9|2G|2|2P|5|0|H|0|12|D|1|0|0|0|0|0|T|B|1Q|9|20|7|2V|9|40|9|4P|9|0|0|0|0|J|7|0^^$0|@$1|2|3|4|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@$9|1H|A|1I|1|1J]|$9|1K|A|1L|1|1M]]|E|$]]|$1|F|3|G|5|6|7|1N|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1O|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1P|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1Q|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1R|8|@$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]|$9|22|A|23|B|C]]|D|@]|E|$]]|$1|S|3|T|5|J|7|24|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|25|8|@]|D|@]|E|$]]|$1|W|3|X|5|J|7|26|8|@]|D|@]|E|$K|L]]|$1|Y|3|Z|5|6|7|27|8|@$9|28|A|29|B|C]]|D|@]|E|$]]|$1|10|3|-4|5|6|7|2A|8|@]|D|@]|E|$]]]|11|$12|$5|13|14|15|E|$16|17]]|18|$5|13|14|15|E|$16|19]]]]

<a href="https://stackoverflow.com/a/17215533/1441112">falsetru's answer</a> has a clever use of a defaulting dictionary with <code>vformat()</code>, and <a href="https://stackoverflow.com/a/33621609/1441112">dawg's answer</a> is perhaps more in-line with Python's documentation, but neither handle compound field names (e.g., with explicit conversion (<code>!r</code>) or format specs (<code>:+10g</code>).

For example, using falsetru's SafeDict:

<pre><code>&gt;&gt;&gt; string.Formatter().vformat('{one} {one:x} {one:10f} {two!r} {two[0]}', (), SafeDict(one=215, two=['James', 'Bond']))
"215 d7 215.000000 ['James', 'Bond'] James"
&gt;&gt;&gt; string.Formatter().vformat('{one} {one:x} {one:10f} {two!r} {two[0]}', (), SafeDict(one=215))
"215 d7 215.000000 '{two}' {"
</code></pre>

And using dawg's MyFormatter:

<pre><code>&gt;&gt;&gt; MyFormatter().format('{one} {one:x} {one:10f} {two!r} {two[0]}', one=215, two=['James', 'Bond'])
"215 d7 215.000000 ['James', 'Bond'] James"
&gt;&gt;&gt; MyFormatter().format('{one} {one:x} {one:10f} {two!r} {two[0]}', one=215)
"215 d7 215.000000 '{two}' {"
</code></pre>

Neither work well in the second case because the value lookup (in <code>get_value()</code>) has already stripped out the formatting specifications. Instead, you can redefine <code>vformat()</code> or <code>parse()</code> so these specifications are available. My solution below does this by redefining <code>vformat()</code> so it performs the key lookup and, if the key is missing, escapes the format string with double braces (e.g. <code>{{two!r}}</code>) and then performs the normal <code>vformat()</code>.

<pre><code>class SafeFormatter(string.Formatter):
 def vformat(self, format_string, args, kwargs):
 args_len = len(args) # for checking IndexError
 tokens = []
 for (lit, name, spec, conv) in self.parse(format_string):
 # re-escape braces that parse() unescaped
 lit = lit.replace('{', '{{').replace('}', '}}')
 # only lit is non-None at the end of the string
 if name is None:
 tokens.append(lit)
 else:
 # but conv and spec are None if unused
 conv = '!' + conv if conv else ''
 spec = ':' + spec if spec else ''
 # name includes indexing ([blah]) and attributes (.blah)
 # so get just the first part
 fp = name.split('[')[0].split('.')[0]
 # treat as normal if fp is empty (an implicit
 # positional arg), a digit (an explicit positional
 # arg) or if it is in kwargs
 if not fp or fp.isdigit() or fp in kwargs:
 tokens.extend([lit, '{', name, conv, spec, '}'])
 # otherwise escape the braces
 else:
 tokens.extend([lit, '{{', name, conv, spec, '}}'])
 format_string = ''.join(tokens) # put the string back together
 # finally call the default formatter
 return string.Formatter.vformat(self, format_string, args, kwargs)
</code></pre>

Here's it in action:

<pre><code>&gt;&gt;&gt; SafeFormatter().format('{one} {one:x} {one:10f} {two!r} {two[0]}', one=215, two=['James', 'Bond'])
"215 d7 215.000000 ['James', 'Bond'] James"
&gt;&gt;&gt; SafeFormatter().format('{one} {one:x} {one:10f} {two!r} {two[0]}', one=215)
'215 d7 215.000000 {two!r} {two[0]}'
&gt;&gt;&gt; SafeFormatter().format('{one} {one:x} {one:10f} {two!r} {two[0]}')
'{one} {one:x} {one:10f} {two!r} {two[0]}'
&gt;&gt;&gt; SafeFormatter().format('{one} {one:x} {one:10f} {two!r} {two[0]}', two=['James', 'Bond'])
"{one} {one:x} {one:10f} ['James', 'Bond'] James"
</code></pre>

This solution is a bit too hacky (maybe redefining <code>parse()</code> would have fewer kludges), but should work for more formatting strings.

blocks|key|43458|text|一个人也可以做简单和可读的，尽管有点愚蠢：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|43459|'{bar},+{fro}+{bar}'.format(bar='bar',+fro='{fro}')|code-block|syntax|javascript|43460|我知道这个答案需要了解预期的键，但我正在寻找一个简单的两步替换(首先是问题名称，然后是循环中的问题索引)，并且创建整个类或不可读的代码比需要的要复杂得多。|43461|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

One can also do the simple and readable, albeit somewhat silly:
<pre class="lang-py prettyprint-override"><code>'{bar}, {fro} {bar}'.format(bar='bar', fro='{fro}')
</code></pre>
I know that this answer requires knowledge of the expected keys,
but I was looking for a simple two-step substitution (say problem name first, then problem index within a loop) and creating a whole class or unreadable code was more complex than needed.

blocks|key|2728390|text|当逐步填充格式字符串时，例如对于SQL查询，需要部分填充格式字符串是一个常见的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2728391|format_partial()方法使用来自string和ast的Formatter来解析格式字符串，并确定命名参数散列是否具有部分计算格式所需的所有值：|offset|length|style|CODE|2728392|import+ast
from+collections+import+defaultdict
from+itertools+import+chain,+ifilter,+imap
from+operator+import+itemgetter
import+re
from+string+import+Formatter

def+format_partial(fstr,+**kwargs):
++++def+can_resolve(expr,+**kwargs):
++++++++walk+=+chain.from_iterable(imap(ast.iter_fields,+ast.walk(ast.parse(expr))))
++++++++return+all(v+in+kwargs+for+k,v+in+ifilter(lambda+(k,v):+k=='id',+walk))

++++ostr+=+fstr
++++fmtr+=+Formatter()
++++dd+=+defaultdict(int)
++++fmtr.get_field+=+lambda+field_name,+args,+kwargs:+(dd[field_name],field_name)
++++fmtr.check_unused_args+=+lambda+used_args,+args,+kwargs:+all(v+in+dd+for+v+in+used_args)
++++for+t+in+ifilter(itemgetter(1),+Formatter().parse(fstr)):
++++++++f+=+'{'%2Bt[1]%2B(':'%2Bt[2]+if+t[2]+else+'')%2B'}'
++++++++dd+=+defaultdict(int)
++++++++fmtr.format(f,**kwargs)
++++++++if+all(can_resolve(e,**kwargs)+for+e+in+dd):
++++++++++++ostr+=+re.sub(re.escape(f),Formatter().format(f,+**kwargs),ostr,count=1)
++++return+ostr|code-block|syntax|javascript|2728393|format_partial将保留格式字符串中未解析的部分，因此当数据可用时，后续调用可用于解析这些部分。|2728394|goodmami和dawg的答案看起来更清晰，但他们都没有像{x:>{x}}那样完全捕获格式迷你语言；format_partial解析string.format()解析的任何格式字符串都没有问题：|2728395|from+datetime+import+date
format_partial('{x}+{}+{y[1]:x}+{x:>{x}}+{z.year}',+**{'x':30,+'y':[1,2],+'z':date.today()})

'30+{}+2+++++++++++++++++++++++++++++30+2016'|2728396|使用正则表达式而不是字符串格式化程序将功能扩展到旧样式格式字符串甚至更容易，因为旧样式格式子字符串是常规的(即。无嵌套标记)。|2728397|entityMap^0|0|0|G|M|6|T|3|X|9|0|0|0|E|0|U|8|1F|E|1V|F|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@$D|Y|E|Z|F|G]|$D|10|E|11|F|G]|$D|12|E|13|F|G]|$D|14|E|15|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|17|8|@$D|18|E|19|F|G]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@$D|1B|E|1C|F|G]|$D|1D|E|1E|F|G]|$D|1F|E|1G|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|J|7|1H|8|@]|9|@]|A|$K|L]]|$1|S|3|T|5|6|7|1I|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|V|$]]

Needing to partially fill format strings is a common problem when progressively filling the format strings, e.g. for SQL queries.

<code>format_partial()</code> method uses the <code>Formatter</code> from <code>string</code> and <code>ast</code> to parse the format string and also find out whether the named parameter hash has all the values needed to partially evaluate the format:

<pre><code>import ast
from collections import defaultdict
from itertools import chain, ifilter, imap
from operator import itemgetter
import re
from string import Formatter

def format_partial(fstr, **kwargs):
 def can_resolve(expr, **kwargs):
 walk = chain.from_iterable(imap(ast.iter_fields, ast.walk(ast.parse(expr))))
 return all(v in kwargs for k,v in ifilter(lambda (k,v): k=='id', walk))

 ostr = fstr
 fmtr = Formatter()
 dd = defaultdict(int)
 fmtr.get_field = lambda field_name, args, kwargs: (dd[field_name],field_name)
 fmtr.check_unused_args = lambda used_args, args, kwargs: all(v in dd for v in used_args)
 for t in ifilter(itemgetter(1), Formatter().parse(fstr)):
 f = '{'+t[1]+(':'+t[2] if t[2] else '')+'}'
 dd = defaultdict(int)
 fmtr.format(f,**kwargs)
 if all(can_resolve(e,**kwargs) for e in dd):
 ostr = re.sub(re.escape(f),Formatter().format(f, **kwargs),ostr,count=1)
 return ostr
</code></pre>

<code>format_partial</code> will leave the unresolved portion of the format string, so subsequent calls can be used to resolve those parts as the data is available.

goodmami's and dawg's answers seem cleaner, but they both fail to capture the format mini-language completely as in <code>{x:&gt;{x}}</code>; <code>format_partial</code> will have no problem resolving any format string that <code>string.format()</code> resolves:

<pre><code>from datetime import date
format_partial('{x} {} {y[1]:x} {x:&gt;{x}} {z.year}', **{'x':30, 'y':[1,2], 'z':date.today()})

'30 {} 2 30 2016'
</code></pre>

It is even easier to extend the functionality to old style format strings using regex instead of the string formatter, as the old style format substrings were regular (ie. no nested markers).

blocks|key|2518869|text|下面是使用python27的另一种方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2518870|action+=+'{bond},+{james}+{bond}'
d+=+dict((x[1],+'')+for+x+in+action._formatter_parser())
#+Now+we+have:+`d+=+{'james':+'',+'bond':+''}`.
d.update(bond='bond')
print+action.format(**d)++#+bond,++bond|code-block|syntax|javascript|2518871|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's another way to do it using python27:

<pre><code>action = '{bond}, {james} {bond}'
d = dict((x[1], '') for x in action._formatter_parser())
# Now we have: `d = {'james': '', 'bond': ''}`.
d.update(bond='bond')
print action.format(**d) # bond, bond
</code></pre>

blocks|key|43686|text|对于Python+3，采用认可的答案，这是一个很好的，紧凑的，Pythonic实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|43687|def+safeformat(str,+**kwargs):
++++class+SafeDict(dict):
++++++++def+__missing__(self,+key):
++++++++++++return+'{'+%2B+key+%2B+'}'
++++replacements+=+SafeDict(**kwargs)
++++return+str.format_map(replacements)

#+In+[1]:+safeformat("a:+{a},+b:+{b},+c:+{c}",+a="A",+c="C",+d="D")
#+Out[1]:+'a:+A,+b:+{b},+c:+C'|code-block|syntax|javascript|43688|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For Python 3, taking the approved answer, this is a nice, tight, Pythonic implementation:

<pre><code>def safeformat(str, **kwargs):
 class SafeDict(dict):
 def __missing__(self, key):
 return '{' + key + '}'
 replacements = SafeDict(**kwargs)
 return str.format_map(replacements)

# In [1]: safeformat("a: {a}, b: {b}, c: {c}", a="A", c="C", d="D")
# Out[1]: 'a: A, b: {b}, c: C'
</code></pre>

blocks|key|2518984|text|基于其他一些答案，我扩展了解决方案。这将处理带有格式化规范"{a:<10}"的字符串。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2518985|我发现selenium日志记录中的一些字符串导致vformat+(和format_map)达到递归限制。我还想确保我可以处理存在空花括号的字符串。|2518986|def+partialformat(s:+str,+recursionlimit:+int+=+10,+**kwargs):
++++"""
++++vformat+does+the+acutal+work+of+formatting+strings.+_vformat+is+the+
++++internal+call+to+vformat+and+has+the+ability+to+alter+the+recursion+
++++limit+of+how+many+embedded+curly+braces+to+handle.+But+for+some+reason+
++++vformat+does+not.++vformat+also+sets+the+limit+to+2!+++

++++The+2nd+argument+of+_vformat+'args'+allows+us+to+pass+in+a+string+which+
++++contains+an+empty+curly+brace+set+and+ignore+them.
++++"""

++++class+FormatPlaceholder:
++++++++def+__init__(self,+key):
++++++++++++self.key+=+key

++++++++def+__format__(self,+spec):
++++++++++++result+=+self.key
++++++++++++if+spec:
++++++++++++++++result+%2B=+":"+%2B+spec
++++++++++++return+"{"+%2B+result+%2B+"}"

++++class+FormatDict(dict):
++++++++def+__missing__(self,+key):
++++++++++++return+FormatPlaceholder(key)

++++class+PartialFormatter(string.Formatter):
++++++++def+get_field(self,+field_name,+args,+kwargs):
++++++++++++try:
++++++++++++++++obj,+first+=+super(PartialFormatter,+self).get_field(field_name,+args,+kwargs)
++++++++++++except+(IndexError,+KeyError,+AttributeError):
++++++++++++++++first,+rest+=+formatter_field_name_split(field_name)
++++++++++++++++obj+=+'{'+%2B+field_name+%2B+'}'

++++++++++++++++#+loop+through+the+rest+of+the+field_name,+doing
++++++++++++++++#++getattr+or+getitem+as+needed
++++++++++++++++for+is_attr,+i+in+rest:
++++++++++++++++++++if+is_attr:
++++++++++++++++++++++++try:
++++++++++++++++++++++++++++obj+=+getattr(obj,+i)
++++++++++++++++++++++++except+AttributeError+as+exc:
++++++++++++++++++++++++++++pass
++++++++++++++++++++else:
++++++++++++++++++++++++obj+=+obj[i]

++++++++++++return+obj,+first

++++fmttr+=+string.Formatter()
++++fs,+_+=+fmttr._vformat(s,+("{}",),+FormatDict(**kwargs),+set(),+recursionlimit)
++++return+fs

class+ColorObj(object):
++++blue+=+"%5EBLUE%5E"
s+=+'{"a":+{"b":+{"c":+{"d"+:+{}+{foo:<12}+&+{foo!r}+{arg}+{color.blue:<10}+{color.pink}+{blah.atr}+}}}}'
print(partialformat(s,+foo="Fooolery",+arg="ARRrrrrrg!",+color=ColorObj))|code-block|syntax|javascript|2518987|输出：|2518988|{"a":+{"b":+{"c":+{"d"+:+{}+Fooolery+++++++++++++&+'Fooolery'+Fooolery+ARRrrrrrg!+%5EBLUE%5E+{color.pink}+{blah.atr}+}}}}|2518989|entityMap^0|T|9|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

Based on some of the other answers, I expanded the solutions.
This will handle strings with formatting spec <code>"{a:&lt;10}"</code>.

I found that some strings from selenium logging were causing vformat (and format_map) to hit a recursion limit. I also wanted to ensure I could handle strings where empty curly braces exist as well.

<pre class="lang-py prettyprint-override"><code>def partialformat(s: str, recursionlimit: int = 10, **kwargs):
 """
 vformat does the acutal work of formatting strings. _vformat is the 
 internal call to vformat and has the ability to alter the recursion 
 limit of how many embedded curly braces to handle. But for some reason 
 vformat does not. vformat also sets the limit to 2! 

 The 2nd argument of _vformat 'args' allows us to pass in a string which 
 contains an empty curly brace set and ignore them.
 """

 class FormatPlaceholder:
 def __init__(self, key):
 self.key = key

 def __format__(self, spec):
 result = self.key
 if spec:
 result += ":" + spec
 return "{" + result + "}"

 class FormatDict(dict):
 def __missing__(self, key):
 return FormatPlaceholder(key)

 class PartialFormatter(string.Formatter):
 def get_field(self, field_name, args, kwargs):
 try:
 obj, first = super(PartialFormatter, self).get_field(field_name, args, kwargs)
 except (IndexError, KeyError, AttributeError):
 first, rest = formatter_field_name_split(field_name)
 obj = '{' + field_name + '}'

 # loop through the rest of the field_name, doing
 # getattr or getitem as needed
 for is_attr, i in rest:
 if is_attr:
 try:
 obj = getattr(obj, i)
 except AttributeError as exc:
 pass
 else:
 obj = obj[i]

 return obj, first

 fmttr = string.Formatter()
 fs, _ = fmttr._vformat(s, ("{}",), FormatDict(**kwargs), set(), recursionlimit)
 return fs

class ColorObj(object):
 blue = "^BLUE^"
s = '{"a": {"b": {"c": {"d" : {} {foo:&lt;12} &amp; {foo!r} {arg} {color.blue:&lt;10} {color.pink} {blah.atr} }}}}'
print(partialformat(s, foo="Fooolery", arg="ARRrrrrrg!", color=ColorObj))
</code></pre>

output:

<pre class="lang-none prettyprint-override"><code>{"a": {"b": {"c": {"d" : {} Fooolery &amp; 'Fooolery' Fooolery ARRrrrrrg! ^BLUE^ {color.pink} {blah.atr} }}}}
</code></pre>

Let's say I have:

<pre><code>action = '{bond}, {james} {bond}'.format(bond='bond', james='james')
</code></pre>

this wil output:

<pre><code>'bond, james bond' 
</code></pre>

Next we have:

<pre><code> action = '{bond}, {james} {bond}'.format(bond='bond')
</code></pre>

this will output:

<pre><code>KeyError: 'james'
</code></pre>

Is there some workaround to prevent this error to happen, something like:

<ul>
<li>if keyrror: ignore, leave it alone (but do parse others)</li>
<li>compare format string with available named arguments, if missing then add</li>
</ul>

Format string unused named arguments

5位重磅专家聚焦 AI 时代开发者核心成长需求，带你深入解锁全栈进化、人机协作关键路径！点击报名到场：<a href="https://cloud.tencent.com/developer/salon/salon-2403/signup" target="_blank">https://cloud.tencent.com/developer/salon/salon-2403/signup</a> 
 <img src="https://qcloudimg.tencent-cloud.cn/raw/487c82639d2338df3ef66dfb1450601a.png"/>

腾讯技术创作特训营「年度论坛」正在报名中！

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

假设我有：action = '{bond}, {james} {bond}'.format(bond='bond', james='james')这个wil输出：'bond, james bond' 接下来我们有： action = '{bond}, {james} {bond}'.format(bond='bond'...

问格式字符串未使用的命名参数
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问格式字符串未使用的命名参数EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问格式字符串未使用的命名参数
EN