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

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

В 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

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

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

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

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

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]

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

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

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

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

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

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

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

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 , который делает разные вещи со списками.

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

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

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

В Python ответы на оба этих вопроса зависят от типа данных файла.

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

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

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

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

Если объект является изменяемым, рекомендуется (но не обязательно) выполнить изменение на месте. Таким образом, 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], но не сможет.

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

Ex. Если бы у вас было, a = 10то a += 5было бы: a = a + 5

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

Примечание 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

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

number = 4
number = number + 1

Вместо этого вы бы написали

numbers = 4
numbers += 1

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

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

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

Это также можно было бы написать так:

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

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

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

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

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

Один пример:

x -= 1 + 3

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

x = x - (1 + 3)

и нет:

x = (x - 1) + 3

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

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.

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

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