Add string to another string

Question

Hi there,

I currently encountered a problem: I want to handle adding strings to other strings very efficiently, so I looked up many methods and techniques, and I figured the "fastest" method. But I quite can not understand how it actually works:

def method6():
    return ''.join([`num` for num in xrange(loop_count)])

From source (Method 6)

Especially the ([`num` for num in xrange(loop_count)]) confused me totally.

Answer 1

it's a list comprehension, that uses backticks for repr conversion. Don't do this. Backticks are deprecated and removed in py3k and more efficient and pythonic way is not to build intermediate list at all, but to use generator expression:

''.join(str(num) for num in xrange(loop_count))        # use range in py3k

Answer 2

That bit in the brackets is a list comprehension, arguably one of the most powerful elements of Python. It produces a list from iteration. You may want to look up its documentation. The use of backticks to convert num to a string is not suggestible - try str(num) or some such instead.

join() is a method of the string class. It takes a list of strings and return a single string consisting of each component string separated by "self" (aka the calling string). The trick here is that join() is being called directly from the string literal '', which is allowed in Python. What this code will to is produce a string consisting of the string form of each element of xrange(loop_count) with no separation.

Answer 3

xrange() is a faster (written in C) version of range().

Backtick notation -- num, coerces a variable to a string, and is the same as str(num).

[x for x in y] is called a list comprehension, and is basically an one-liner for loop that returns a list as its result. So all together, your code's semantically equivalent to the following, but faster, because list comprehensions and xrange are faster than for loops and range:

z = []
for i in range(loop_count):
   z.append(str(i))
return "".join(z)

Answer 4

First of all: while this code is still correct in the 2.x series of Python, it a bit confusing and can be written differently:

def method6a():
    return ''.join(str(num) for num in xrange(loop_count))

In Python 2.x, the backticks can be used instead of the repr function. The expression within the square brackets [] is a list comprehension. In case you are new to list comprehensions: they work like a combination of a loop and a list append-statement, only that you don't have to invent a name for a variable:

Those two are equivalent:

a = [repr(num) for num in xrange(loop_count)]
# <=>
a = []
for num in xrange(loop_count):
    a.append(repr(num))

As a result, the list comprehension will contain a list of all numbers from 0 to loop_count (exclusively).

Finally, string.join(iterable) will use the contents of string concatenate all of the strings in iterable, using string as the seperator between each element. If you use the empty string as the seperator, then all elements are concatenated without anything between them - this is exactly what you wanted: a concatenation of all of the numbers from 0 to loop_count.

As for my modifications:

• I used str instead of repr because the result is the same for all ints and it is easier to read.
• I am using a generator expression instead of a list comprehension because the list built by the list comprehension is unnecessary and gets garbage collected anyway. Generator expressions are iterable, but they don't need to store all elements of the list. Of course, if you already have a list of strings, then simply pass the list to the join.

Generally, the ''.join(iterable) idiom is well understood by most Python programmers to mean "string concatenation of any list of strings", so understandability shouldn't be an issue.