O que exatamente + = faz em python?

Eu preciso saber o que + = faz em python. É simples assim. Eu também gostaria de receber links para definições de outras ferramentas curtas em python.

Em Python, + = é uma cobertura de açúcar para o __iadd__método especial, ou __add__ou __radd__se __iadd__não estiver presente. O __iadd__método de uma classe pode fazer tudo o que quiser. O objeto de lista o implementa e o usa para iterar sobre um objeto iterável anexando cada elemento a si mesmo da mesma maneira que o método extend da lista faz.

Aqui está uma classe personalizada simples que implementa o __iadd__método especial. Você inicializa o objeto com um int e pode usar o operador + = para adicionar um número. Eu adicionei uma instrução de impressão __iadd__para mostrar que ela é chamada. Além disso, __iadd__espera-se que ele retorne um objeto, portanto, retornei a adição dele mais o outro número que faz sentido neste caso.

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

Espero que isto ajude.

+= adiciona outro valor com o valor da variável e atribui o novo valor à variável.

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

-=, *=, /=Faz semelhante para subtração, multiplicação e divisão.

x += 5 não é exatamente o mesmo que dizer x = x + 5 em Python.

Observe aqui:

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]

Consulte para referência: Por que + = se comporta de maneira inesperada nas listas?

+=adiciona um número a uma variável, alterando a própria variável no processo (o que +não aconteceria). Semelhante a isso, existem os seguintes que também modificam a variável:

• -=, subtrai um valor da variável, definindo a variável para o resultado
• *=, multiplica a variável e um valor, tornando o resultado a variável
• /=, divide a variável pelo valor, tornando o resultado a variável
• %=, realiza o módulo na variável, com a variável sendo então definida como o resultado dele

Pode haver outros. Eu não sou um programador Python.

Ele adiciona o operando direito à esquerda. x += 2significax = x + 2

Ele também pode adicionar elementos a uma lista - consulte este tópico do SO .

Não é um mero atalho sintático. Experimente isto:

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

versus

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

Isso ilustra que + = invoca o método iadd list, mas + invoca add , que faz coisas diferentes com listas.

Teoricamente, a + = b "adiciona" b a a armazenando o resultado em a. Esta descrição simplista descreveria o operador + = em muitos idiomas.

No entanto, a descrição simplista levanta algumas questões.

1. O que exatamente queremos dizer com "adicionar"?
2. O que exatamente queremos dizer com "armazenar o resultado em a"? Variáveis ​​python não armazenam valores diretamente, elas armazenam referências a objetos.

Em python, as respostas a essas duas perguntas dependem do tipo de dados de a.

Então, o que exatamente significa "adicionar"?

• Para números, significa adição numérica.
• Para listas, tuplas, strings, etc., significa concatenação.

Observe que, para listas, + = é mais flexível do que +, o operador + em uma lista requer outra lista, mas o operador + = aceitará qualquer iterável.

Então, o que significa "armazenar o valor em a"?

Se o objeto for mutável, então é recomendado (mas não obrigatório) realizar a modificação no local. Portanto, a aponta para o mesmo objeto de antes, mas esse objeto agora tem conteúdo diferente.

Se o objeto for imutável, obviamente não poderá realizar a modificação no local. Alguns objetos mutáveis ​​também podem não ter uma implementação de uma operação "adicionar" no local. Neste caso, a variável "a" será atualizada para apontar para um novo objeto contendo o resultado de uma operação de adição.

Tecnicamente, isso é implementado procurando __IADD__primeiro; se isso não for implementado, então __ADD__é tentado e finalmente __RADD__.

É necessário cuidado ao usar + = em python em variáveis ​​em que não temos certeza do tipo exato e, em particular, quando não temos certeza se o tipo é mutável ou não. Por exemplo, considere o seguinte código.

def dostuff(a):
    b = a
    a += (3,4)
    print(repr(a)+' '+repr(b))

dostuff((1,2))
dostuff([1,2])

Quando invocamos dostuff com uma tupla, a tupla é copiada como parte da operação + = e, portanto, b não é afetado. No entanto, quando o chamamos com uma lista, a lista é modificada no local, de modo que a e b são afetados.

No python 3, comportamento semelhante é observado com os tipos "bytes" e "bytearray".

Por fim, observe que a reatribuição ocorre mesmo se o objeto não for substituído. Isso não importa muito se o lado esquerdo for simplesmente uma variável, mas pode causar um comportamento confuso quando você tem uma coleção imutável referindo-se a coleções mutáveis, por exemplo:

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

Neste caso, [5] será adicionado com sucesso à lista referida por [0], mas depois disso uma exceção será levantada quando o código tentar e falhar em reatribuir um [0].

A resposta curta +=pode ser traduzida como "adicione tudo o que estiver à direita de + = à variável à esquerda de + =".

Ex. Se você tivesse, a = 10então a += 5seria: a = a + 5

Portanto, "a" agora é igual a 15.

Nota x += ynão é o mesmo que x = x + yem algumas situações onde um operador adicional é incluído por causa da precedência do operador combinada com o fato de que o lado direito é sempre avaliado primeiro, por exemplo

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

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

Observe que o primeiro caso se expande para:

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

É mais provável que você encontre isso no 'mundo real' com outros operadores, por exemplo

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

+= é apenas um atalho para escrever

number = 4
number = number + 1

Então, em vez disso, você escreveria

numbers = 4
numbers += 1

Ambas as formas estão corretas, mas o exemplo dois ajuda a escrever um pouco menos de código

Como outros também disseram, o operador + = é um atalho. Um exemplo:

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

Também pode ser escrito assim:

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

Portanto, em vez de escrever o primeiro exemplo, você pode apenas escrever o segundo, o que funcionaria perfeitamente.

Lembre-se de quando você costumava somar, por exemplo, 2 e 3, em sua calculadora antiga e toda vez que acertar o =você vê 3 adicionado ao total, +=ele faz um trabalho semelhante. Exemplo:

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

Estou vendo muitas respostas que não aparecem usando + = com vários números inteiros.

Um exemplo:

x -= 1 + 3

Isso seria semelhante a:

x = x - (1 + 3)

e não:

x = (x - 1) + 3

De acordo com a documentação

x += yé equivalente a x = operator.iadd(x, y). Outra forma de colocar isso é dizer que z = operator.iadd(x, y)é equivalente à instrução composta z = x; z += y.

Então x += 3é o mesmo que x = x + 3.

x = 2

x += 3

print(x)

produzirá 5.

Observe que também há

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