为什么Python调用__str__而不是返回long值

Question

我有一个简单的类，它扩展为接受带有值修饰符的字符串（即'10m'将是1024 * 1024 * 10）

我有__str__函数打印传入的原始值（即如果传入'10m'，则返回'10m'）

问题是，当我打电话时，如：

>>>  printf("%d" % Size('10m'))

我得到以下

SystemError: ../Objects/stringobject.c:4044: bad argument to internal function

显然，如果我打印"%s"，我会得到'10m'

所以问题是，因为我将子类化为long，为什么类应该在获取long值时调用__str__。

BTW，更多的测试显示%x和%f将打印整数值，这让我更加困惑。我还尝试添加__format__但似乎只在调用"...".format()时调用。

编辑＃1，这是代码：

class Size(long):
    '''Represents a size reflected bytes.  Subclass of long.
     Size passed in must be in the formats <int> or "0x<int>" or "0x<int><unit>" or "<int><unit>" or "<int><unit><int><unit>....".
     "0x<int><unit>0x<int><unit>" or similar numbers are not supported as is "<int><unit><int>"

    b = bytes
    s = sectors (512-byte)
    k = kilobytes
    m = megabytes
    g = gigabytes
    t = terabytes
    '''

    units = { 'b':1, 's':512, 'k':1024, 'm':1024 ** 2, 'g':1024 ** 3, 't':1024 ** 4 }

    def __new__(cls, value):
        '''Creates a Size object with the specified value.

        Value can be a number or a string (optionally prefixed with '0x' or
        postfixed with a type character).  If using hex, the final character
        will be treated as part of the value if it is a hex digit, regardless
        of whether it is a valid unit character.

        Examples:
           Size(50)
           Size("0x100s") # 256 sectors
           Size("64")
           Size("512k")
           Size("0x1b") # this is 1b bytes, not 1 byte
        '''
        self = _new_unit_number(value, cls.units, long, cls)
        return self

    def __init__(self, value):
        self._orig_value = value

    def __str__(self):
        print "calling str"
        return str(self._orig_value)  # Convert to str in case the object was created w/an int

    def __format__(self, format_spec):
        print "calling format"
        print format_spec
        try:
            value = format(str(self), format_spec)
        except ValueError:
            value = format(int(self), format_spec)
        return value

def _new_unit_number(value, unit_list, num_type, cls):
    '''Converts a string of numbers followed by a unit character to the
    requested numeric type (int or long for example).
    '''
    base = 10
    start = 0
    digits = string.digits
    try:
        if value[0:2] == '0x':
            start = 2
            base = 16
            digits = string.hexdigits

        if value[-1] in digits:
            return num_type.__new__(cls, value[start:], base)
        else:
            try:
                # Use a regex to split the parts of the unit
                regex_string = '(\d+[%s])' % (''.join(unit_list.keys()))
                parts = [x for x in re.split(regex_string, value[start:]) if x]

                if len(parts) == 1:
                    return num_type.__new__(cls, num_type(value[start:-1], base) * unit_list[value[-1]])
                else:
                    # Total up each part
                    # There's probably a better way to do this.
                    # This converts each unit to its base type, stores it in total,
                    # only to be converted back to the base type. 
                    total = 0
                    for part in parts:
                        total += num_type(part[start:-1], base) * unit_list[part[-1]]

                    # Finally return the requested unit
                    return num_type.__new__(cls, total)
            except KeyError:
                raise ValueError("Invalid %s unit identifier: %s"
                    % (cls.__name__, unit_list[value[-1]]))

    # not a string or empty, see if we can still use the class's constructor
    except (TypeError, IndexError):
        return num_type.__new__(cls, value)

Answer 1

不是答案，但评论的时间太长了。

我发现这个问题非常有趣。我尝试使用这个来复制行为：

#! /usr/bin/python2.7

class Size (long):
    def __new__ (cls, arg):
        if arg and type (arg) == str:
            if arg [-1] == 'm':
                return super (Size, cls).__new__ (cls, long (arg [:-1] ) * 2 ** 20)
        return super (Size, cls).__new__ (cls, arg)

    def __init__ (self, arg):
        self.s = arg

    def __str__ (self):
        return self.s

a = Size ('12m')
print (a)
print ('%s' % a)
#The following fails horribly
print ('%d' % a)

OP描述的行为。但现在有趣的是：当我从int继承而不是从long继承时，它运作顺利：

class Size (int):
    def __new__ (cls, arg):
        if arg and type (arg) == str:
            if arg [-1] == 'm':
                return super (Size, cls).__new__ (cls, int (arg [:-1] ) * 2 ** 20)
        return super (Size, cls).__new__ (cls, arg)

    def __init__ (self, arg):
        self.s = arg

    def __str__ (self):
        return self.s

也就是说，它在python2中工作正常，但在python3中失败。奇怪，奇怪。

Answer 2

请参阅Python问题跟踪器，Issue 18780: SystemError when formatting int subclass：

>>> class I(int):
...   def __str__(self):
...       return 'spam'
...
>>> '%d' % I(42)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
SystemError: Objects/unicodeobject.c:13305: bad argument to internal function

这适用于3.4.0alpha4，但不适用于3. [0123]。