Verhalten von Inkrement- und Dekrementoperatoren in Python

Ich stelle fest, dass ein Vorinkrementierungs- / Dekrementierungsoperator auf eine Variable (wie ++count) angewendet werden kann . Es wird kompiliert, ändert aber den Wert der Variablen nicht!

Wie verhalten sich die Operatoren vor dem Inkrementieren / Dekrementieren (++ / -) in Python?

Warum weicht Python vom Verhalten dieser Operatoren in C / C ++ ab?

++ist kein Operator. Es sind zwei +Operatoren. Der +Operator ist der Identitätsoperator , der nichts tut. (Klarstellung: Die +und -unäre Operatoren arbeiten nur mit Zahlen, aber ich gehe davon aus, dass Sie nicht erwarten würden, dass ein hypothetischer ++Operator mit Zeichenfolgen arbeitet.)

++count

Analysiert als

+(+count)

Was übersetzt bedeutet

count

Sie müssen den etwas längeren +=Operator verwenden, um das zu tun, was Sie tun möchten:

count += 1

Ich vermute, dass die ++und --Operatoren aus Gründen der Konsistenz und Einfachheit weggelassen wurden. Ich kenne das genaue Argument, das Guido van Rossum für die Entscheidung vorgebracht hat, nicht, aber ich kann mir einige Argumente vorstellen:

• Einfacheres Parsen. Technisch Parsing ++countist nicht eindeutig, wie es sein könnte +, +, count(zwei einstellige +Operatoren) genauso einfach wie es sein könnte ++, count(ein einstelliger ++Operator). Es ist keine signifikante syntaktische Mehrdeutigkeit, aber es existiert.
• Einfachere Sprache. ++ist nichts weiter als ein Synonym für += 1. Es war eine Kurzform, die erfunden wurde, weil C-Compiler dumm waren und nicht wussten, wie sie a += 1die incAnweisungen der meisten Computer optimieren sollten . In der heutigen Zeit der Optimierung von Compilern und Bytecode-interpretierten Sprachen ist das Hinzufügen von Operatoren zu einer Sprache, mit der Programmierer ihren Code optimieren können, normalerweise verpönt, insbesondere in einer Sprache wie Python, die konsistent und lesbar ist.
• Verwirrende Nebenwirkungen. Ein häufiger Anfängerfehler in Sprachen mit ++Operatoren besteht darin, die Unterschiede (sowohl in Bezug auf die Priorität als auch in Bezug auf den Rückgabewert) zwischen den Operatoren vor und nach dem Inkrementieren / Dekrementieren zu verwechseln, und Python eliminiert gerne die Sprache "gotcha" -s. Der Rang Fragen von Pre- / Post-Inkrement in C sind ziemlich behaart, und unglaublich einfach zu vermasseln.

Wenn Sie inkrementieren oder dekrementieren möchten, möchten Sie dies normalerweise für eine Ganzzahl tun. Wie so:

b++

In Python sind Ganzzahlen jedoch unveränderlich . Das heißt, Sie können sie nicht ändern. Dies liegt daran, dass die ganzzahligen Objekte unter mehreren Namen verwendet werden können. Versuche dies:

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

a und b oben sind eigentlich das gleiche Objekt. Wenn Sie a erhöhen, erhöhen Sie auch b. Das willst du nicht. Sie müssen also neu zuweisen. So was:

b = b + 1

Oder einfacher:

b += 1

Was neu zuweisen wird bzu b+1. Dies ist kein Inkrementierungsoperator, da er nicht inkrementiert b, sondern neu zugewiesen wird.

Kurz gesagt: Python verhält sich hier anders, weil es nicht C ist und kein Wrapper auf niedriger Ebene um Maschinencode, sondern eine dynamische Sprache auf hoher Ebene, in der Inkremente keinen Sinn ergeben und auch nicht so notwendig sind wie in C. , wo Sie sie zum Beispiel jedes Mal verwenden, wenn Sie eine Schleife haben.

Während die anderen Antworten insofern richtig sind, als sie zeigen, was ein bloßes +tut (nämlich die Zahl so lassen, wie sie ist, wenn es eine ist), sind sie insofern unvollständig, als sie nicht erklären, was passiert.

Um genau zu sein, +xbewertet zu x.__pos__()und ++xzu x.__pos__().__pos__().

Ich könnte mir eine SEHR seltsame Klassenstruktur vorstellen (Kinder, mach das nicht zu Hause!) Wie diese:

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 verfügt nicht über diese Operatoren, aber wenn Sie sie wirklich benötigen, können Sie eine Funktion mit derselben Funktionalität schreiben.

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

Verwendungszweck:

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

Innerhalb einer Funktion müssen Sie local () als zweites Argument hinzufügen, wenn Sie die lokale Variable ändern möchten. Andernfalls wird versucht, die globale Variable zu ändern.

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

Auch mit diesen Funktionen können Sie:

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

Meiner Meinung nach ist der folgende Ansatz jedoch viel klarer:

x = 1
x+=1
print(x)

Dekrementierungsoperatoren:

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

Ich habe diese Funktionen in meinem Modul verwendet, um Javascript in Python zu übersetzen.

In Python wird im Gegensatz zu Sprachen wie Common Lisp, Scheme oder Ruby eine Unterscheidung zwischen Ausdrücken und Anweisungen streng erzwungen.

Wikipedia

Wenn Sie also solche Operatoren einführen, können Sie die Aufteilung von Ausdruck und Anweisung aufheben.

Aus dem gleichen Grund kann man nicht schreiben

if x = 0:
  y = 1

wie Sie können in einigen anderen Sprachen, in denen eine solche Unterscheidung nicht erhalten bleibt.

TL; DR

Python hat keine unären Inkrementierungs- / Dekrementierungsoperatoren ( --/ ++). Verwenden Sie stattdessen, um einen Wert zu erhöhen

a += 1

Mehr Details und Fallstricke

Aber sei hier vorsichtig. Wenn Sie aus C kommen, ist auch dies in Python anders. Python hat keine "Variablen" in dem Sinne wie C, stattdessen verwendet Python Namen und Objekte und in Python intsind sie unveränderlich.

Nehmen wir an, Sie tun es

a = 1

In Python bedeutet dies: Erstellen Sie ein Objekt vom Typ intmit Wert 1und binden Sie den Namen adaran. Das Objekt ist eine Instanz intmit Wert 1, und der Name a verweist darauf. Der Name aund das Objekt, auf das es sich bezieht, sind unterschiedlich.

Nehmen wir jetzt an, Sie tun es

a += 1

Da ints unveränderlich sind, geschieht hier Folgendes:

1. Suchen Sie nach dem Objekt, aauf das verwiesen wird (es ist eine intmit ID 0x559239eeb380).
2. den Wert des Objekts nachschlagen 0x559239eeb380(es ist 1)
3. addiere 1 zu diesem Wert (1 + 1 = 2)
4. Erstellen Sie ein neues int Objekt mit Wert 2(es hat Objekt-ID 0x559239eeb3a0)
5. Binden Sie den Namen erneut aan dieses neue Objekt
6. aBezieht sich jetzt auf das Objekt 0x559239eeb3a0und das ursprüngliche Objekt ( 0x559239eeb380) wird nicht mehr mit dem Namen bezeichnet a. Wenn keine anderen Namen auf das ursprüngliche Objekt verweisen, wird der Müll später gesammelt.

Probieren Sie es selbst aus:

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

Ja, ich habe auch ++ und - Funktionalität vermisst. Ein paar Millionen Zeilen C-Code haben diese Art des Denkens in meinem alten Kopf verankert, und anstatt dagegen anzukämpfen ... Hier ist eine Klasse, die ich zusammengeschustert habe und die Folgendes implementiert:

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

Hier ist es:

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

Sie könnten es so verwenden:

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

... bereits mit c, könnten Sie dies tun ...

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

....oder nur...

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

... und für die (Neu-) Zuordnung in eine Ganzzahl ...

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

... während dies c als Typzähler beibehält:

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

BEARBEITEN:

Und dann gibt es dieses unerwartete (und völlig unerwünschte) Verhalten .

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

... weil in diesem Tupel getitem () nicht verwendet wird, sondern ein Verweis auf das Objekt an die Formatierungsfunktion übergeben wird. Seufzer. Damit:

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

... oder wörtlicher und expliziter, was wir eigentlich wollten, obwohl dies in tatsächlicher Form durch die Ausführlichkeit entgegengesetzt wird ( c.vstattdessen verwenden) ...

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

In Python gibt es keine Post / Pre-Inkrement- / Dekrement-Operatoren wie in Sprachen wie C.

Wir können sehen ++oder --als mehrere Zeichen multiplizieren, wie wir es in Mathe (-1) * (-1) = (+1) tun.

Z.B

---count

Analysiert als

-(-(-count)))

Was übersetzt bedeutet

-(+count)

Denn Multiplikation von -Vorzeichen mit -Vorzeichen ist+

Und schlussendlich,

-count

In Python 3.8+ können Sie Folgendes tun:

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

Damit kann man viel nachdenken.

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


1
2
3
4

Oder wenn Sie etwas mit einer ausgefeilteren Syntax schreiben möchten (das Ziel ist nicht die Optimierung):

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


1
2
3
4

Es gibt gut 0 zurück, wenn ein nicht fehlerfrei existiert, und setzt es dann auf 1