Python没有前增量和后增量操作符。

在Python中，整数是不可变的。那就是你不能改变他们。这是因为整数对象可以在多个名称下使用。试试这个:

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

上面的A和b实际上是同一个物体。如果你增加a，你也会增加b，这不是你想要的。所以你必须重新分配。是这样的:

b = b + 1

许多使用python的C程序员都想要一个自增操作符，但是这个操作符看起来像是对对象进行了自增操作，而实际上是对对象进行了重赋。因此-=和+=运算符加在一起，比b = b+ 1更短，同时比b++更清晰和灵活，所以大多数人会用:

b += 1

将b重新赋值给b+1。这不是一个自增运算符，因为它不加b，而是重新赋值。

简而言之:Python在这里表现不同，因为它不是C语言，也不是机器代码的低级包装器，而是一种高级动态语言，其中增量没有意义，也不像C语言那样必要，例如，在C语言中，每次有循环时都要使用增量。

python中不像C语言中那样有后/前自增/自减操作符。

我们可以看到++或-作为多个符号相乘，就像我们在数学中做的(-1)*(-1)=(+1)。

E.g.

---count

解析为

-(-(-count)))

翻译过来就是

-(+count)

因为-号和-号的乘法是+

最后,

-count

一个直截了当的解决办法

c = 0
c = (lambda c_plusplus: plusplus+1)(c)
print(c)
1

不再打字

 c = c + 1

你也可以直接写 c++ 完成所有代码，然后搜索/替换“c++”，替换为“c=c+1”。只要确保正则表达式搜索是关闭的。

在Python中，表达式和语句之间有严格的区别 与Common Lisp、Scheme或 Ruby。

维基百科

因此，通过引入这样的操作符，可以打破表达式/语句的分割。

和你不能写作的原因一样

if x = 0:
  y = 1

就像在其他一些不保留这种区别的语言中一样。

博士TL;

Python没有一元的递增/递减操作符(——/++)。相反，要增加一个值，请使用

a += 1

更多细节和陷阱

但这里要小心。如果你来自C语言，在python中甚至这一点都是不同的。Python没有C语言那样的“变量”，相反，Python使用名称和对象，并且在Python中int是不可变的。

假设你有

a = 1

这在python中意味着:创建一个int类型的值为1的对象，并将名称a绑定到它。对象是int的一个实例，值为1，名称a指向它。名称a和它所引用的对象是不同的。

现在让我们假设你知道

a += 1

由于int型是不可变的，这里发生的情况如下:

查找a所指向的对象(它是一个int型，id为0x559239eeb380) 查找对象0x559239eeb380的值(它是1) 将该值加1 (1 + 1 = 2) 创建一个值为2的新int对象(对象id为0x559239eeb3a0) 将名称a重新绑定到这个新对象 现在a引用对象0x559239eeb3a0，原始对象(0x559239eeb380)不再被名称a引用。如果没有任何其他名称引用原始对象，它将在以后被垃圾收集。

你自己试试吧:

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

是的，我也错过了++和-功能。几百万行c代码让这种想法在我的老头脑中根深蒂固，而不是与它斗争……这里是一个我拼凑起来实现的类:

pre- and post-increment, pre- and post-decrement, addition,
subtraction, multiplication, division, results assignable
as integer, printable, settable.

这里的是:

class counter(object):
    def __init__(self,v=0):
        self.set(v)

    def preinc(self):
        self.v += 1
        return self.v
    def predec(self):
        self.v -= 1
        return self.v

    def postinc(self):
        self.v += 1
        return self.v - 1
    def postdec(self):
        self.v -= 1
        return self.v + 1

    def __add__(self,addend):
        return self.v + addend
    def __sub__(self,subtrahend):
        return self.v - subtrahend
    def __mul__(self,multiplier):
        return self.v * multiplier
    def __div__(self,divisor):
        return self.v / divisor

    def __getitem__(self):
        return self.v

    def __str__(self):
        return str(self.v)

    def set(self,v):
        if type(v) != int:
            v = 0
        self.v = v

你可以这样使用它:

c = counter()                          # defaults to zero
for listItem in myList:                # imaginary task
     doSomething(c.postinc(),listItem) # passes c, but becomes c+1

.．.已经有了c，你可以这样做。

c.set(11)
while c.predec() > 0:
    print c

．...或者只是……

d = counter(11)
while d.predec() > 0:
    print d

.．.和(重)赋值为整数…

c = counter(100)
d = c + 223 # assignment as integer
c = c + 223 # re-assignment as integer
print type(c),c # <type 'int'> 323

.．.而这将保持c作为类型计数器:

c = counter(100)
c.set(c + 223)
print type(c),c # <class '__main__.counter'> 323

编辑:

还有一点出乎意料(完全不受欢迎)的行为，

c = counter(42)
s = '%s: %d' % ('Expecting 42',c) # but getting non-numeric exception
print s

.．.因为在该元组中，没有使用getitem()，而是将对象的引用传递给格式化函数。叹息。所以:

c = counter(42)
s = '%s: %d' % ('Expecting 42',c.v) # and getting 42.
print s

.．.或者，更详细，更明确地说，我们实际上想要发生什么，尽管在实际形式中与冗长相反(使用c.v代替)……

c = counter(42)
s = '%s: %d' % ('Expecting 42',c.__getitem__()) # and getting 42.
print s