Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

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

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

like image 390
Leonid Avatar asked Sep 06 '10 23:09

Leonid


People also ask

Does Python have ++ and --?

Python does not allow using the “(++ and –)” operators. To increment or decrement a variable in python we can simply reassign it. So, the “++” and “–” symbols do not exist in Python.

What is the purpose to use is & is not operator in Python?

is and is not are the identity operators in Python. They are used to check if two values (or variables) are located on the same part of the memory.

How do you use && in Python?

To use the and operator in Python, use the keyword and instead of && because there is no && operator in Python. If you use && operator in Python, you will get the SyntaxError. Likewise, || and ! are not valid Python operators. So instead, use or and not operator.

Why does ++ doesn't work in Python?

In C, C++, Java etc ++ and -- operators increment and decrement value of a variable by 1. In Python these operators won't work. In Python variables are just labels to objects in memory. In Python numeric objects are immutable.

What is the + operator in Python?

Python Operators Operators are used to perform operations on variables and values. In the example below, we use the + operator to add together two values:

Why is ++ not used in Python?

Python is a lot about clarity and no programmer is likely to correctly guess the meaning of --a unless s/he's learned a language having that construct. Python is also a lot about avoiding constructs that invite mistakes and the ++ operators are known to be rich sources of defects.

Why doesn't Python have increment and decrement operators?

First, Python is only indirectly influenced by C; it is heavily influenced by ABC, which apparently does not have these operators, so it should not be any great surprise not to find them in Python either. Secondly, as others have said, increment and decrement are supported by += and -= already.

Why is ++/--not used for integers in Python?

Because, in Python, integers are immutable (int's += actually returns a different object). Also, with ++/-- you need to worry about pre- versus post- increment/decrement, and it takes only one more keystroke to write x+=1.


2 Answers

It's not because it doesn't make sense; it makes perfect sense to define "x++" as "x += 1, evaluating to the previous binding of x".

If you want to know the original reason, you'll have to either wade through old Python mailing lists or ask somebody who was there (eg. Guido), but it's easy enough to justify after the fact:

Simple increment and decrement aren't needed as much as in other languages. You don't write things like for(int i = 0; i < 10; ++i) in Python very often; instead you do things like for i in range(0, 10).

Since it's not needed nearly as often, there's much less reason to give it its own special syntax; when you do need to increment, += is usually just fine.

It's not a decision of whether it makes sense, or whether it can be done--it does, and it can. It's a question of whether the benefit is worth adding to the core syntax of the language. Remember, this is four operators--postinc, postdec, preinc, predec, and each of these would need to have its own class overloads; they all need to be specified, and tested; it would add opcodes to the language (implying a larger, and therefore slower, VM engine); every class that supports a logical increment would need to implement them (on top of += and -=).

This is all redundant with += and -=, so it would become a net loss.

like image 106
Glenn Maynard Avatar answered Oct 21 '22 11:10

Glenn Maynard


This original answer I wrote is a myth from the folklore of computing: debunked by Dennis Ritchie as "historically impossible" as noted in the letters to the editors of Communications of the ACM July 2012 doi:10.1145/2209249.2209251


The C increment/decrement operators were invented at a time when the C compiler wasn't very smart and the authors wanted to be able to specify the direct intent that a machine language operator should be used which saved a handful of cycles for a compiler which might do a

load memory load 1 add store memory 

instead of

inc memory  

and the PDP-11 even supported "autoincrement" and "autoincrement deferred" instructions corresponding to *++p and *p++, respectively. See section 5.3 of the manual if horribly curious.

As compilers are smart enough to handle the high-level optimization tricks built into the syntax of C, they are just a syntactic convenience now.

Python doesn't have tricks to convey intentions to the assembler because it doesn't use one.

like image 36
msw Avatar answered Oct 21 '22 10:10

msw