Wat doet += precies in python?

Ik moet weten wat += doet in Python. Het is zo simpel. Ik zou ook graag links naar definities van andere steno-tools in Python waarderen.

Antwoord 1, autoriteit 100%

In Python is += suikercoating voor de speciale methode __IADD__, of __add__ of __radd__ als __IADD__ niet aanwezig is. De __IADD__ methode van een klasse kan alles doen wat het wil. Het lijstobject implementeert het en gebruikt het om een ​​itereerbaar object te herhalen en elk element aan zichzelf toe te voegen op dezelfde manier als de methode voor het uitbreiden van de lijst.

Hier is een eenvoudige aangepaste klasse die de speciale methode __IADD__ implementeert. U initialiseert het object met een int en kunt vervolgens de +=-operator gebruiken om een ​​getal toe te voegen. Ik heb een print statement toegevoegd in __IADD__ om te laten zien dat het wordt aangeroepen. Ook wordt verwacht dat __IADD__ een object retourneert, dus ik heb de toevoeging van zichzelf plus het andere getal geretourneerd, wat in dit geval logisch is.

>>> class Adder(object):
        def __init__(self, num=0):
            self.num = num
        def __iadd__(self, other):
            print 'in __iadd__', other
            self.num = self.num + other
            return self.num
>>> a = Adder(2)
>>> a += 3
in __iadd__ 3
>>> a
5

Hopelijk helpt dit.

Antwoord 2, autoriteit 89%

+= voegt een andere waarde toe aan de waarde van de variabele en wijst de nieuwe waarde toe aan de variabele.

>>> x = 3
>>> x += 2
>>> print x
5

-=, *=, /= doet hetzelfde voor aftrekken, vermenigvuldigen en delen.

Antwoord 3, autoriteit 31%

x += 5 is niet precies hetzelfde als zeggen x = x + 5 in Python.

Let hier op:

In [1]: x = [2, 3, 4]    
In [2]: y = x    
In [3]: x += 7, 8, 9    
In [4]: x
Out[4]: [2, 3, 4, 7, 8, 9]    
In [5]: y
Out[5]: [2, 3, 4, 7, 8, 9]    
In [6]: x += [44, 55]    
In [7]: x
Out[7]: [2, 3, 4, 7, 8, 9, 44, 55]    
In [8]: y
Out[8]: [2, 3, 4, 7, 8, 9, 44, 55]    
In [9]: x = x + [33, 22]    
In [10]: x
Out[10]: [2, 3, 4, 7, 8, 9, 44, 55, 33, 22]    
In [11]: y
Out[11]: [2, 3, 4, 7, 8, 9, 44, 55]

Zie voor referentie: Waarom gedraagt ​​+= zich onverwacht op lijsten?

Antwoord 4, autoriteit 20%

+= voegt een getal toe aan een variabele, waarbij de variabele zelf verandert (terwijl + dat niet zou doen). Op dezelfde manier zijn er de volgende die ook de variabele wijzigen:

• -=, trekt een waarde af van de variabele en stelt de variabele in op het resultaat
• *=, vermenigvuldigt de variabele en een waarde, waardoor de uitkomst de variabele wordt
• /=, deelt de variabele door de waarde, waardoor de uitkomst de variabele wordt
• %=, voert modulus uit op de variabele, waarbij de variabele vervolgens wordt ingesteld op het resultaat ervan

Misschien zijn er nog andere. Ik ben geen Python-programmeur.

Antwoord 5, autoriteit 15%

Het is niet zomaar een syntactische suiker. Probeer dit:

x = []                 # empty list
x += "something"       # iterates over the string and appends to list
print(x)               # ['s', 'o', 'm', 'e', 't', 'h', 'i', 'n', 'g']

tegen

x = []                 # empty list
x = x + "something"    # TypeError: can only concatenate list (not "str") to list

De += operator roept de __iadd__() lijstmethode aan, terwijl + de __add__() een. Ze doen verschillende dingen met lijsten.

Antwoord 6, autoriteit 10%

Het voegt de rechter operand aan de linkerkant toe. x += 2 betekent x = x + 2

Het kan ook elementen aan een lijst toevoegen — zie deze SO-thread.

Antwoord 7, autoriteit 6%

Natuurlijk voegt a += b b toe aan a door het resultaat op te slaan in a. Deze simplistische beschrijving zou de += operator in vele talen beschrijven.

De simplistische beschrijving roept echter een aantal vragen op.

1. Wat bedoelen we precies met “toevoegen”?
2. Wat bedoelen we precies met “het resultaat opslaan in een”? python-variabelen slaan waarden niet rechtstreeks op, ze slaan verwijzingen naar objecten op.

In python zijn de antwoorden op beide vragen afhankelijk van het gegevenstype van a.

Dus wat betekent ‘toevoegen’ precies?

• Voor getallen betekent dit numerieke optelling.
• Voor lijsten, tupels, strings enz. betekent dit aaneenschakeling.

Houd er rekening mee dat voor lijsten += flexibeler is dan +, de operator + op een lijst een andere lijst vereist, maar de operator += accepteert elke iterabele.

Dus wat betekent ‘de waarde opslaan in a’?

Als het object veranderlijk is, wordt het aangemoedigd (maar niet verplicht) om de wijziging ter plaatse uit te voeren. Dus a verwijst naar hetzelfde object als voorheen, maar dat object heeft nu een andere inhoud.

Als het object onveranderlijk is, kan het de wijziging uiteraard niet ter plaatse uitvoeren. Sommige veranderlijke objecten hebben mogelijk ook geen implementatie van een in-place “add”-bewerking. In dit geval wordt de variabele “a” bijgewerkt om te verwijzen naar een nieuw object dat het resultaat van een optelbewerking bevat.

Technisch gezien wordt dit geïmplementeerd door eerst te zoeken naar __IADD__, als dat niet is geïmplementeerd, wordt __add__ geprobeerd en ten slotte __radd__.

Voorzichtigheid is geboden bij het gebruik van += in python op variabelen waarvan we niet zeker zijn van het exacte type en in het bijzonder waar we niet zeker weten of het type veranderlijk is of niet. Beschouw bijvoorbeeld de volgende code.

def dostuff(a):
    b = a
    a += (3,4)
    print(repr(a)+' '+repr(b))
dostuff((1,2))
dostuff([1,2])

Als we dostuff aanroepen met een tuple, dan wordt de tuple gekopieerd als onderdeel van de += operatie en wordt b dus niet beïnvloed. Wanneer we het echter aanroepen met een lijst, wordt de lijst op zijn plaats gewijzigd, zodat zowel a als b worden beïnvloed.

In python 3 wordt vergelijkbaar gedrag waargenomen met de typen “bytes” en “bytearray”.

Ten slotte wordt opgemerkt dat hertoewijzing ook plaatsvindt als het object niet wordt vervangen. Dit maakt niet veel uit als de linkerkant gewoon een variabele is, maar het kan verwarrend gedrag veroorzaken als je een onveranderlijke verzameling hebt die verwijst naar veranderlijke verzamelingen, bijvoorbeeld:

a = ([1,2],[3,4])
a[0] += [5]

In dit geval wordt [5] met succes toegevoegd aan de lijst waarnaar wordt verwezen door a[0], maar daarna wordt er een uitzondering gemaakt wanneer de code probeert en faalt om een ​​[0] opnieuw toe te wijzen.

Antwoord 8, autoriteit 4%

Opmerking x += y is niet hetzelfde als x = x + y in sommige situaties waarin een extra operator is opgenomen vanwege de operatorprioriteit gecombineerd met het feit dat de rechterkant altijd als eerste wordt geëvalueerd, bijv.

>>> x = 2
>>> x += 2 and 1
>>> x
3
>>> x = 2
>>> x = x + 2 and 1
>>> x
1

Let op het eerste geval uitbreiden naar:

>>> x = 2
>>> x = x + (2 and 1)
>>> x
3

De kans is groter dat je dit in de ‘echte wereld’ tegenkomt met andere operators, bijvoorbeeld

x *= 2 + 1 == x = x * (2 + 1) != x = x * 2 + 1

Antwoord 9, autoriteit 3%

Het korte antwoord is += kan worden vertaald als “voeg toe wat zich rechts van de += bevindt aan de variabele aan de linkerkant van de +=”.

Bijvoorbeeld. Als je a = 10 hebt, dan is a += 5: a = a + 5

Dus, “a” is nu gelijk aan 15.

Antwoord 10, autoriteit 2%

+= is slechts een sneltoets om te schrijven

number = 4
number = number + 1

Dus in plaats daarvan zou je schrijven

numbers = 4
numbers += 1

Beide manieren zijn correct, maar voorbeeld twee helpt je om wat minder code te schrijven

Antwoord 11

Volgens de documentatie

x += y is gelijk aan x = operator.iadd(x, y). Een andere manier om
zet het is om te zeggen dat z = operator.iadd(x, y) gelijk is aan de
samengestelde instructie z = x; z += y.

Dus x += 3 is hetzelfde als x = x + 3.

x = 2
x += 3
print(x)

voer 5 uit.

Merk op dat er ook

• &=
• //=
• <<=
• %=
• *=
• @=
• |=
• **=
• >>=
• -=
• /=
• ^=

Antwoord 12

Zoals anderen ook al zeiden, is de operator += een snelkoppeling.
Een voorbeeld:

var = 1;
var = var + 1;
#var = 2

Het kan ook zo worden geschreven:

var = 1;
var += 1;
#var = 2

Dus in plaats van het eerste voorbeeld te schrijven, kun je gewoon het tweede schrijven, wat prima zou werken.

Antwoord 13

Weet je nog wanneer je vroeger optelde, bijvoorbeeld 2 & 3, in je oude rekenmachine en elke keer dat je op = drukt, zie je 3 opgeteld bij het totaal, doet de += hetzelfde werk. Voorbeeld:

>>> orange = 2
>>> orange += 3
>>> print(orange)
5
>>> orange +=3
>>> print(orange)
8

Antwoord 14

Ik zie veel antwoorden die niet naar voren komen door += te gebruiken met meerdere gehele getallen.

Eén voorbeeld:

x -= 1 + 3

Dit zou vergelijkbaar zijn met:

x = x - (1 + 3)

en niet:

x = (x - 1) + 3

Antwoord 15

Laten we eens kijken naar de bytecode die CPython genereert voor x += y en x = x = y. (Ja, dit is afhankelijk van de implementatie, maar het geeft je een idee van de taalgedefinieerde semantiek die wordt geïmplementeerd.)

>>> import dis
>>> dis.dis("x += y")
  1           0 LOAD_NAME                0 (x)
              2 LOAD_NAME                1 (y)
              4 INPLACE_ADD
              6 STORE_NAME               0 (x)
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE
>>> dis.dis("x = x + y")
  1           0 LOAD_NAME                0 (x)
              2 LOAD_NAME                1 (y)
              4 BINARY_ADD
              6 STORE_NAME               0 (x)
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE

Het enige verschil tussen de twee is de bytecode die wordt gebruikt voor de operator: INPLACE_ADD voor += en BINARY_ADD voor +.

BINARY_ADD wordt geïmplementeerd met behulp van x.__add__ (of y.__radd__ indien nodig), dus x = x + y is ongeveer hetzelfde als x = x.__add__(y). Zowel __add__ als __radd__ retourneren doorgaans nieuwe instanties, zonder een van beide argumenten te wijzigen.

INPLACE_ADD wordt geïmplementeerd met x.__iadd__. Als dat niet bestaat, wordt in plaats daarvan x.__add__ gebruikt. x.__iadd__ retourneert doorgaans x, zodat de resulterende STORE_NAME de referent van x niet verandert, hoewel dat object is mogelijk gemuteerd. (Het doel van INPLACE_ADD is inderdaad om een ​​manier te bieden om een ​​object te muteren in plaats van altijd een nieuw object te maken.)

Bijvoorbeeld, int.__iadd__ is niet gedefinieerd, dus x += 7 wanneer x een int is hetzelfde als x = x.__add__(y), waarbij x wordt ingesteld op een nieuwe instantie van int.

Aan de andere kant is list.__iadd__ gedefinieerd, dus x += [7] wanneer x een list is hetzelfde als x = x.__iadd__([9]). list.__iadd__ roept effectief extend aan om de elementen van zijn argument toe te voegen aan het einde van x. Het is niet echt mogelijk om door te kijken naar de waarde van x voor en na de uitgebreide toewijzing dat x opnieuw is toegewezen, omdat het hetzelfde object was toegewezen aan de naam.