{"id":25122,"date":"2020-04-01T12:15:16","date_gmt":"2020-04-01T09:15:16","guid":{"rendered":"https:\/\/www.webcodegeeks.com\/?p=25122"},"modified":"2020-06-23T14:48:32","modified_gmt":"2020-06-23T11:48:32","slug":"how-to-convert-a-string-to-lowercase-in-python","status":"publish","type":"post","link":"https:\/\/www.webcodegeeks.com\/python\/how-to-convert-a-string-to-lowercase-in-python\/","title":{"rendered":"How to Convert a String to Lowercase in Python"},"content":{"rendered":"\n

As this series grows, I\u2019ve started poking at seemingly simple problems to expose their complexity. This time, I thought it would be interesting to look at how to convert a string to lowercase.<\/p>\n\n\n\n

As it turns out, there\u2019s a really straightforward solution (lower()<\/code>), but I think it\u2019s worth looking at a few homemade solutions first. For instance, we could try building up a string by looping over every character. If that sounds interesting, check out the rest of this article. <\/p>\n\n\n\n

Problem Description<\/h2>\n\n\n\n

If you\u2019ve ever tried to write code which manipulates strings, you know how painful of a process it can be. For instance, try writing some code to reverse a string. Pro tip<\/strong>: it\u2019s not as easy as you think. I know this because I added string reversal as one of the challenges in our Sample Programs repository<\/a>.<\/p>\n\n\n\n

When I was building up that repo, I found out that you can\u2019t just start at the end of the string and print out the characters in reverse. That\u2019ll work for simple strings like most of the text in this article. However, it could fail for more complex characters like emojis.<\/p>\n\n\n\n

All that said, Python 3<\/strong> does a great job of abstracting characters, so you may not run into issues. For example, the following code seems to work fine:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n<\/td>\n
\n
\n
>>> hero = <\/code>\"\ud83d\ude0a\"<\/code><\/div>\n
>>> hero[::-<\/code>1<\/code>]<\/code><\/div>\n
'\ud83d\ude0a'<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Now, I bring this up because today we want to talk about converting a string to lowercase. If you\u2019ve been around Python awhile, you know there\u2019s a quick way to do this. However, if you haven\u2019t, there\u2019s a chance you might try to do it yourself (or you have to do it yourself for a course). As a result, I\u2019ll be setting a constraint for this entire article: assume ASCII<\/strong>.<\/p>\n\n\n\n

This constraint can save us a lot of pain and suffering. It basically restricts us to the first 128 characters (or 256 depending on who you ask). That way, we don\u2019t have to worry about dealing with characters from other languages or emojis.<\/p>\n\n\n\n

Assuming ASCII, we should be able to convert a string like \u201cAll Might\u201d to \u201call might\u201d fairly easily. In the sections below, we\u2019ll look at a few solutions that will be able to do just this.<\/p>\n\n\n\n

Solutions<\/h2>\n\n\n\n

In this section, we\u2019ll take a look at each solution I could come up with. Since this problem has been trivially solved by the lower()<\/code> method, most of these solutions are essentially brute force. In other words, each solution goes through a different strategy for converting a string to lowercase by hand. If that\u2019s not you\u2019re thing, feel free to jump to the last solution. For everyone else, let\u2019s take a look at our first brute force solution!<\/p>\n\n\n\n

Convert a String to Lowercase by Brute Force<\/h3>\n\n\n\n

Since we\u2019re assuming ASCII, we can try to convert our string to lowercase by looking at the ordinal values of each character. In other words, each character is assigned to some number. If a character\u2019s ID falls within the range of capital letters, we should be able to find its corresponding lowercase ID and replace it. That\u2019s exactly what we do below:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n
7<\/div>\n<\/td>\n
\n
\n
hero = <\/code>\"All Might\"<\/code><\/div>\n
output = <\/code>\"\"<\/code><\/div>\n
for<\/code> char<\/code> in hero:<\/code><\/div>\n
  <\/code>if<\/code> \"A\"<\/code> <= <\/code>char<\/code> <= <\/code>\"Z\"<\/code>:<\/code><\/div>\n
    <\/code>output += chr(ord(<\/code>char<\/code>) - ord(<\/code>'A'<\/code>) + ord(<\/code>'a'<\/code>))<\/code><\/div>\n
  <\/code>else<\/code>:<\/code><\/div>\n
    <\/code>output += <\/code>char<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Here, we create a string called hero<\/code> which stores the name \u201cAll Might\u201d. Then, we create an empty output string. After that, we loop over every character in the string checking to see if the current character falls in the range of capital letters. If it does, we convert it to lowercase with this clever little expression:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n<\/td>\n
\n
\n
chr(ord(<\/code>char<\/code>) - ord(<\/code>'A'<\/code>) + ord(<\/code>'a'<\/code>))<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

By subtracting ord('A')<\/code>, we get the index of the character in the alphabet. For example, if char<\/code> was \u201cC\u201d, the expression ord(char) - ord('A')<\/code> would be 2. Then, all we need to know is what the ordinal value of \u2018a\u2019 is to shift our index into the range of lowercase letters. In other words, this expression converts any uppercase letter to lowercase.<\/p>\n\n\n\n

One thing I don\u2019t love about this algorithm is the concatenation. In general, it\u2019s a bad idea to concatenate strings in a loop like this. As a result, we could use a list instead:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n
7<\/div>\n
8<\/div>\n<\/td>\n
\n
\n
hero = <\/code>\"All Might\"<\/code><\/div>\n
output = []<\/code><\/div>\n
for<\/code> char<\/code> in hero:<\/code><\/div>\n
  <\/code>if<\/code> \"A\"<\/code> <= <\/code>char<\/code> <= <\/code>\"Z\"<\/code>:<\/code><\/div>\n
    <\/code>output.append(chr(ord(<\/code>char<\/code>) - ord(<\/code>'A'<\/code>) + ord(<\/code>'a'<\/code>)))<\/code><\/div>\n
  <\/code>else<\/code>:<\/code><\/div>\n
    <\/code>output.append(<\/code>char<\/code>)<\/code><\/div>\n
output = <\/code>\"\"<\/code>.join(output)<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

In the performance section, we\u2019ll take a look to see if this matters at all. For now though, let\u2019s dig into some better options.<\/p>\n\n\n\n

Convert a String to Lowercase Using ASCII Collections<\/h3>\n\n\n\n

In the previous solution, we computed lowercase values mathematically. However, what if we just happened to have the lowercase and uppercase letters available to us as a collection? As it turns out, the string library has us covered:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n<\/td>\n
\n
\n
from string <\/code>import<\/code> ascii_lowercase, ascii_uppercase<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

If you\u2019re curious to know what these values look like, I checked for us:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n<\/td>\n
\n
\n
>>> ascii_lowercase<\/code><\/div>\n
'abcdefghijklmnopqrstuvwxyz'<\/code><\/div>\n
>>> ascii_uppercase<\/code><\/div>\n
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

As we can see, each value is a string containing the alphabet. Now, it\u2019s just a matter of mapping from one set to the other given an index:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n
7<\/div>\n
8<\/div>\n<\/td>\n
\n
\n
hero = <\/code>\"All Might\"<\/code><\/div>\n
output = []<\/code><\/div>\n
for<\/code> char<\/code> in hero:<\/code><\/div>\n
  <\/code>if<\/code> char<\/code> in ascii_uppercase:<\/code><\/div>\n
    <\/code>output.append(ascii_lowercase[ascii_uppercase.index(<\/code>char<\/code>)])<\/code><\/div>\n
  <\/code>else<\/code>:<\/code><\/div>\n
    <\/code>output.append(<\/code>char<\/code>)<\/code><\/div>\n
output = <\/code>\"\"<\/code>.join(output)<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Again, we loop over every character in our string. Of course, this time we check if that character is in the uppercase set. If it is, we look for the corresponding lowercase character and add it to our final string. Otherwise, we append the original character.<\/p>\n\n\n\n

Personally, I like this solution a little bit better because we\u2019re more explicitly dealing with certain sets of characters. That said, there is still a better solution ahead.<\/p>\n\n\n\n

Convert a String to Lowercase Using a List Comprehension<\/h3>\n\n\n\n

Looking at the solutions above, I thought it might be fun to try to use a list comprehension. It\u2019s not pretty, but it gets the job done:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n<\/td>\n
\n
\n
from string <\/code>import<\/code> ascii_uppercase, ascii_lowercase<\/code><\/div>\n
 <\/div>\n
hero = <\/code>\"All Might\"<\/code><\/div>\n
output = [ascii_lowercase[ascii_uppercase.index(<\/code>char<\/code>)] <\/code>if<\/code> char<\/code> in ascii_uppercase <\/code>else<\/code> char<\/code> for<\/code> char<\/code> in hero]<\/code><\/div>\n
output = <\/code>\"\"<\/code>.join(output)<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

If you\u2019d prefer something a little more readable, here\u2019s the same list comprehension with the expression separate from the loop:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n<\/td>\n
\n
\n
[<\/code><\/div>\n
  <\/code>ascii_lowercase[ascii_uppercase.index(<\/code>char<\/code>)] <\/code><\/div>\n
    <\/code>if<\/code> char<\/code> in ascii_uppercase <\/code><\/div>\n
    <\/code>else<\/code> char<\/code><\/div>\n
  <\/code>for<\/code> char<\/code> in hero<\/code><\/div>\n
]<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Basically, we say that for each character in hero<\/code>, assume we\u2019re going to convert uppercase to lowercase. Otherwise, leave the character unchanged.<\/p>\n\n\n\n

Honestly, this might be a bit cleaner if we pulled the expression out into a function:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n<\/td>\n
\n
\n
def to_lowercase(<\/code>char<\/code>: str):<\/code><\/div>\n
  <\/code>if<\/code> char<\/code> in ascii_uppercase:<\/code><\/div>\n
    <\/code>return<\/code> ascii_lowercase[ascii_uppercase.index(<\/code>char<\/code>)]<\/code><\/div>\n
  <\/code>else<\/code>:<\/code><\/div>\n
    <\/code>return<\/code> char<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Then, we could call this function in place of that mess:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n<\/td>\n
\n
\n
[to_lowercase(<\/code>char<\/code>) <\/code>for<\/code> char<\/code> in hero]<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Now, that\u2019s a lot cleaner! Of course, there is definitely a better solution to follow. That said, if you like list comprehensions, and you want to learn more about them, check out my article on how to write list comprehensions<\/a>.<\/p>\n\n\n\n

Convert a String to Lowercase Using the lower()<\/code> Method<\/h3>\n\n\n\n

Up to this point, we tried rolling our own lowercase function. Due to the complexity of strings, it turned out to be a nontrivial matter. Luckily, the Python developers knew this would be a popular request, so they wrote a method for us:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n<\/td>\n
\n
\n
hero = <\/code>\"All Might\"<\/code><\/div>\n
hero.lower()<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

And, that\u2019s it! In one line, we can convert a string to lowercase.<\/p>\n\n\n\n

Since we assumed ASCII up to this point, there\u2019s not much to say in terms of the benefits with this solution. Sure, lower()<\/code> is likely more convenient and faster than our previous solutions, but our assumption has stopped us from talking about the real benefit: it works beyond ASCII.<\/p>\n\n\n\n

Unlike our previous solutions, this solution will work for basically any locale where the concepts of uppercase and lowercase make sense. In other words, lower()<\/code> should work in contexts beyond ASCII. If you\u2019re interested in how it works under the hood, check out section 3.13 of the Unicode standard<\/a>.<\/p>\n\n\n\n

Performance<\/h2>\n\n\n\n

At this point, let\u2019s take a look at how each solution compares in terms of performance. If you\u2019ve been around awhile, you know we start off testing by storing each solution in a string. If this is your first time seeing one of these tutorials, you can get up to speed on performance testing with this article<\/a>. Otherwise, here are the strings:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n
14<\/div>\n
15<\/div>\n
16<\/div>\n
17<\/div>\n
18<\/div>\n
19<\/div>\n
20<\/div>\n
21<\/div>\n
22<\/div>\n
23<\/div>\n
24<\/div>\n
25<\/div>\n
26<\/div>\n
27<\/div>\n
28<\/div>\n
29<\/div>\n
30<\/div>\n
31<\/div>\n
32<\/div>\n
33<\/div>\n
34<\/div>\n
35<\/div>\n
36<\/div>\n
37<\/div>\n
38<\/div>\n
39<\/div>\n
40<\/div>\n
41<\/div>\n
42<\/div>\n<\/td>\n
\n
\n
setup = <\/code>\"\"<\/code>\"<\/code><\/div>\n
hero = <\/code>\"All Might\"<\/code><\/div>\n
from string <\/code>import<\/code> ascii_lowercase, ascii_uppercase<\/code><\/div>\n
\"\"<\/code>\"<\/code><\/div>\n
 <\/div>\n
brute_force_concat = <\/code>\"\"<\/code>\"<\/code><\/div>\n
output = <\/code>\"\"<\/code><\/div>\n
for<\/code> char<\/code> in hero:<\/code><\/div>\n
  <\/code>if<\/code> \"A\"<\/code> <= <\/code>char<\/code> <= <\/code>\"Z\"<\/code>:<\/code><\/div>\n
    <\/code>output += chr(ord(<\/code>char<\/code>) - ord(<\/code>'A'<\/code>) + ord(<\/code>'a'<\/code>))<\/code><\/div>\n
  <\/code>else<\/code>:<\/code><\/div>\n
    <\/code>output += <\/code>char<\/code><\/div>\n
\"\"<\/code>\"<\/code><\/div>\n
 <\/div>\n
brute_force_list = <\/code>\"\"<\/code>\"<\/code><\/div>\n
output = []<\/code><\/div>\n
for<\/code> char<\/code> in hero:<\/code><\/div>\n
  <\/code>if<\/code> \"A\"<\/code> <= <\/code>char<\/code> <= <\/code>\"Z\"<\/code>:<\/code><\/div>\n
    <\/code>output.append(chr(ord(<\/code>char<\/code>) - ord(<\/code>'A'<\/code>) + ord(<\/code>'a'<\/code>)))<\/code><\/div>\n
  <\/code>else<\/code>:<\/code><\/div>\n
    <\/code>output.append(<\/code>char<\/code>)<\/code><\/div>\n
output = <\/code>\"\"<\/code>.join(output)<\/code><\/div>\n
\"\"<\/code>\"<\/code><\/div>\n
 <\/div>\n
ascii_collection = <\/code>\"\"<\/code>\"<\/code><\/div>\n
output = []<\/code><\/div>\n
for<\/code> char<\/code> in hero:<\/code><\/div>\n
  <\/code>if<\/code> char<\/code> in ascii_uppercase:<\/code><\/div>\n
    <\/code>output.append(ascii_lowercase[ascii_uppercase.index(<\/code>char<\/code>)])<\/code><\/div>\n
  <\/code>else<\/code>:<\/code><\/div>\n
    <\/code>output.append(<\/code>char<\/code>)<\/code><\/div>\n
output = <\/code>\"\"<\/code>.join(output)<\/code><\/div>\n
\"\"<\/code>\"<\/code><\/div>\n
 <\/div>\n
list_comp = <\/code>\"\"<\/code>\"<\/code><\/div>\n
output = [ascii_lowercase[ascii_uppercase.index(<\/code>char<\/code>)] <\/code>if<\/code> char<\/code> in ascii_uppercase <\/code>else<\/code> char<\/code> for<\/code> char<\/code> in hero]<\/code><\/div>\n
output = <\/code>\"\"<\/code>.join(output)<\/code><\/div>\n
\"\"<\/code>\"<\/code><\/div>\n
 <\/div>\n
lower_method = <\/code>\"\"<\/code>\"<\/code><\/div>\n
output = hero.lower()<\/code><\/div>\n
\"\"<\/code>\"<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Then, if we want to performance test these solutions, we can import the timeit<\/code> library and run the repeat()<\/code> method:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n<\/td>\n
\n
\n
>>> <\/code>import<\/code> timeit<\/code><\/div>\n
>>> min(timeit.repeat(setup=setup, stmt=brute_force_concat))<\/code><\/div>\n
1.702892600000041<\/code><\/div>\n
>>> min(timeit.repeat(setup=setup, stmt=brute_force_list))<\/code><\/div>\n
1.9661427000000913<\/code><\/div>\n
>>> min(timeit.repeat(setup=setup, stmt=ascii_collection))<\/code><\/div>\n
1.5348989000001438<\/code><\/div>\n
>>> min(timeit.repeat(setup=setup, stmt=list_comp))<\/code><\/div>\n
1.4514239000000089<\/code><\/div>\n
>>> min(timeit.repeat(setup=setup, stmt=lower_method))<\/code><\/div>\n
0.07294070000011743<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Unsurprisingly, the lower()<\/code> method is incredibly fast. We\u2019re talking a 100 times faster than our brute force solutions. That said, I was actually surprised by the minor improvement in speed that concatenation has over using a list in our example. As a result, I decided to use a larger string for testing:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n
14<\/div>\n<\/td>\n
\n
\n
>>> setup = <\/code>\"\"<\/code>\"<\/code><\/div>\n
hero = <\/code>\"If you feel yourself hitting up against your limit remember for what cause you clench your fists... remember why you started down this path, and let that memory carry you beyond your limit.\"<\/code><\/div>\n
from string <\/code>import<\/code> ascii_lowercase, ascii_uppercase<\/code><\/div>\n
\"\"<\/code>\"<\/code><\/div>\n
>>> min(timeit.repeat(setup=setup, stmt=brute_force_concat))<\/code><\/div>\n
22.304970499999996<\/code><\/div>\n
>>> min(timeit.repeat(setup=setup, stmt=brute_force_list))<\/code><\/div>\n
24.565209700000025<\/code><\/div>\n
>>> min(timeit.repeat(setup=setup, stmt=ascii_collection))<\/code><\/div>\n
19.60345490000003<\/code><\/div>\n
>>> min(timeit.repeat(setup=setup, stmt=list_comp))<\/code><\/div>\n
13.309821600000078<\/code><\/div>\n
>>> min(timeit.repeat(setup=setup, stmt=lower_method))<\/code><\/div>\n
0.16421549999995477<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Somehow, concatenation is still a little bit faster than using a list. This surprised me a lot. After all, pretty much all literature points to concatenation being a bad idea<\/a>, so I was a bit stumped. As a result, I actually went as far as to duplicate the test code from that article above to see if I was doing something wrong in my testing:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n
14<\/div>\n
15<\/div>\n
16<\/div>\n
17<\/div>\n
18<\/div>\n
19<\/div>\n
20<\/div>\n
21<\/div>\n<\/td>\n
\n
\n
>>> setup = <\/code>\"\"<\/code>\"<\/code><\/div>\n
hero = <\/code>\"All Might\"<\/code><\/div>\n
loop_count = <\/code>500<\/code><\/div>\n
from string <\/code>import<\/code> ascii_lowercase, ascii_uppercase<\/code><\/div>\n
 <\/div>\n
def method1():<\/code><\/div>\n
  <\/code>out_str = <\/code>''<\/code><\/div>\n
  <\/code>for<\/code> num in range(loop_count):<\/code><\/div>\n
    <\/code>out_str += str(num)<\/code><\/div>\n
  <\/code>return<\/code> out_str<\/code><\/div>\n
 <\/div>\n
def method4():<\/code><\/div>\n
  <\/code>str_list = []<\/code><\/div>\n
  <\/code>for<\/code> num in range(loop_count):<\/code><\/div>\n
    <\/code>str_list.append(str(num))<\/code><\/div>\n
  <\/code>return<\/code> ''<\/code>.join(str_list)<\/code><\/div>\n
\"\"<\/code>\"<\/code><\/div>\n
>>> min(timeit.repeat(setup=setup, stmt=<\/code>\"method1()\"<\/code>))<\/code><\/div>\n
156.1076584<\/code><\/div>\n
>>> min(timeit.repeat(setup=setup, stmt=<\/code>\"method4()\"<\/code>))<\/code><\/div>\n
124.92521890000012<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

To me, there\u2019s one of two things going on:<\/p>\n\n\n\n