[Barry A. Warsaw]
> This PEP describes a simpler string substitution feature, also
> known as string interpolation. This PEP is "simpler" in two
> respects:
> 1. Python's current string substitution feature (commonly known as
> %-substitutions) is complicated and error prone. This PEP is
> simpler at the cost of less expressiveness.
> 2. PEP 215 proposed an alternative string interpolation feature,
> introducing a new `$' string prefix. PEP 292 is simpler than
> this because it involves no syntax changes and has much simpler
> rules for what substitutions can occur in the string.
For one, I do not like seeing `$' as a string prefix in Python, and wonder
if we could not merely go with `%' as we always did in Python. At least,
it keeps a kind of clear cut distance between Python and Perl. :-)
> In addition, the rules for what can follow a % sign are fairly
> complex, while the usual application rarely needs such complexity.
This premise seems exaggerated to me. `%' as it stands is not that
complex to understand. Moreover, many of us use `%' formatting a lot,
so it is not so rare that the current `%' specification is useful.
> 1. $$ is an escape; it is replaced with a single $
Let's suppose we stick with `%', the above rule reduces to something
already known.
> 3. ${identifier} [...]
We could use %{identifier} as meaning `%(identifier)s'. Clean. Simple.
> 2. $identifier [...]
This is where the difficulty lies. Since the PEP already suggests that
${identifier} was to be preferred over $identifier, why not just go a bit
forward, and drop 2. altogether? Or else, how do you justify that using
it really make things more legible?
Then, the whole proposal would reduce to adding %{identifier}, and instead
of having `.sub()' methods or whatever, just stick with what we already have.
This would be a mild change instead of a whole new feature, and keep Python
a little more wrapped to itself. Interpolation proposals I've seen always
looked a bit awkward and foreign so far.
I guess that merely adding %{identifier} would wholly satisfy the given
justifications for the PEP (that is, giving a mean for people to avoid
the %()s as error prone), with a minimal impact on the current Python
definition, and a bit less of a surprise. Python does not have to look
like Perl to be useful, you know! :-)
> Handling Missing Keys
This would be a non-issue, by the fact that %(identifier)s behaviour,
for undefined identifier, is already what we want.
> The mapping argument is optional; if it is omitted then the mapping is
> taken from the locals and globals of the context in which the .sub()
> method is executed.
This is an interesting idea. However, there are other contexts where the
concept of a compound dictionary of all globals and locals would be useful.
Maybe we could have some allvars() similar to globals() and locals(),
and use `... % allvars()' instead of `.sub()'? So this would serve both
string interpolation and other avenues.
I hope I succeed to express my feeling that we should try keeping string
interpolation rather natural with what Python already is. We should not
carelessly multiply paradigms.
--
François Pinard http://www.iro.umontreal.ca/~pinard
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4