[Python-ideas] Briefer string format

[Ryan Gonzalez]

On July 19, 2015 11:23:00 PM CDT, "Stephen J. Turnbull" <stephen at xemacs.org> wrote:
>Chris Angelico writes:
>
> > I'm -1 on the specific idea, though definitely sympathetic to the
> > broader concept of simplified formatting of strings.
>
>So does everybody.  But we've seen many iterations: Perl/shell-style
>implicit interpolation apparently was right out from the very
>beginning of Python.  The magic print statement was then deprecated in
>favor of a function.  So I suppose it will be very hard to convince
>the BDFL (and anything implicit would surely need his approval) of
>anything but a function or an operator.
>
>We have the % operator taking a printf-style format string and a tuple
>of values to interpolate.  It's compact and easy to use with position
>indexes into the tuple for short formats and few values, but is nearly
>unreadable and not easy to write for long formats with many
>interpolations, especially if they are repeated.
>
> > Python's printf-style formatting has its own warts (mainly because
> > of the cute use of an operator, rather than doing it as a function
> > call),
>
>I think the operator is actually a useful feature, not merely "cute".
>It directs the focus to the format string, rather than the function
>call.
>
> > and still has the problem of having percent markers with no
> > indication of what they'll be interpolating in.
>
>Not so.  We have the more modern (?) % operator that takes a format
>string with named format sequences and a dictionary.  This seems to be
>close to what the OP wants:
>
>    val = "readable simple formatting method"
>    print("This is a %(val)s." % locals())
>
>(which actually works at module level as well as within a function).
>I suppose the OP will claim that an explicit call to locals() is
>verbose and redundant, but if that really is a problem:
>
>    def format_with_locals(fmtstr):
>        return fmtstr % locals()
>

Won't this use the locals of the function format_with_locals over its caller?

>(of course with a nice short name, mnemonic to the author).  Or for
>format strings to be used repeatedly with different (global -- the
>"locals" you want are actually nonlocal relative to a method, so
>there's no way to get at them AFAICS) values, there's this horrible
>hack:
>
>    >>> class autoformat_with_globals(str):
>    ...     def __pos__(self):
>    ...         return self % globals()
>    ...
>    >>> a = autoformat_with_globals("This is a %(description)s.")
>    >>> description = "autoformatted string"
>    >>> +a
>    'This is a autoformatted string.'
>
>with __neg__ and __invert__ as alternative horrible hacks.
>
>We have str.format.  I've gotten used to str.format but for most of my
>uses mapped %-formatting would work fine.
>
>We have an older proposal for a more flexible form of templating using
>the Perl/shell-ish $ operator in format strings.  And we have a large
>number of templating languages from web frameworks (Django, Jinja,
>etc).
>
>None of these seem universally applicable.  It's ugly in one sense
>(TOOWTDI violation), but ISTM that positional % for short interactive
>use, mapped % for templating where the conventional format operators
>suffice, and str.format for maximum explicit flexibility in programs,
>with context-sensitive formatting of new types, is an excellent
>combination.
>
>_______________________________________________
>Python-ideas mailing list
>Python-ideas at python.org
>https://mail.python.org/mailman/listinfo/python-ideas
>Code of Conduct: http://python.org/psf/codeofconduct/

-- 
Sent from my Android device with K-9 Mail. Please excuse my brevity.