Behaviour of increment and decrement operators in Python
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 optimizea += 1
into theinc
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 int
s 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 int
s are immutable, what happens here is as follows:
- look up the object that
a
refers to (it is anint
with id0x559239eeb380
) - look up the value of object
0x559239eeb380
(it is1
) - add 1 to that value (1 + 1 = 2)
- create a new
int
object with value2
(it has object id0x559239eeb3a0
) - rebind the name
a
to this new object - Now
a
refers to object0x559239eeb3a0
and the original object (0x559239eeb380
) is no longer refered to by the namea
. 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.
Markus Joschko
I work with GPUs on deep learning and computer vision.
Updated on July 08, 2022Comments
-
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 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 over 14 yearsRight. But then again,
++
and--
should only be expected to work on numeric types. -
Ned Deily over 14 yearsAlso, 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 over 14 yearsThe unary
+
operator has a use. For decimal.Decimal objects, it rounds to current precision. -
Markus Joschko over 14 yearsKaizer, that is an odd use for +. Any idea why Python does that for decimal.Decimal objects?
-
Markus Joschko over 14 yearsChris, thanks so much for this detailed answer! I learnt a lot just by reading and understanding your explanation :-)
-
user2365801 about 14 yearsThat 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 over 13 yearsI'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 over 12 yearsThe immutability claim is spurious. Conceptually,
i++
would mean to assigni + 1
to the variablei
.i = 5; i++
means to assign6
toi
, not modify theint
object pointed to byi
. That is, it does not mean to increment the value of5
! -
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 over 12 years@LennartRegebro: In C++ and Java,
i++
only operates on lvalues. If it were intended to increment the object pointed to byi
, this restriction would be unnecessary. -
visual_learner about 12 yearsThis 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 about 11 yearsImmutability 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 over 10 years
-
Lennart Regebro over 10 years
-
ArtOfWarfare over 10 yearsFor 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 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 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 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 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 alength()
method which could be overriden if desired. -
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 undefinedlength()
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 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 over 8 years'Python likes to eliminate language "gotcha"-s' - isn't this a language gotcha?
-
maharshi over 7 yearshow to increment/decrement a recordset ? link
-
PhilHibbs almost 7 yearsIt'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 over 6 yearsJust for this, your are my idol: "C compilers were stupid and didn't know how to optimize a += 1"
-
Admin about 6 yearsEach 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 about 5 yearsTo future-proof @NedDeily's highly up-voted remark on assignments, Python 3.8 allows assignment nearly anywhere with the new
:=
operator. -
Adam almost 5 yearsNote: 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 over 4 yearsInterestingly, 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. about 4 yearsWhat does this say that other answers don't?
-
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 about 4 yearsThere 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 over 3 yearsGreate 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 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 about 3 yearsapart from the fact that small integers are 'interned', so they will never be garbage collected.
-
ingyhere about 3 yearsBut can you do
(a:+=1)
? -
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 over 2 yearsModerator note: Comments are not for extended discussion. Please use chat for that.
-
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 about 2 yearsWhat 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 about 2 yearsYou 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.