Pythonでの増分演算子と減分演算子の動作

プリインクリメント/デクリメント演算子が変数（など++count）に適用できることに気づきました。コンパイルされますが、実際には変数の値は変更されません！

Pythonの事前インクリメント/デクリメント演算子（++ /-）の動作は何ですか？

PythonがC / C ++で見られるこれらの演算子の動作から逸脱するのはなぜですか？

++は演算子ではありません。2つの+演算子です。+オペレータは、アイデンティティ何もしません演算子、。（説明：単項演算子+と-単項演算子は数値に対してのみ機能しますが、架空の++演算子が文字列に対して機能するとは思わないでしょう。）

++count

として解析

+(+count)

に変換します

count

あなたが+=やりたいことをするために少し長い演算子を使わなければなりません：

count += 1

++と--演算子は一貫性と単純さのために省略されたと思います。グイドファンロッサムが決定について与えた正確な議論はわかりませんが、いくつかの議論を想像することができます。

• より簡単な解析。技術的には、構文解析は、++countそれができるよう、曖昧で+、+、count（2つの単項+同じように簡単にそれができるよう事業者）++、count（1つの単項++演算子）。これは重大な構文のあいまいさではありませんが、存在します。
• よりシンプルな言語。++の同義語にすぎません+= 1。Cコンパイラは愚かで、ほとんどのコンピューターが持っている命令に最適化a += 1する方法を知らなかったため、これは発明された速記でしたinc。コンパイラとバイトコード解釈言語を最適化するこの日は、プログラマがコードを最適化できるようにするために言語に演算子を追加することは、特にPythonのような一貫性があり読みやすいように設計された言語では、通常不快になります。
• 紛らわしい副作用。++演算子を使用する言語でよくある初心者のエラーの1つは、前/後の増分/減分演算子の違い（優先順位と戻り値の両方）を混同することです。Pythonは、言語の「問題」を排除することを好みます。Cでの前/後のインクリメントの優先順位の問題はかなり複雑で、非常に簡単に失敗します。

インクリメントまたはデクリメントする場合、通常は整数で行います。そのようです：

b++

しかし、Pythonでは整数は不変です。つまり、それらを変更することはできません。これは、整数オブジェクトを複数の名前で使用できるためです。これを試して：

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

上記のaとbは実際には同じオブジェクトです。aを増分すると、bも増分します。それはあなたが望むものではありません。したがって、再割り当てする必要があります。このような：

b = b + 1

またはより単純：

b += 1

に再割り当てさbれb+1ます。これはインクリメント演算子ではありません。インクリメントしないためb、再割り当てします。

つまり、PythonはCではなく、マシンコードの低レベルのラッパーではないため、ここでは動作が異なりますが、高レベルの動的言語では、増分は意味がなく、Cほど必要ではありません。たとえば、ループが発生するたびに使用します。

他の答えは、単なる+通常の動作を示している限り（つまり、1の場合はそのままにしておきます）正解ですが、何が起こっているのかを説明しない限り、不完全です。

正確には、+xto x.__pos__()と++xtoを評価しx.__pos__().__pos__()ます。

私は次のような非常に奇妙なクラス構造（子供たち、これを家でしないでください！）を想像できます。

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)

Pythonにはこれらの演算子はありませんが、本当に必要な場合は、同じ機能を持つ関数を記述できます。

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

使用法：

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

関数内で、ローカル変数を変更する場合は、2番目の引数としてlocals（）を追加する必要があります。追加しない場合、グローバルを変更しようとします。

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()

また、これらの機能を使用すると、次のことができます。

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

しかし、私の意見では、次のアプローチははるかに明確です：

x = 1
x+=1
print(x)

デクリメント演算子：

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

私は、JavaScriptをPythonに変換するモジュールでこれらの関数を使用しました。

Pythonでは、Common Lisp、Scheme、Rubyなどの言語とは対照的に、式とステートメントの区別が厳密に適用されます。

ウィキペディア

したがって、そのような演算子を導入することで、式/ステートメントの分割を壊すことになります。

同じ理由であなたは書くことができません

if x = 0:
  y = 1

そのような区別が保持されない他のいくつかの言語でできるように。

TL; DR

Pythonには単項インクリメント/デクリメント演算子（--/ ++）はありません。代わりに、値をインクリメントするには、次を使用します

a += 1

詳細と落とし穴

ただし、ここでは注意してください。Cから来ている場合でも、これはPythonでは異なります。Pythonのではなく、用途パイソンCがないという意味で、「変数」、持っていない名前とオブジェクトを、そしてPythonでintSは不変です。

あなたがそう言うとしましょう

a = 1

これがpythonで意味することは、int値1を持つタイプのオブジェクトを作成し、それに名前aをバインドすることです。オブジェクトは、のインスタンスであるint値を有し1、そして名前が aそれを意味します。名前aとそれが参照するオブジェクトは異なります。

今あなたがそう言うとしましょう

a += 1

intsは不変なので、次のようになります。

1. 参照しているオブジェクトを検索しますa（それはintID付きです0x559239eeb380）
2. オブジェクトの値を調べます0x559239eeb380（それは1）
3. その値に1を加えます（1 + 1 = 2）
4. 値を持つ新しい intオブジェクトを作成します2（オブジェクトIDがあります0x559239eeb3a0）
5. aこの新しいオブジェクトに名前を再バインドします
6. 今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

Cのような言語のようなpythonには、ポスト/プリインクリメント/デクリメント演算子はありません。

数学で行うように、++または--複数の符号が乗算されるのを見ることができます（-1）*（-1）=（+1）。

例えば

---count

として解析

-(-(-count)))

に変換します

-(+count)

なぜなら、-符号と-符号の乗算は+

そして最後に、

-count

Python 3.8以降では、次のことができます。

(a:=a+1) #same as a++

これで多くのことを考えることができます。

>>> a = 0
>>> while (a:=a+1) < 5:
    print(a)


1
2
3
4

または、より洗練された構文で何かを記述したい場合（目的は最適化ではありません）：

>>> del a
>>> while (a := (a if 'a' in locals() else 0) + 1) < 5:
    print(a)


1
2
3
4

エラーなしで存在しない場合は0を返し、それを1に設定します