Behaviour of increment and decrement operators in Python

1,282,292

Solution 1

++ is not an operator. It is two + operators. The + operator is the identity operator, which does nothing. (Clarification: the + and - unary operators only work on numbers, but I presume that you wouldn't expect a hypothetical ++ operator to work on strings.)

++count

Parses as

+(+count)

Which translates to

count

You have to use the slightly longer += operator to do what you want to do:

count += 1

I suspect the ++ and -- operators were left out for consistency and simplicity. I don't know the exact argument Guido van Rossum gave for the decision, but I can imagine a few arguments:

  • Simpler parsing. Technically, parsing ++count is ambiguous, as it could be +, +, count (two unary + operators) just as easily as it could be ++, count (one unary ++ operator). It's not a significant syntactic ambiguity, but it does exist.
  • Simpler language. ++ is nothing more than a synonym for += 1. It was a shorthand invented because C compilers were stupid and didn't know how to optimize a += 1 into the inc instruction most computers have. In this day of optimizing compilers and bytecode interpreted languages, adding operators to a language to allow programmers to optimize their code is usually frowned upon, especially in a language like Python that is designed to be consistent and readable.
  • Confusing side-effects. One common newbie error in languages with ++ operators is mixing up the differences (both in precedence and in return value) between the pre- and post-increment/decrement operators, and Python likes to eliminate language "gotcha"-s. The precedence issues of pre-/post-increment in C are pretty hairy, and incredibly easy to mess up.

Solution 2

Python does not have pre and post increment operators.

In Python, integers are immutable. That is you can't change them. This is because the integer objects can be used under several names. Try this:

>>> b = 5
>>> a = 5
>>> id(a)
162334512
>>> id(b)
162334512
>>> a is b
True

a and b above are actually the same object. If you incremented a, you would also increment b. That's not what you want. So you have to reassign. Like this:

b = b + 1

Many C programmers who used python wanted an increment operator, but that operator would look like it incremented the object, while it actually reassigns it. Therefore the -= and += operators where added, to be shorter than the b = b + 1, while being clearer and more flexible than b++, so most people will increment with:

b += 1

Which will reassign b to b+1. That is not an increment operator, because it does not increment b, it reassigns it.

In short: Python behaves differently here, because it is not C, and is not a low level wrapper around machine code, but a high-level dynamic language, where increments don't make sense, and also are not as necessary as in C, where you use them every time you have a loop, for example.

Solution 3

While the others answers are correct in so far as they show what a mere + usually does (namely, leave the number as it is, if it is one), they are incomplete in so far as they don't explain what happens.

To be exact, +x evaluates to x.__pos__() and ++x to x.__pos__().__pos__().

I could imagine a VERY weird class structure (Children, don't do this at home!) like this:

class ValueKeeper(object):
    def __init__(self, value): self.value = value
    def __str__(self): return str(self.value)

class A(ValueKeeper):
    def __pos__(self):
        print 'called A.__pos__'
        return B(self.value - 3)

class B(ValueKeeper):
    def __pos__(self):
        print 'called B.__pos__'
        return A(self.value + 19)

x = A(430)
print x, type(x)
print +x, type(+x)
print ++x, type(++x)
print +++x, type(+++x)

Solution 4

TL;DR

Python does not have unary increment/decrement operators (--/++). Instead, to increment a value, use

a += 1

More detail and gotchas

But be careful here. If you're coming from C, even this is different in python. Python doesn't have "variables" in the sense that C does, instead python uses names and objects, and in python ints are immutable.

so lets say you do

a = 1

What this means in python is: create an object of type int having value 1 and bind the name a to it. The object is an instance of int having value 1, and the name a refers to it. The name a and the object to which it refers are distinct.

Now lets say you do

a += 1

Since ints are immutable, what happens here is as follows:

  1. look up the object that a refers to (it is an int with id 0x559239eeb380)
  2. look up the value of object 0x559239eeb380 (it is 1)
  3. add 1 to that value (1 + 1 = 2)
  4. create a new int object with value 2 (it has object id 0x559239eeb3a0)
  5. rebind the name a to this new object
  6. Now a refers to object 0x559239eeb3a0 and the original object (0x559239eeb380) is no longer refered to by the name a. If there aren't any other names refering to the original object it will be garbage collected later.

Give it a try yourself:

a = 1
print(hex(id(a)))
a += 1
print(hex(id(a)))

Solution 5

Python does not have these operators, but if you really need them you can write a function having the same functionality.

def PreIncrement(name, local={}):
    #Equivalent to ++name
    if name in local:
        local[name]+=1
        return local[name]
    globals()[name]+=1
    return globals()[name]

def PostIncrement(name, local={}):
    #Equivalent to name++
    if name in local:
        local[name]+=1
        return local[name]-1
    globals()[name]+=1
    return globals()[name]-1

Usage:

x = 1
y = PreIncrement('x') #y and x are both 2
a = 1
b = PostIncrement('a') #b is 1 and a is 2

Inside a function you have to add locals() as a second argument if you want to change local variable, otherwise it will try to change global.

x = 1
def test():
    x = 10
    y = PreIncrement('x') #y will be 2, local x will be still 10 and global x will be changed to 2
    z = PreIncrement('x', locals()) #z will be 11, local x will be 11 and global x will be unaltered
test()

Also with these functions you can do:

x = 1
print(PreIncrement('x'))   #print(x+=1) is illegal!

But in my opinion following approach is much clearer:

x = 1
x+=1
print(x)

Decrement operators:

def PreDecrement(name, local={}):
    #Equivalent to --name
    if name in local:
        local[name]-=1
        return local[name]
    globals()[name]-=1
    return globals()[name]

def PostDecrement(name, local={}):
    #Equivalent to name--
    if name in local:
        local[name]-=1
        return local[name]+1
    globals()[name]-=1
    return globals()[name]+1

I used these functions in my module translating javascript to python.

Share:
1,282,292
Markus Joschko
Author by

Markus Joschko

I work with GPUs on deep learning and computer vision.

Updated on July 08, 2022

Comments

  • Markus Joschko
    Markus Joschko over 1 year

    I notice that a pre-increment/decrement operator can be applied on a variable (like ++count). It compiles, but it does not actually change the value of the variable!

    What is the behavior of the pre-increment/decrement operators (++/--) in Python?

    Why does Python deviate from the behavior of these operators seen in C/C++?

  • newacct
    newacct over 14 years
    "The + operator is the "identity" operator, which does nothing." Only for numeric types; for other type it is an error by default.
  • visual_learner
    visual_learner over 14 years
    Right. But then again, ++ and -- should only be expected to work on numeric types.
  • Ned Deily
    Ned Deily over 14 years
    Also, be aware that, in Python, += and friends are not operators that can be used in expressions. Rather, in Python they are defined as part of an "augmented assignment statement". This is consistent with the language design decision in Python to not allow assignment ("=") as an operator within arbitrary expressions, unlike what one can do in C. See docs.python.org/reference/…
  • u0b34a0f6ae
    u0b34a0f6ae over 14 years
    The unary + operator has a use. For decimal.Decimal objects, it rounds to current precision.
  • Markus Joschko
    Markus Joschko over 14 years
    Kaizer, that is an odd use for +. Any idea why Python does that for decimal.Decimal objects?
  • Markus Joschko
    Markus Joschko over 14 years
    Chris, thanks so much for this detailed answer! I learnt a lot just by reading and understanding your explanation :-)
  • user2365801
    user2365801 about 14 years
    That example is wrong (and you're probably confusing immutability with identity) - they have the same id due to some vm optimization that uses the same objects for numbers till 255 (or something like that). Eg (bigger numbers): >>> a = 1231231231231 >>> b = 1231231231231 >>> id(a), id(b) (32171144, 32171168)
  • Mike DeSimone
    Mike DeSimone over 13 years
    I'm betting on parser simplification. Note an item in PEP 3099, "Things that will Not Change in Python 3000": "The parser won't be more complex than LL(1). Simple is better than complex. This idea extends to the parser. Restricting Python's grammar to an LL(1) parser is a blessing, not a curse. It puts us in handcuffs that prevent us from going overboard and ending up with funky grammar rules like some other dynamic languages that will go unnamed, such as Perl." I don't see how to disambiguate + + and ++ without breaking LL(1).
  • Mechanical snail
    Mechanical snail over 12 years
    The immutability claim is spurious. Conceptually, i++ would mean to assign i + 1 to the variable i. i = 5; i++ means to assign 6 to i, not modify the int object pointed to by i. That is, it does not mean to increment the value of 5!
  • Lennart Regebro
    Lennart Regebro over 12 years
    @Mechanical snail: In which case it would not be increment operators at all. And then the += operator is clearer, more explicit, more flexible and does the same thing anyway.
  • Mechanical snail
    Mechanical snail over 12 years
    @LennartRegebro: In C++ and Java, i++ only operates on lvalues. If it were intended to increment the object pointed to by i, this restriction would be unnecessary.
  • visual_learner
    visual_learner about 12 years
    This must be the reference question that all other "why doesn't Python have ++ operators?" questions get closed as duplicates of, because this answer accounts for 4% of my reputation.
  • charleslparker
    charleslparker about 11 years
    Immutability is indeed irrelevant in this case. Consider: Clojure has a built-in increment operator and all data structures are immutable by default. While it's true you get a new reference to the new value, that's mostly orthogonal to the purely syntactic choice of ++ vs. += 1.
  • Basic
    Basic over 10 years
    This answer is correct so +1 but this is just another one of those annoyances with Python that have made me come to really dislike it. strip() instead of trim() like every other languages, no switches, some OO functions and some not (len(s) vs s.lower()). Very frustrating and inconsistent language
  • Lennart Regebro
    Lennart Regebro over 10 years
  • ArtOfWarfare
    ArtOfWarfare over 10 years
    For anyone who was, like me, at a loss as to what the purpose of the unary + operator is, it's the opposite of the unary - operator. What is -1? It's negative one. What is +1? It's positive one. What is +(+1)? It's still positive one. Feel stupid for having wondered now? Me too.
  • CivFan
    CivFan almost 9 years
    @Basic the beauty of python's built-in functions, such as len(), is they usually map to a method in the object, allowing you to override or give power to the built-in's for any of your own classes -- s.__len__() in this case.
  • Basic
    Basic almost 9 years
    @CivFan Why is that any more desirable than inheriting from an object that has a length method/property that can be overridden? As far as I can see, it simply adds a layer of indirection for no tangible benefit
  • CivFan
    CivFan almost 9 years
    @Basic But.. that's precisely what's happening. This leads into something else beautiful about python, a public, private, protected method scheme enforced by consistent coding style, rather than strictly enforced. s.__len__() is there when you really want to override it, but hidden away not cluttering the vast majority of classes that have no need for it.
  • Basic
    Basic almost 9 years
    @CivFan then a) __len__() isn't really private, it's just public but called via indiretion and b) we now need to know all the global methods that call the private methods when the object could've just had a length() method which could be overriden if desired.
  • CivFan
    CivFan almost 9 years
    @Basic precisely on both accounts! __len__() is not really private, but looks like it when you don't need it, and only there when you need it. When you introspect an object for useful methods, you don't end up finding an undefined length() and a hundred other undefined built-in methods. But that one time you do, it's still there under the covers. I need a drink. ;)
  • Basic
    Basic almost 9 years
    @CivFan I think we'll have to agree to disagree, I still think it looks like noise and breaks OO principles for little benefit, if any. For all that, I need a drink too. Have a nice weekend
  • Nick Mertin
    Nick Mertin over 8 years
    'Python likes to eliminate language "gotcha"-s' - isn't this a language gotcha?
  • maharshi
    maharshi over 7 years
    how to increment/decrement a recordset ? link
  • PhilHibbs
    PhilHibbs almost 7 years
    It's not correct to say that ++ is nothing more than a synonym for += 1. There are pre-increment and post-increment variants of ++ so it is clearly not the same thing. I agree with the rest of your points, though.
  • Jimmy
    Jimmy over 6 years
    Just for this, your are my idol: "C compilers were stupid and didn't know how to optimize a += 1"
  • Admin
    Admin about 6 years
    Each to their own. I use ++ and -- all the time and don't end up messing anything up. Python is an OK language, but it has many flaws and I find the community over religious about various language constructs. Its a tool, not the Mona Lisa. Lets get the job done and move on to the next task ... which will most probably be written in R, or Matlab or C++
  • Benoît P
    Benoît P about 5 years
    To future-proof @NedDeily's highly up-voted remark on assignments, Python 3.8 allows assignment nearly anywhere with the new := operator.
  • Adam
    Adam almost 5 years
    Note: while great, these helper methods will not work if your locals exist on class function stack frame. i.e - calling them from within a class method def will not work - the 'locals()' dict is a snapshot, and does not update the stack frame.
  • Zertrin
    Zertrin over 4 years
    Interestingly, this restriction will be lifted in the upcoming release Python 3.8 with the new syntax for Assignment expressions (PEP-572 python.org/dev/peps/pep-0572). We will be able to write if (n := len(a)) > 10: y = n + 1 for example. Note that the distinction is clear because of the introduction of a new operator for that purpose (:=)
  • Daniel B.
    Daniel B. about 4 years
    What does this say that other answers don't?
  • Optider
    Optider about 4 years
    @DanielB. Other answers haven't told what happens internally. And, neither they have told what will happen when you will write -----count.
  • Optider
    Optider about 4 years
    There isn't any mention that multiplication is being carried out, so I thought a consice and to the point answer would be useful for fellow users. No offense if you understood from that. Learning is more important than the source where you learn from.
  • thiagola92
    thiagola92 over 3 years
    Greate answer! Just one suggestion: a++ would increment but return the old value, (a:=a+1) is more like an ++a that would increment and return the new value.
  • Manuel Alves
    Manuel Alves over 3 years
    "why does Python even have this unary operator? It exists only to complement the – operator if you need to overload these operators for your own classes. (See the documentation for the pos special method.)" From: inventwithpython.com/blog/2018/05/21/…
  • Tony Suffolk 66
    Tony Suffolk 66 about 3 years
    apart from the fact that small integers are 'interned', so they will never be garbage collected.
  • ingyhere
    ingyhere about 3 years
    But can you do (a:+=1)?
  • Henry
    Henry about 3 years
    @ingyhere no, it's an syntax error because '+=' is an operation between 2 object (iadd), you can't assigne an syntaxe operation to an variable
  • Martijn Pieters
    Martijn Pieters over 2 years
    Moderator note: Comments are not for extended discussion. Please use chat for that.
  • Fosfor
    Fosfor about 2 years
    -1, the lambda workaround works just once - it always return 1. And the search&replace also doesn't work for all cases - consider if (c++): ...
  • Spike0xff
    Spike0xff about 2 years
    What you're calling 'names' are commonly called variables (including by Mr Rossum) across programming languages. They may have different scope and lifetime and more relaxed typing rules in dynamic languages like Python (Lisp, JavaScript, Lua, etc.) As @TonySuffolk66 points out, they aren't actually always references to GC'able objects - and a C/C++ variable may hold a reference to an object, and as in Python, such an object may be shared between variables, and GC'd when there are no more references to it.
  • Tony Suffolk 66
    Tony Suffolk 66 about 2 years
    You are correct that Guido talks about variables, but when you look at any documentation that looks at the internal semantics you will see that the details talk about names bound to objects. It is a minor distinction for most developers but an important one when you start talking about the impact on objects of operations.