I am generating sql query and perfoming a lot of += operations on my string. It looks like:
insert_string = 'INSERT INTO ' + table_name + ' VALUES '
for row in data_frame.iterrows():
raw_row = row[1].values
insert_string += str(tuple(raw_row))
So if my insert_string are immutable every += operation creates new string. For example, in C# there is StringBuilder class for this, that could initialise empty string with given capacity. How can i do it in Python?
Perhaps the most common way is to create a list of all the pieces, and join them with the str.join method, like this:
pieces = ['a', 'b', 'c']
text = ''.join(pieces)
assert text == 'abc'
Note that you call the join method on the separator that will come between the pieces. In the previous example, that was the empty string, but in your case you might actually want something like a space or even a newline:
pieces = ['a', 'b', 'c']
text = '\n'.join(pieces)
Additionally, you could get a file-like interface by using the io.StringIO class:
with io.StringIO() as query_str:
query_str.write('INSERT INTO ')
query_str.write(table_name)
query_str.write(' VALUES ')
for row in data_frame.iterrows():
raw_row = row[1].values
query_str.write(str(tuple(raw_row)))
# Use query_str.getvalue(), as it will be deleted
# when the 'with' scope is finished.
what you are probably looking for is StringIO, which presents a file-like interface to a list of strings, and allows you to extract a single string at the end:
import StringIO
builder = StringIO.StringIO()
builder.write('INSERT INTO ')
builder.write(table_name)
builder.write(' VALUES ')
for row in data_frame.iterrows():
raw_row = row[1].values
builder.write(str(tuple(raw_row)))
insert_string = builder.getvalue()
Although, most python users are happy with using a list directly, as in Rafael's answer. For completeness here's your code translated to that style:
builder = ['INSERT INTO ', table_name, ' VALUES ']
for row in data_frame.iterrows():
raw_row = row[1].values
builder.append(str(tuple(raw_row)))
insert_string = ''.join(builder)
In the odd case that someone viewing this question actually needs a mutable string; I'm sorry to say that there's nothing quite like that, and the solution depends a bit on the exact problem you're trying to solve. If you need a mutable byte string, that's available, builtin, as bytearray.
>>> b
bytearray(b'xaby')
>>> b[1:3] = b'yz'
>>> b
bytearray(b'xyzy')
>>> b.extend(b'foonly')
>>> b
bytearray(b'xyzyfoonly')
there's no equivalent action for str, though.
Here is a good article on Efficient String Concatenation in Python which very much fits your problem.
tl;dr: Use join with a list comprehension:
''.join([str(tuple(row[1].values)) for row in data_frame.iterrows()])
In Python 2, there is a module called UserString that contains MutableString.
from UserString import *
myString = MutableString('String')
myString.pop(0)
myString[1] = 'h'
print myString # prints 'thing'
