Question

看到this question之后，我开始想知道：是否可以编写一个行为的类，就像一个随机整数？

我设法找到了dir()的一些可覆盖的方法：

class RandomInt(int):
    def __add__(self, other):
        return randint(1, 100) + other

    def __mul__(self, other):
        return randint(1, 100) * other

    def __div__(self, other):
        return randint(1, 100) / other

    def __sub__(self, other):
        return randint(1, 100) - other

    def __repr__(self):
        return str(randint(1, 100))

但我觉得有一种更优雅的方法可以将randint(1, 100)注入到接受self参数的每个方法中。

如果没有从头开始重写整个int类，有没有办法做到这一点？

类似的东西：

>>> x = RandomInt()
>>> x + 1
2
>>> x + 1
74
>>> x * 4
152

Answer 1

这是一个不同的答案，因为它与我发布的另一个非常不同。（我觉得这应该是分开的）

守则：

class RandomInt:
    def __getattr__(self, name):
        attr = getattr(int, name, '')
        if attr != '':
            def wrapper(*args, **kw):
                return attr(random.randint(1, 100), *args, **kw)
            return wrapper
        else:
            raise AttributeError(
                    "'{0}' object has no attribute '{1}'".format('RandomInt',name))

示例运行：

>>> x = RandomInt()
>>> x
88
>>> 1 + x # __radd__
67
>>> x*100 # __mul__
1900
>>> x+5 # __add__
50
>>> x-1000 # __sub__
-945
>>> x//5 # __floordiv__
8
>>> float(x) # __float__
63.0
>>> str(x) # __str__
'75'
>>> complex(x) # __complex__
(24+0j)
>>> sum([x]*10)
573

有改进的余地：

>>> x + x

Traceback (most recent call last):
  File "<pyshell#1456>", line 1, in <module>
    x + x
TypeError: unsupported operand type(s) for +: 'instance' and 'instance'

x*x，x/x和类似的

相同

这次是另一个版本，类似于@gatto's回答：

import random, inspect

class RandomInt:
    def __init__(self):
        def inject(attr):
            def wrapper(*args, **kw):
                args = list(args)
                for i,x in enumerate(args):
                    if isinstance(x, RandomInt):
                        args[i] = x+0
                return attr(random.randint(1,100), *args, **kw)
            return wrapper

        for name in dir(int):
            attr = getattr(int, name)
            if inspect.ismethoddescriptor(attr):
                setattr(self, name, inject(attr))

这个支持：

>>> x + x
49
>>> x // x
2
>>> x * x
4958
>>> x - x
77
>>> x ** x
467056167777397914441056671494001L
>>> float(x) / float(x)
0.28

又一个版本，它使用类属性来克服新式/旧式问题（感谢@gatto）：

import random, inspect

class RandomInt(object):
    pass

def inject(attr):
    def wrapper(*args, **kw):
        args = list(args)
        for i,x in enumerate(args):
            if isinstance(x, RandomInt):
                args[i] = random.randint(1,100)
        return attr(*args, **kw)
    return wrapper

for name in dir(int):
    attr = getattr(int, name)
    if inspect.ismethoddescriptor(attr):
        setattr(RandomInt, name, inject(attr))

输出：

>>> x
86
>>> x
22
>>> x * x
5280
>>> [1] * x
[1, 1, 1, 1, 1, 1]
>>> x * '0123'
'0123012301230123'
>>> s[x] # s = '0123456789' * 10
'5'

Answer 2

import inspect
from random import randint

class SelfInjecter(type):
    def __new__(self, *args, **kw):
        cls = type(*args, **kw)
        factory = cls.__factory__

        def inject(attr):
            def wrapper(self, *args, **kw):
                return attr(factory(self), *args, **kw)
            return wrapper

        for name in dir(cls):
            attr = getattr(cls, name)

            if inspect.ismethoddescriptor(attr):
                setattr(cls, name, inject(attr))

        return cls

class RandomInt(int):
    __metaclass__ = SelfInjecter
    __factory__ = lambda self: randint(1, 100)

x = RandomInt()
print x + 3, x - 3, x * 3, repr(x)

上面的代码有一些问题。

正如Schoolboy所建议的那样，以下内容无效：

>>> print x * x
0

如果可能，我们需要将所有参数转换为新类型RandomInt：

def factory(x):
    if isinstance(x, cls):
        return cls.__factory__(x)
    return x

def inject(attr):
    def wrapper(*args, **kw):
        args = [factory(x) for x in args]
        kw = {k: factory(v) for k, v in kw}
        return attr(*args, **kw)

    return wrapper

序列乘法和索引也不能按预期工作：

>>> [1] * x, x * '123', '123'[x]
([], '', '1')

这是因为Python没有将__index__用于int - 继承类型：

class Int(int):
    def __index__(self):
        return 2

>>> x = Int(1)
>>> '012'[x], '012'[x.__index__()]
('1', '2')

以下是Python 2.7.4实现的代码：

/* Return a Python Int or Long from the object item
   Raise TypeError if the result is not an int-or-long
   or if the object cannot be interpreted as an index.
*/
PyObject *
PyNumber_Index(PyObject *item)
{
    PyObject *result = NULL;
    if (item == NULL)
        return null_error();
    if (PyInt_Check(item) || PyLong_Check(item)) {
        Py_INCREF(item);
        return item;
    }
    if (PyIndex_Check(item)) {
        result = item->ob_type->tp_as_number->nb_index(item);
        if (result &&
            !PyInt_Check(result) && !PyLong_Check(result)) {
            PyErr_Format(PyExc_TypeError,
                         "__index__ returned non-(int,long) " \
                         "(type %.200s)",
                         result->ob_type->tp_name);
            Py_DECREF(result);
            return NULL;
        }
    }

如您所见，它首先检查int和long，然后才尝试拨打__index__。

解决方案是继承object并从int克隆/包装属性，或实际上我更喜欢Schoolboys's answer，我想它也可以以类似的方式进行纠正。< / p>

Answer 3

一个想法是使用__call__方法，返回一个随机数。

class RandomInt(int):
    def __call__(self):
        return random.randint(1, 100)
    def __add__(self, other):
        return self() + other

    def __mul__(self, other):
        return self() * other

    def __div__(self, other):
        return self() / other

    def __sub__(self, other):
        return self() - other

    def __repr__(self):
        return str(self())

示例运行

>>> x = RandomInt()
>>> x * 3
81
>>> x + 3
56
>>> x - 4
68
>>> x / 4
2

Answer 4

您可以在运行时附加方法：

def add_methods(*names):
    def the_decorator(cls):
        for name in names:
            def the_function(self, other):
                 return cls(random.randint(0, 100))
            setattr(cls, name, the_function)
        return cls
    return the_decorator


@add_methods('__add__', '__mul__', '__sub__')
class RandomInt(int):
    pass

这允许您选择应该随机采取的方法。

请注意，您可能会尝试使用__getattr__或__getattribute__之类的内容来自定义属性的访问方式，并避免在类中明确设置方法，但这不适用于特殊方法，自从他们查询does not pass through the attribute-access methods。

随机化整数行为

4 个答案: