Zachowanie operatorów increment i decrement w Pythonie

Gdy chcesz zwiększyć lub zmniejszyć, Zwykle chcesz to zrobić na liczbie całkowitej. Tak:

b++

Ale w Pythonie liczby całkowite są niezmienne. Nie możesz ich zmienić. Dzieje się tak dlatego, że obiekty integer mogą być używane pod kilkoma nazwami. Spróbuj tego:

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

A i B powyżej to w rzeczywistości ten sam obiekt. Jeśli zwiększysz a, zwiększysz również b. to nie jest to, czego chcesz. Więc musisz zmienić przydział. Tak:

b = b + 1

Lub prostsze:

b += 1

, który zmieni b na b+1. Nie jest to operator inkrementacji, ponieważ nie inkrementuje b, lecz przypisuje go.

W skrócie: Python zachowuje się tutaj inaczej, ponieważ nie jest to C i nie jest niskopoziomowym opakowaniem wokół kodu maszynowego, ale dynamicznym językiem wysokiego poziomu, w którym przyrosty nie mają sensu, a także nie są tak potrzebne jak w C, gdzie używasz ich za każdym razem, gdy masz pętlę, na przykład.

Podczas gdy pozostałe odpowiedzi są poprawne w takim stopniu, w jakim pokazują to, co zwykłe + zwykle robi (tzn. pozostawiają liczbę taką, jaką jest, jeśli jest jedna), są niekompletne w takim stopniu, w jakim nie wyjaśniają, co się dzieje.

Aby być dokładnym, +x ocenia na x.__pos__() i ++x na x.__pos__().__pos__().

Wyobrażam sobie bardzo dziwną strukturę klasową (dzieci, nie róbcie tego w domu!) Tak:

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 nie ma tych operatorów, ale jeśli naprawdę ich potrzebujesz, możesz napisać funkcję o tej samej funkcjonalności.

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

Użycie:

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

Wewnątrz funkcji musisz dodać locals () jako drugi argument, jeśli chcesz zmienić zmienną lokalną, w przeciwnym razie spróbuje zmienić globalną.

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

Również z tych funkcji można zrobić:

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

Ale moim zdaniem następujące podejście jest znacznie jaśniejsze:

x = 1
x+=1
print(x)

Decrement operatory:

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

Użyłem tych funkcji w moim module tłumaczącym javascript na python.

W Pythonie rozróżnienie między wyrażeniami i wyrażeniami jest sztywne egzekwowane, w przeciwieństwie do języków takich jak Common Lisp, Scheme czy Ruby.

Wikipedia

Więc wprowadzając takie operatory, złamałbyś podział wyrażenia/instrukcji.

Z tego samego powodu nie możesz napisać

if x = 0:
  y = 1

Jak można w niektórych innych językach, gdzie takie rozróżnienie nie jest zachowane.

Tak, przegapiłem ++ i -- funkcjonalność również. Kilka milionów linijek kodu c zaszczepiło takie myślenie w mojej starej głowie i zamiast z tym walczyć... Oto klasa i, która implementuje:

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

Oto jest:

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

Możesz użyć tego tak:

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

...już mając c, możesz to zrobić...

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

....albo po prostu...

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

...oraz dla (re-)przypisania do liczby całkowitej...

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

...podczas gdy to utrzyma c jako licznik typu:

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

EDIT:

I jeszcze ten kawałek nieoczekiwanego (i całkowicie niechcianego) zachowania ,

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

...ponieważ wewnątrz tej krotki, getitem () nie jest tym, co jest używane, zamiast tego odwołanie do obiektu jest przekazywane do funkcji formatującej. Westchnienie. Więc:

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

...lub, bardziej gadatliwie i wyraźnie, to, co naprawdę chcieliśmy się wydarzyć, jest jednak przeciwstawiane w rzeczywistej formie gadatliwości (use c.v zamiast tego)...

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