homepage

I've run into a case where pprint isn't able to print out a particular 
data structure, and have distilled it down to a simple example:
import pprint
class A:
 pass
pprint.pprint({A(): 1, A(): 2})
Which throws this exception:
Traceback (most recent call last):
 File 
"/opt/local/Library/Frameworks/Python.framework/Versions/3.0/lib/python3
.0/pprint.py", line 272, in _safe_repr
 items = sorted(items)
TypeError: unorderable types: A() < A()
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
 File "foo.py", line 6, in <module>
 pprint.pprint({A(): 1, A(): 2})
 File 
"/opt/local/Library/Frameworks/Python.framework/Versions/3.0/lib/python3
.0/pprint.py", line 55, in pprint
 printer.pprint(object)
 File 
"/opt/local/Library/Frameworks/Python.framework/Versions/3.0/lib/python3
.0/pprint.py", line 106, in pprint
 self._format(object, self._stream, 0, 0, {}, 0)
 File 
"/opt/local/Library/Frameworks/Python.framework/Versions/3.0/lib/python3
.0/pprint.py", line 129, in _format
 rep = self._repr(object, context, level - 1)
 File 
"/opt/local/Library/Frameworks/Python.framework/Versions/3.0/lib/python3
.0/pprint.py", line 216, in _repr
 self._depth, level)
 File 
"/opt/local/Library/Frameworks/Python.framework/Versions/3.0/lib/python3
.0/pprint.py", line 228, in format
 return _safe_repr(object, context, maxlevels, level)
 File 
"/opt/local/Library/Frameworks/Python.framework/Versions/3.0/lib/python3
.0/pprint.py", line 277, in _safe_repr
 items = sorted(items, key=sortkey)
TypeError: unorderable types: A() < A()
This is happening because of this block of code:
 try:
 items = sorted(items)
 except TypeError:
 def sortkey(item):
 key, value = item
 return str(type(key)), key, value
 items = sorted(items, key=sortkey)
The exception block is trying to sort the items again, but in this 
instance, it's still not orderable. Could we get _safe_repr to at least 
give up on sorting at this point? Or, we could try just falling back to 
sorting according to the class name, with:
 try:
 items = sorted(items)
 except TypeError:
 def sortkey(item):
 key, value = item
 return str(type(key)), key, value
 try:
 items = sorted(items, key=sortkey)
 except TypeError:
 def sortkey(item):
 key, value = item
 return str(type(key))
That would at least give some ordering to the output. Unfortunately, in 
this case it's a shame that we don't have the cmp function any more, 
because then we could just fall back to giving up on the ordering for 
just certain unorderable keys, but still have sorted output for 
orderable keys. I thought maybe we could test if the key and value have 
__lt__, but it looks like all classes now have that function, even if 
the user didn't implement it. In the long run though, I suppose the case 
where you have mixed types in a dict there's no sensible ordering 
anyway.

Another solution would be to separate the dict items by key type, try to
sort each items list with separate fallback on onsorted. Then merge the
whole thing, ordered by key type name.

fyi, I found another case where pprint needs a "safe sort", this is
when you have a list that contains a dictionary. Anyway, Here's a
simple patch that creates a _safe_sorted function that implements the
fallback:
--- /opt/local/lib/python3.0/pprint.py	2008年09月26日 09:35:21.000000000 -0700
+++ /tmp/pprint.py	2008年09月26日 09:35:13.000000000 -0700
@@ -145,7 +145,7 @@
 if length:
 context[objid] = 1
 indent = indent + self._indent_per_level
- items = sorted(object.items())
+ items = _safe_sorted(object.items())
 key, ent = items[0]
 rep = self._repr(key, context, level)
 write(rep)
@@ -267,14 +267,7 @@
 append = components.append
 level += 1
 saferepr = _safe_repr
- items = object.items()
- try:
- items = sorted(items)
- except TypeError:
- def sortkey(item):
- key, value = item
- return str(type(key)), key, value
- items = sorted(items, key=sortkey)
+ items = _safe_sorted(object.items())
 for k, v in items:
 krepr, kreadable, krecur = saferepr(k, context, maxlevels, level)
 vrepr, vreadable, vrecur = saferepr(v, context, maxlevels, level)
@@ -321,6 +314,20 @@
 rep = repr(object)
 return rep, (rep and not rep.startswith('<')), False
+def _safe_sorted(items):
+ try:
+ return sorted(items)
+ except TypeError:
+ def sortkey(item):
+ key, value = item
+ return str(type(key)), key, value
+ try:
+ return sorted(items, key=sortkey)
+ except TypeError:
+ def sortkey(item):
+ key, value = item
+ return str(type(key))
+ return sorted(items, key=sortkey)
 def _recursion(object):
 return ("<Recursion on %s with id=%s>"
One other thing to note is that I'm also aware that the yaml project
also has this problem, and they've got their own "safe_sorted"
function. It might be worthwhile formalizing this in a public function
in the api somewhere.

For this to be integrated, it should also add an unit test.

The proposed patch appears to give up sorting by key,value altogether if 
there are a few incomparable items. It would be better to group items by 
type and sort within each group. For example, 
pprint({1:1,2:2,A():3,A():4}) should print int:int items in order.

Also note that this patch will not sort sequences of mixed types where
some types are intercomparable "correctly" (in the way that Python 2
did), e.g. for
{1:2, 2:3, 'a':4, 1.5: 5}
the 1.5 key will not be placed between the 1 and 2 keys.
I'm not aware of a way to implement that behavior without support for a
general comparison function instead of a DSU key function.

I'm thinking that pprint should not try to sort unsortable items.
 try:
 items = sorted(items)
 except TypeError:
 items = list(items)

OK, there *is* a way. Consider this:
class safe_key(object):
 __slots__ = ('obj',)
 def __init__(self, obj):
 self.obj = obj
 def __eq__(self, other):
 return self.obj.__eq__(other.obj)
 def __lt__(self, other):
 try:
 return self.obj < other.obj
 except TypeError:
 return id(type(self.obj)) < id(type(other.obj))
ls = [2, 1, 1.0, 1.5, 'a', 'c', 'b']
print(sorted(ls, key=safe_key))

@Georg: Instead of catching a TypeError i would rather call __gt__ /
__lt__ directly and check for NotImplemented. Python 2.x did not catch
TypeErrors either.

Eg, something like this:
class safe_key(object):
 __slots__ = ('obj',)
 def __init__(self, obj):
 self.obj = obj
 def __eq__(self, other):
 return self.obj.__eq__(other.obj)
 def __lt__(self, other):
 rv = self.obj.__lt__(other.obj)
 if rv is NotImplemented:
 rv = id(type(self.obj)) < id(type(other.obj))
 return rv
ls = [2, 1, 1.0, 1.5, 'a', 'c', 'b']
print(sorted(ls, key=safe_key))

Fixed. See r76389 and r76390.

Armin: this has the problem that, if the object you're trying to compare is a class, self.obj.__lt__ expects a different number of parameters (i.e., it expects the instance). See issue 10017 . Testing with "<" works.