ncoghlan ncoghlan - 2 months ago 12
Python Question

Including a formatted iterable as part of a larger formatted string

In writing a class recently, I initially included a

__repr__
method along the following lines:

return "{}({!r}, {!r}, {!r})".format(
self.__class__.__name__,
self.arg1,
self.arg2,
self.arg3)


Repeating the '{!r}' snippet like that feels wrong and would be tedious to maintain if I ever add any more arguments to this class. However, the more robust alternatives that occurred to me aren't going to win any prizes for elegance either.

Building the format string programmatically:

fmt = "{}(%s)" % ", ".join(["{!r}"]*3)
return fmt.format(self.__class__.__name__,
self.arg1,
self.arg2,
self.arg3)


Formatting the arguments separately with
str.join
:

args = ", ".join(map(repr, [self.arg1, self.arg2, self.arg3]))
return "{}({})".format(self.__class__.__name__, args)


I've currently implemented the class using the last example, but I'm interested in suggestions for alternative approaches (since I'm not particularly happy with any of the above options).

Update:
Inspired by Ned's answer, I've now added the following utility function to a helper module:

def format_iter(iterable, fmt='{!r}', sep=', '):
return sep.join(fmt.format(x) for x in iterable)

>>> format_iter(range(10))
'0, 1, 2, 3, 4, 5, 6, 7, 8, 9'
>>> format_iter(range(10), sep='|')
'0|1|2|3|4|5|6|7|8|9'
>>> format_iter(range(10), fmt='{:04b}', sep='|')
'0000|0001|0010|0011|0100|0101|0110|0111|1000|1001'
>>> format_iter(range(10), fmt='{0.real}+{0.imag}j')
'0+0j, 1+0j, 2+0j, 3+0j, 4+0j, 5+0j, 6+0j, 7+0j, 8+0j, 9+0j'


Update2:
I ended up adding a second utility function, almost identical to the one in agf's answer:

def call_repr(name, *args):
return "{}({})".format(name, format_iter(args))


So the originally offending
__repr__
function now looks like:

def __repr__(self):
return call_repr(self.__class__.__name__,
self.arg1,
self.arg2)


(Yes, one of the original constructor arguments went away earlier today.)

agf agf
Answer

If this is a pattern you're going to repeat, I'd probably use:

# This is a static method or module-level function
def argrepr(name, *args):
    return '{}({})'.format(name, ', '.join(repr(arg) for arg in args))

def __repr__(self):
    return argrepr(self.__name__, self.arg1, self.arg2, self.arg3)

or

# This is a static method or module-level function
def argrepr(*args):
    return '(' + ', '.join(repr(arg) for arg in args) + ')'

def __repr__(self):
    return repr(self.__name__) + argrepr(self.arg1, self.arg2, self.arg3)