Why are there no ++ and --​ operators in Python?

Other answers have described why it's not needed for iterators, but sometimes it is useful when assigning to increase a variable in-line, you can achieve the same effect using tuples and multiple assignment:

b = ++a becomes:

a,b = (a+1,)*2

and b = a++ becomes:

a,b = a+1, a

Python 3.8 introduces the assignment := operator, allowing us to achievefoo(++a) with

foo(a:=a+1)

foo(a++) is still elusive though.

I think this relates to the concepts of mutability and immutability of objects. 2,3,4,5 are immutable in python. Refer to the image below. 2 has fixed id until this python process.

x++ would essentially mean an in-place increment like C. In C, x++ performs in-place increments. So, x=3, and x++ would increment 3 in the memory to 4, unlike python where 3 would still exist in memory.

Thus in python, you don't need to recreate a value in memory. This may lead to performance optimizations.

This is a hunch based answer.

I know this is an old thread, but the most common use case for ++i is not covered, that being manually indexing sets when there are no provided indices. This situation is why python provides enumerate()

Example : In any given language, when you use a construct like foreach to iterate over a set - for the sake of the example we'll even say it's an unordered set and you need a unique index for everything to tell them apart, say

i = 0
stuff = {'a': 'b', 'c': 'd', 'e': 'f'}
uniquestuff = {}
for key, val in stuff.items() :
  uniquestuff[key] = '{0}{1}'.format(val, i)
  i += 1

In cases like this, python provides an enumerate method, e.g.

for i, (key, val) in enumerate(stuff.items()) :

This is not the answer, (just a log from me) but I believe: it should be there.

It is true that there is a python way of doing things and it is not needed for loop counters, However: there are few cases where one needs to manipulate other variable besides the one which is looping.

Looking at views for this thread.. there definitely is a use case.

We need lobbying to get this feature in... although I don't see that fructifying for a long long time. In the mean time: is there a way to do operator overloading to imitate ++?

In addition to the other excellent answers here, ++ and -- are also notorious for undefined behavior. For example, what happens in this code?

foo[bar] = bar++;

It's so innocent-looking, but it's wrong C (and C++), because you don't know whether the first bar will have been incremented or not. One compiler might do it one way, another might do it another way, and a third might make demons fly out of your nose. All would be perfectly conformant with the C and C++ standards.

Undefined behavior is seen as a necessary evil in C and C++, but in Python, it's just evil, and avoided as much as possible.