Question

我正在开发一个库，它实现了一个适用于任何有序数据类型的数据结构 - 一个范围集。当你允许正负无限时，许多操作（如反转）会变得有趣。

一个目标是让datetime对象与该模块一起使用，并且在使用非数字对象支持infinity时，我创建了INFINITY和NEGATIVE_INFINITY：

class _Indeterminate(object):
    def __eq__(self, other):
        return other is self

@functools.total_ordering
class _Infinity(_Indeterminate):
    def __lt__(self, other):
        return False
    def __gt__(self, other):
        return True
    def __str__(self):
        return 'inf'
    __repr__ = __str__

@functools.total_ordering
class _NegativeInfinity(_Indeterminate):
    def __lt__(self, other):
        return True
    def __gt__(self, other):
        return False
    def __str__(self):
        return '-inf'

INFINITY = _Infinity()
NEGATIVE_INFINITY = _NegativeInfinity()

不幸的是，当在cmp（）操作的左侧时，这对datetime对象不起作用：

In [1]: from rangeset import *
In [2]: from datetime import datetime
In [3]: now = datetime.now()
In [4]: cmp(INFINITY, now)
Out[4]: 1
In [5]: cmp(now, INFINITY)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/home/axiak/Documents/rangeset/<ipython-input-5-c928d3687d92> in <module>()
----> 1 cmp(now, INFINITY)

TypeError: can't compare datetime.datetime to _Infinity

我曾希望通过使用cmp包装器来解决这个限制，这只能确保我的对象始终被调用，但我真的想使用.sort()方法，这将导致在这些对象之间调用cmp

有没有办法创建一个真正小于任何其他对象的对象，并且真正比任何其他对象更大？

模块主页：https://github.com/axiak/py-rangeset

Answer 1

来自docs

的

为了阻止比较回落到默认方案比较对象地址，日期比较通常会引发TypeError 如果另一个comparand也不是日期对象。然而，如果另一个comparand有一个，则返回NotImplemented timetuple（）属性。

因此，为了与datetime对象进行比较，可以添加timetuple方法，例如

class _Infinity(object):

    def __lt__(self, other):
        return False

    def __gt__(self, other):
        return True

    def timetuple(self):
        return tuple()

import datetime
INF = _Infinity()
now = datetime.datetime.now()
print cmp(INF, now)
print cmp(now, INF)

输出：

1    
-1

Answer 2

我不太确定，但尝试覆盖__eq__和__ne__（或__cmp__）以查看是否在您执行cmp时调用它们。您还应该知道cmp和__cmp__已从python 3中删除。

Answer 3

问题是cmp(now, INFINITY)等同于datetime.__cmp__(INFINITY)，它直接在datettime类上定义。你可以通过猴子修补dateetime模块来解决这个问题，但那确实是个hackish。

我认为你真正想要的只是一个排序功能，它考虑到你的课程，并且总是根据无限的符号将它放在前面或后面。

def order(x, y):
    if isinstance(x,_Infinity):
        return -1
    if isinstance(y, _Infinity):
        return 1
    elif isinstance(x, _NegativeInfinity):
        return 1
    elif isinstance(y, _NegativeInfinity):
         return -1
    else:
        return cmp(x,y)

>>> sorted([datetime.datetime.now(), datetime.datetime.now(), INFINITY, NEGATIVE_INFINITY], cmp=order)
[ 
    NEGATIVE_INFINITY, 
    datetime.datetime(2011, 12, 8, 13, 38, 47, 428626),
    datetime.datetime(2011, 12, 8, 13, 38, 47, 428661),
    INFINITY
]

在python中为任何对象创建无穷大和负无穷大

3 个答案: