Is it possible to define a data object in python that behaves like a normal integer when used in mathematical operations or comparisons, but is also able to store instance variables?
In other words, it should be possible to do the following things:
pseudo_integer = PseudoInteger(5, hidden_object="Hello World!")
print(5 + pseudo_integer) # Prints "10"
print(pseudo_integer == 5) # Prints "True"
print(pseudo_integer.hidden_object) # Prints "Hello World!"
So, all answers above are fine, but probably you don't want to re-define all existing methods.
Normally, in python you can just subclass any built-in class (type). But with immutable types (and integers in python are immutable) is slightly tricky. TL;DR:
class PseudoInt(int):
def __new__(cls, x, hidden, *args, **kwargs):
instance = int.__new__(cls, x, *args, **kwargs)
instance.hidden = hidden
return instance
x = PseudoInt(5, 'secret')
x.hidden # 'secret'
x + 4 # 9
x * 3 # 15
Normally, you should reload __init__ method, but with immutable bases you should use __new__. You can read more about data model in corresponding docs section
All this is viable only if you need single signature for constructing your object. If its fine to have 1 call for creating, and dedicated calls to populate object with attributes - Kevin's answer is all you need
__add__ if they want the result of PseudoInt(5) + 3 to be a PseudoInt.
PseudoInt(5) += 4 will return 9. But I guess, this is what OP wanted - int-like object. To return same class with math ops, __ methods should be reloaded, you're right.PseudoInt(5) += 4 would be a SyntaxError! </nitpick>Yes, it is. You can create your own custom class. Python has many magic methods to help you archive that.
Check the code:
class PseudoInteger:
def __init__(self, x, s):
self.x = x
self.s = s
def __add__(self, num):
return self.x + num
def __eq__(self, num):
return self.x == num
a = PseudoInteger(5, 'hello, world')
print(a + 3)
print(a == 5)
print(a == 2)
Or you can just inherit from int, after creating an instance, you are able to assign attributes to the inherited int object. You can't assign attributes to int directly, because int does not support item assignment :
class PseudoInteger(int):
pass
a = PseudoInteger(5)
a.hidden = 'hello, world'
print(a)
print(a == 5)
print(a + 3)
print(a.hidden)
You simply need a class for this:
class PseudoInteger(object):
def __init__(self, num, hidden=None):
self.num = num
self.hidden = hidden
def __add__(self, otherVal):
if isinstance(otherVal, PseudoInteger):
return self.num + otherVal.num
else:
return self.num + otherVal
p = PseudoInteger(4, 'Tiger')
q = PseudoInteger(6, 'lion')
print (p+q)
print (p+4)
This prints out:
10
8
You have to add the other operations (division, substraction, eq, ...) you need to the class on your own :)
hidden_objectto be, after a addition ?hidden_objectafter an addition, so it's okay if it's gone. I just need it to either be able to be added, compared orhidden_objectto be obtained.5 + pseudo_integerto have? Should it have typeint, or typePseudoInteger? What aboutpseudo_integer + pseudo_integer?