In Python, what does "x = 5" really do/mean?

Hi,

I'm a great scripter, but just learning programming (using Python).

I'm very much a newbie at this, so please be patient as I'm sure these will seem so basic a questions and may seem stupid to those experienced.

I'm reading a python book right now that has me thinking about variables.

As the title says, what does "x=5" really mean?

What is the "5" being assigned to? Is "x" considered an "instance" of "int?"

If I do this:

>>> class test(int):
    pass

>>> x=test(5)
>>> x
5
>>> 

Then x here is an instance of class test(), a subclass of int.

But with int, you can do x=5.

If I do that after the above code, then x is no longer an instance of test() but is a variable of type int().

In the above, what is the 5 actually being assigned to in the instance of test()?

I have accessed it by defining a class and doing this just messing around:

>>> class test2(int):
    def value(self):
        print self
        self += 1
        print self

        
>>> x=test2(5)
>>> x
5
>>> x.value()
5
6
>>> x
5

Why doesn't the value of x change to 6 in the above example? I'm I "redefining" self in the value() method to no longer reflect what is self in the instance?

Also, can I "hijack" what x=5 means to to add my own methods, but it still behave like x=5. What I mean might be explained by this code:

#do whatever code here to "hijack" int()

>>> x=5
>>> x
5
>>> x.make_negative
>>> x
-5
>>> x=-2
>>> x
-2
>>> x.make_negative
>>> x
2

Or something like that?

If there is no way to do that and we go back to my original subclass definition, how do I change the value of the instance of the class to another value?

In:

>>> x=5
>>> x += 1
>>> x
6

How does the value of x become incremented internally? What magic is happening behind the scenes?

Say I want to do what is verboten in Python. Make in C-like incrementor like this.

>>> class Incrementor(int):
    def incAfter (self): # equivalent of x++
        #do whatever to access the value of instance
        return VALUE_OF_INSTANCE # as in x=Incrementor(5)
        VALUE_OF_INSTANCE += 1 # not quite sure how to do this to make it increment after returning the value (perhaps it is imporssible). Help here would be appreciated, too.
    def incBefore(self): # equivalent of ++x
        VALUE_OF_INSTANCE += 1
        return VALUE_OF_INSTANCE # as in x=Incrementor(5)

So that I could do something like this:

>>> x = Incrementor(5)
>>> x
5
>>> print x.incAfter()
5
>>> x
6
>>> print x.incBefore()
7
>>> x
7

Helping me with the concepts would really go a long way for me. Any help would be greatly appreciated.

Thankfully,
Narnie

If you read up on the Python Data Model, you will see that numbers (actually all numerics) are implemented as an immutable (aka. not-changeable) type. This would mean that you could never (using Python numerics) implement something such that 2+2=5 (for all extremely large values of 2 :p)

No magic really. What is happening (even with your shorthand) is a replacement operator. The right side is evaluated, and then the left side is re-pointed to the new value (so the old value is essentially lost). You have to watch out when you use this though, because the immutable/mutable types each act differently... Read this for more info...

It depends on how far you are willing to go to get a "proper solution". If you want to use the "++" or "--" in-line in Python, be prepared to write the extension in C/C++ and to recompile Python just for you. You would basically be writing "object.__iplusplus__" (or something pretty close) - Again reference the Data Model to give you an idea where to look in the Python Source.

Either way you head, I applaud you for not jumping ship at the whitespace-strictness.

Thanks. I thought it likely had to do with the fact the int, str, etc are immutable, but lists, dictionaries are mutable. This clarifies that thinking.

As far as the last comment, HAHA!!! I'm just beginning to wrap my head around Python. No way do I want to write a C/C++ extension! BECAUSE I COULDN'T, hehe. Actually being able to right x++ or ++x to increment isn't important to me.

I have since learned about __call__ and __repr__ methods. I would nave loved to be able to make an int-like variable be assigned where I could just go x=5. Then when I needed to go x.incAfter (for x++) or x.incBefore (for ++x). I think I have realized that isn't possible.

What I have (with some help from others) figured out is:

class Incrementor(object):
    def __init__(self, value=0):
        self.__value = value

    def __call__(self):
        print self.__value

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

    def incAfter(self):
        oldvalue = self.__value
        self.__value += 1
        return oldvalue

    def incBefore(self):
        self.__value += 1
        return self.__value

then it works the way I envisioned:

>>> x = Incrementor(5)
>>> x
5
>>> x.incAfter()
5
>>> x
6
>>> print x.incBefore()
7
>>> x
7
>>> print x.incAfter()
7
>>> x
8
>>> 

Works ok for me and was a great teaching tool/exercise.

Cheerio,
Narnie