[EMAIL PROTECTED] wrote:
> Positional arguments remove too much meaning from the template.
>
> Compare:
>
> '$user forgot to frobnicate the $file!\n'
>
> with
>
> '$1 forgot to frobnicate the $2!\n'
>
> Whenever the template definition and its use are not directly
> adjacent, the template is that much harder to understand (i.e.,
> in the context of translation, one wouldn't see the arguments
> passed to the template).
Ideas like this one are really about taking the current C-originated string
formatting and replacing it with a more powerful version of the new
string.Template formatting.
One interesting idea to consider is to add "format" and "safe_format" string
methods (or "substitute" and "safe_substitute" if matching the PEP 292 method
names is considered important) which work something like:
# These would be new str and unicode methods
def format(*args, **kwds):
return string.Template(args[0]).substitute(*args[1:], **kwds)
def safe_format(*args, **kwds):
return string.Template(args[0]).safe_substitute(*args[1:], **kwds)
Then enhance string.Template such that:
1. Item identifiers could be numbers as well as valid Python identifiers
2. Positional arguments were added to the dictionary of items using their
argument index as a string
Something like:
# This would be modified behaviour of the substitute method
# rather than a separate method or function
def pos_substitute(*args, **kwds):
self = args[0]
kwds.update((str(idx), arg) for idx, arg in enumerate(args))
# Avoiding including self in kwds is also an option
return self.substitute(**kwds)
(To try this on Py2.4, use "$p1" for the positional arguments to easily get
around the restriction in the string.Template regex)
With the above changes, the following would work:
"$1: $2".format("Number of bees", "0.5")
And produce:
"Number of bees: 0.5"
When pre-compiling string.Templates, the keyword method is significantly
clearer, but if the syntax was accessible through a string method, then being
able to use positional arguments would be very handy.
At this point, the only thing missing is the ability to handle proper output
formatting - that would need to be done by invoking the string mod operator
directly on the positional argument via:
"$1: $2".format("Number of bees: ", "%0.2f" % val)
In theory (I haven't really tried this bit), it should be possible to adjust
string.Template to support the following equivalent:
"$1: $[0.2f]2".format("Number of bees: ", val)
That way, rather than inventing a new formatting language, string.Template
could leverage the existing string mod operator by substituting the result of
"('%' + fmt) % val" wherever it sees "$[fmt]name" or "$[fmt]{name}"
Cheers,
Nick.
--
Nick Coghlan | [EMAIL PROTECTED] | Brisbane, Australia
---------------------------------------------------------------
http://boredomandlaziness.blogspot.com
_______________________________________________
Python-Dev mailing list
Python-Dev@python.org
http://mail.python.org/mailman/listinfo/python-dev
Unsubscribe:
http://mail.python.org/mailman/options/python-dev/archive%40mail-archive.com
