DEV Community: Tahmid Hossain

a += b is not the same as a = a + b

Tahmid Hossain — Wed, 02 Dec 2020 11:11:33 +0000

In python a += b is not equivalent as a = a + b. They do not behave the same always. Consider the following:

>>> a = [1, 2, 3]
>>> b = a
>>> a += [4, 5, 6]
>>> a
[1, 2, 3, 4, 5, 6]
>>> b
[1, 2, 3, 4, 5, 6]

>>> a = [1, 2, 3]
>>> b = a
>>> a = a + [4, 5, 6]
>>> a
[1, 2, 3, 4, 5, 6]
>>> b
[1, 2, 3]

What happend here:

a += b modified the list in-place. That means it extended a such that a and b had reference to the same list.
a = a + b expression created a new list and changed a 's reference to that new list. And b refered to the old list. Why it happened? Here comes how python implements + and += operators. When you use + operator python calls the __add__ special method. On the other hand += operator calls the __iadd__ special method, and if __iadd__ is not available only then it uses __add__ method. See below:

class MyList (list):
    def __add__ (self, other):
        print ("__add__ has been called")
        return super (MyList, self).__add__ (other)

    def __iadd__ (self, other):
        print ("__iadd__ has been called")
        return super (MyList, self).__iadd__ (other)

Now, run the below code:

a = MyList ([1, 2, 3])
b = a
a = a + b

It gives following output:

__add__ has been called

Now, run the below code:

a = MyList ([1, 2, 3])
b = a
a += b

It gives the following output:

__iadd__ has been called

The __iadd__ special method is for an inplace addition. That is it mutates the object that it acts on (in a += b __iadd__ mutates a). On the other hand,__add__ method returns a new object (in a = a + b we assigned __add__'s returned object into a).

__iadd__ is only available for mutable types. That's why for immutable types like integers (int), strings (str) and tuple both + and += are equivalent as they both calles __add__. And this is what lets you use += on immutable types.

Now, let's see another difference between + and +=. Consider the following:

>>> a = [1, 2, 3]
>>> b = "hello"
>>> a + b
TypeError: can only concatenate list (not "str") to list
>>> a += b
>>> a
[1, 2, 3, 'h', 'e', 'l', 'l', 'o']

Here a + b gives TypeError. Because + operator is symmetrical. So, we can't add a list and str. But += operator is obviously not symmetrical. It is equivalent to list.extend, which iterates over the second operand. See below:

class MyStr (str):
    def __iter__ (self):
        print ("__iter__ has been called")
        return super (MyStr, self).__iter__()

a = [1, 2, 3]
b = "hello"
a += b

It gives following output:

__iter__ has been called

So, for types that support both __add__ and __iadd__ you therefore have to be careful which one you use.

Speed up Python Code

Tahmid Hossain — Sat, 21 Nov 2020 05:44:31 +0000

Python is one of the most popular programming languages all over the world. For its, simple syntax and rich library, it is being used in competitive programming also. Most of us probably started coding with python. At first, everything goes simple and easy. But while solving a hard algorithmic problems, most of us suffer from Time Limit Exceeded. However, it is not a problem of python; most of the cases, the problem is with the programmer. I am not saying that python is not slow, but if a programmer writes efficient programme, it will get Accepted for sure. Here are some tips to speed up your python programme.

Use proper data structures

Use of proper data structure has a significant effect on runtime. Python has list, tuple, set and dictionary as the built-in data structures. However, most of the people use the list in all cases. But it is not a right choice. Use proper data structures depending on your task. Especially use a tuple instead of a list. Because iterating over tuple is easier than iterating over a list.

Decrease the use of for loop

As for loop is dynamic in python, it takes more time than while loop. So, use while loop instead of for loop.

Use list comprehension

Do not use any other technique if you can use list comprehension. For example, here is a code to list all the numbers between 1 and 1000 that is the multiplier of 3:

L = []
for i in range (1, 1000):
    if i%3 == 0:
        L.append (i)

Using list comprehension, it would be:

L = [i for i in range (1, 1000) if i%3 == 0]

List comprehension works faster than using the append method.

Use multiple assignments

Do not assaign variables like this:

a = 2
b = 3
c = 5
d = 7

Instead, assign variables like this:

a, b, c, d = 2, 3, 5, 7

Do not use global variables

Python has global keyword to declare global variables. But global variables take higher time during operation than a local variable. So, do not use global variables if it is not necessary.

Use library functions

Do not write your function (manually) if it is already in the library. Library functions are highly efficient, and you will probably won't be able to code with that efficiency.

Concatenate strings with join In python, you can concatenate strings with `+` operation.

concatenatedString = "Programming " + "is " + "fun."

It can also be done with join() method.

concatenatedString = " ".join (["Programming", "is", "fun."])

join() concatenates strings faster than + operation because + operators create a new string and then copies the old content at each step. But join() doesn't work that way.

Use generators

If you have a large amount of data in your list and you need to use one data at a time and for once then use generators. It will save you time.

Avoid dot operation as much as possible

Try to avoid dot operation. See the below programme.

import math
val = math.sqrt(60)

Instead of the above style write code like this:

from math import sqrt
val = sqrt(60)

Because when you call a function using . (dot) it first calls __getattribute()__ or __getattr()__ which then use dictionary operation which costs time. So, try using from module import function.

Use 1 for infinity loops

Use while 1 instead of while True. It will reduce some runtime.

Think outside the box

Try new ways to write your code efficiently. See the below code.

if a_condition:
    if another_condition:
        do_something
else:
    raise exception

Instead of the above code you can write:

if (not a_condition) or (not another_condition):
    raise exception
do_something

Use speed up applications

For python's slow speed, some projects have been taken to decrease runtime. Pypy and Numba two of them. In most of the programming contests, you will see pypy if it allows python. These applications will reduce the runtime of your programme.

Use special libraries to process large datasets

C/C++ is faster than python. So, many packages and modules have been written in C/C++ that you can use in your python programme. Numpy, Scipy and Pandas are three of them and are popular for processing large datasets.

Use the latest release of python

Python is updated and upgraded regularly, and every release is faster and more optimized. So always use the latest version of python.

These were some of the tips to decrease the runtime of python code. There are a few more techniques that you can use. Use a search engine to find those and write efficient code!