“int”对象在类中不可调用错误

Question

In python 2.7, I am writing a class called Zillion , which is to act as a counter for very large integers. I believe I have it riddled out, but I keep running into TypeError: 'int' object is not callable , which seems to mean that at some point in my code I tried to call an int like it was a function. Many of the examples I found on this site were simply a mathematical error where the writer omitted an operator. I can't seem to find my error.

Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    z.increment()
TypeError: 'int' object is not callable

My code:

class Zillion:
    def __init__(self, digits):
        self.new = []
        self.count = 0 # for use in process and increment
        self.increment = 1 # for use in increment
        def process(self, digits):
            if digits == '':
                raise RuntimeError
            elif digits[0].isdigit() == False:
                if digits[0] == ' ' or digits[0] == ',':
                    digits = digits[1:]
                else:
                    raise RuntimeError
            elif digits[0].isdigit():
                self.new.append(int(digits[0]))
                digits = digits[1:]
                self.count += 1
            if digits != '':
                    process(self, digits)
        process(self, digits)
        if self.count == 0:
            raise RuntimeError

        self.new2 = self.new  # for use in isZero

    def toString(self):
        self.mystring =''
        self.x = 0
        while self.x < self.count:
            self.mystring = self.mystring + str(self.new[self.x])
            self.x += 1
        print(self.mystring)

    def isZero(self):
        if self.new2[0] != '0':
            return False
        elif self.new2[0] == '0':
            self.new2 = self.new2[1:]
            isZero(self)
        return True

    def increment(self):
        if self.new[self.count - self.increment] == 9:
            self.new[self.count - self.increment] = 0
            if isZero(self):
                self.count += 1
                self.new= [1] + self.new
            else:
                self.increment += 1
                increment(self)
        elif self.new[self.count - self.increment] != 9:
            self.new[self.count - self.increment] = self.new[self.count - self.increment] + 1

Answer 1

You have both an instance variable and a method named increment that seems to be your problem with that traceback at least.

in __init__ you define self.increment = 1 and that masks the method with the same name

To fix, just rename one of them (and if it's the variable name, make sure you change all the places that use it--like throughout the increment method)

One way to see what's happening here is to use type to investigate. For example:

>>> type(Zillion.increment)
<type 'instancemethod'>
>>> z = Zillion('5')
>>> type(z.incremenet)
<type 'int'>

Answer 2

You have defined an instance variable in Zillion.__init__()

def __init__(self, digits):
        self.new = []
        self.count = 0 
        self.increment = 1 # Here!

Then you defined a method with the same name 'Zillion.increment()`:

def increment(self):
    […]

So if you try to call your method like this:

big_number = Zillion()
big_number.increment()

.ìncrement will be the integer you have defined in .__init__() and not the method.

Answer 3

Because you have a variable member self.increment ，and it has been set to the 1 in your __init__ function.

z.increment represents the variable member which set to 1.

You can rename your function from increment to the _increment (or any other names), and it will works.