[Python-ideas] Dunder method to make object str-like

Nathaniel Smith njs at pobox.com
Thu Apr 7 10:56:35 EDT 2016

Why strings and not, say, floats or bools or lists or bytes? Is it because
strings have a uniquely compelling use case, or...?

(For context from the numpy side of things, since IIUC numpy's fixed-width
integer types were the impetus for __index__: numpy actually has a shadow
type system that has versions of all of those types above except list. It
also has a general conversion/casting system with a concept of different
levels of safety, so for us __index__ is like a "safe" cast to int, and
__int__ is like a "unsafe", and we have versions of this for all pairs of
internal types, which if you care about this in general then having a
single parametrized concept of safe casting might make more sense then
adding new methods one by one.

I'm not aware of any particular pain points triggered by numpy's strings
not being real strings, though, at least in numpy's current design.)

On Apr 7, 2016 6:05 AM, "Chris Angelico" <rosuav at gmail.com> wrote:

This is a spin-off from the __fspath__ discussion on python-dev, in
which a few people said that a more general approach would be better.

Proposal: Objects should be allowed to declare that they are
"string-like" by creating a dunder method (analogously to __index__
for integers) which implies a loss-less conversion to str.

This could supersede the __fspath__ "give me the string for this path"
protocol, or could stand in parallel with it.

Obviously str will have this dunder method, returning self. Most other
core types (notably 'object') will not define it. Absence of this
method implies that the object cannot be treated as a string.

String methods will be defined as accepting string-like objects. For
instance, "hello"+foo will succeed if foo is string-like.

Downside: Two string-like objects may behave unexpectedly - foo+bar
will concatenate strings if either is an actual string, but if both
are other string-like objects, depends on the implementation of those


1) What should the dunder method be named? __str_coerce__? __stringlike__?

2) Which standard types are sufficiently string-like to be used thus?

3) Should there be a bytes equivalent?

4) Should there be a format string "coerce to str"? "{}".format(x) is
equivalent to str(x), but it might be nice to be able to assert that
something's stringish already.

Open season!
Python-ideas mailing list
Python-ideas at python.org
Code of Conduct: http://python.org/psf/codeofconduct/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/python-ideas/attachments/20160407/67d725d6/attachment.html>

More information about the Python-ideas mailing list