Что именно делает += в python?

Question

Мне нужно знать, что += делает в Python. Это так просто. Я также был бы признателен за ссылки на определения других сокращенных инструментов в python.

Answer 1

В Python += - сахарное покрытие для __iadd__ специальный метод или __add__ или же __radd__ если __iadd__ нет __iadd__ метод класса может делать все, что захочет. Объект списка реализует его и использует для перебора итерируемого объекта, добавляя каждый элемент к себе так же, как это делает метод расширения списка.

Вот простой пользовательский класс, который реализует __iadd__ особый метод. Вы инициализируете объект с помощью int, затем можете использовать оператор += для добавления числа. Я добавил заявление для печати в __iadd__ чтобы показать, что это называется. Также, __iadd__ ожидается, что он вернет объект, поэтому я вернул добавление самого себя и другого числа, что имеет смысл в этом случае.

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

Надеюсь это поможет.

Answer 2

+= добавляет другое значение со значением переменной и назначает новое значение переменной.

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

-=, *=, /= делает то же самое для вычитания, умножения и деления.

Answer 3

x += 5 не совсем то же самое, что сказать x = x + 5 в Python.

Обратите внимание, здесь:

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]

См. Для справки: почему += ведет себя неожиданно в списках?

Answer 4

+= добавляет число к переменной, изменяя саму переменную в процессе (тогда как + не будет). Аналогично этому есть следующие, которые также изменяют переменную:

• -=, вычитает значение из переменной, устанавливая переменную в результат
• *=, умножает переменную и значение, делая результат переменной
• /=, делит переменную на значение, делая результат переменной
• %=, выполняет модуль для переменной, а затем переменная устанавливается на результат

Там могут быть другие. Я не программист на Python.

Answer 5

Это не просто синтаксический ярлык. Попробуй это:

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

против

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

Это показывает, что += вызывает метод списка iadd, но + вызывает add, что делает разные вещи со списками.

Answer 6

Это добавляет правый операнд слева. x += 2 средства x = x + 2

Он также может добавлять элементы в список - см. Этот поток SO.

Answer 7

Условно a += b "добавляет" b к сохранению результата в a. Это упрощенное описание будет описывать оператор + = во многих языках.

Однако упрощенное описание вызывает пару вопросов.

1. Что именно мы подразумеваем под "добавлением"?
2. Что именно мы подразумеваем под "сохранением результата в"? Переменные python не хранят значения напрямую, они хранят ссылки на объекты.

В python ответы на оба эти вопроса зависят от типа данных a.

---

Так что именно означает "добавление"?

• Для чисел это означает числовое сложение.
• Для списков, кортежей, строк и т. Д. Это означает конкатенацию.

Обратите внимание, что для списков + = более гибок, чем +, для оператора + в списке требуется другой список, но оператор + = примет любую итерацию.

---

Так что же значит "хранить значение в"?

Если объект изменчив, тогда рекомендуется (но не обязательно) выполнить модификацию на месте. Таким образом, указатель на тот же объект, который он делал раньше, но этот объект теперь имеет другое содержание.

Если объект является неизменным, то он, очевидно, не может выполнить модификацию на месте. Некоторые изменяемые объекты могут также не иметь реализации операции добавления на месте. В этом случае переменная "а" будет обновлена, чтобы указывать на новый объект, содержащий результат операции сложения.

Технически это реализуется путем поиска __IADD__ во-первых, если это не реализовано, то __ADD__ окончательно опробован __RADD__,

---

Необходимо соблюдать осторожность при использовании + = в python для переменных, где мы не уверены в точном типе и, в частности, когда мы не уверены, является ли тип изменчивым или нет. Например, рассмотрим следующий код.

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

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

Когда мы вызываем dostuff с кортежем, он копируется как часть операции + =, и, следовательно, b не изменяется. Однако, когда мы вызываем его со списком, список изменяется на месте, поэтому затрагиваются как a, так и b.

В Python 3 подобное поведение наблюдается с типами "bytes" и "bytearray".

---

В заключение отметим, что переназначение происходит, даже если объект не заменен. Это не имеет большого значения, если левая часть является просто переменной, но это может вызвать путаницу, когда у вас есть неизменяемая коллекция, ссылающаяся, например, на изменяемые коллекции:

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

В этом случае [5] будет успешно добавлено в список, на который ссылается [0], но затем будет сгенерировано исключение, когда код попытается и не сможет переназначить [0].

Answer 8

Запись x += y не то же самое, что x = x + yв некоторых ситуациях, когда добавляется дополнительный оператор из-за приоритета оператора в сочетании с тем фактом, что правая часть всегда оценивается первой, например

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

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

Обратите внимание, что первый случай расширяется до:

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

Вы с большей вероятностью столкнетесь с этим в "реальном мире" с другими операторами, например

x *= 2 + 1 == x = x * (2 + 1) знак равно x = x * 2 + 1

Answer 9

Краткий ответ: += можно перевести как "добавить все, что находится справа от +=, к переменной слева от +=".

Ex. Если у вас есть a = 10 затем a += 5 было бы: a = a + 5

Итак, "а" теперь равно 15.

Answer 10

+= 

просто ярлык для написания

numbers = 1
numbers = numbers + 1
print (numbers)   ## 2

Так что вместо этого вы бы написали

numbers = 1
numbers += 1
print (numbers)   ## 2

Оба способа верны, но пример два помогает вам написать немного меньше кода

Answer 11

Согласно документации

x += y эквивалентно x = operator.iadd(x, y). Другими словами, можно сказать, чтоz = operator.iadd(x, y) эквивалентно составному оператору z = x; z += y.

Так x += 3 такой же как x = x + 3.

x = 2

x += 3

print(x)

выведет 5.

Обратите внимание, что есть также

• знак равно
• знак равно
• <<=
• знак равно
• знак равно
• знак равно
• |=
• знак равно
• >>=
• знак равно
• знак равно
• ^=

Answer 12

Давайте посмотрим на байт-код, который CPython генерирует для x += y и x = x = y. (Да, это зависит от реализации, но дает представление о реализуемой семантике, определяемой языком.)

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

Только разница между ними состоит в байт - код , используемый для оператора: для +=, и для +.

BINARY_ADD реализуется с использованием (или y.__radd__ при необходимости), поэтому x = x + yпримерно то же самое, что и. Оба __add__ и __radd__ обычно возвращают новые экземпляры, не изменяя ни один из аргументов.

реализуется с использованием. Если этого не существует, тогда x.__add__ используется вместо него. x.__iadd__ обычно возвращается, так что в результате STORE_NAMEне изменяет референт, хотя этот объект мог быть видоизменен. (Действительно, цель INPLACE_ADD заключается в том, чтобы предоставить способ видоизменить объект, а не всегда создавать новый объект.)

Например, int.__iadd__ не определено, поэтому x += 7 когда это то же самое, что и x = x.__add__(y), устанавливая новый экземпляр int.

С другой стороны, определяется, поэтому x += [7] когда это list такой же как x = x.__iadd__([9]). list.__iadd__ эффективно звонит extendчтобы добавить элементы своего аргумента в конец. Невозможно сказать, глядя на значение до и после расширенного присваивания, которое xбыл переназначен, потому что имя было присвоено тому же объекту.

Answer 13

The +=сокращает избыточность при добавлении двух объектов с заданной переменной:

Длинная версия:

      a = 10
a = a + 7
print(a)  # result is 17

Укороченная версия:

      a = 10
a += 7
print(a)  # result is 17

Answer 14

По сути, это упрощение выражения (переменная) = (переменная) + x. Например:

      num = num + 2

Такой же как:

      num += 2

Answer 15

Помните, когда вы использовали сумму, например 2 и 3, в своем старом калькуляторе и каждый раз, когда вы нажимаете = Вы видите 3 добавлены к итогу, += делает похожую работу. Пример:

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

Answer 16

Я вижу много ответов, которые не возникают при использовании += с несколькими целыми числами.

Один пример:

x -= 1 + 3

Это будет похоже на:

x = x - (1 + 3)

и нет:

x = (x - 1) + 3

Answer 17

Как и другие говорили, оператор += является ярлыком. Пример:

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

Это также можно записать так:

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

Поэтому вместо того, чтобы писать первый пример, вы можете просто написать второй, который будет работать просто отлично.