Large persistent memory use from long query

To initialize one of my applications, I need to read over a large (~78MB) XML file and populate a database table. This XML file has about 300,000 entries of interest. I've put the initialization code in my application's __init__.py file. The transaction management is rather crude, but it seemed to work OK during development.

@transaction.commit_manually
def init():
    """
    Read data.xml and populate the table
    """
    from models import Entry

    # If an entry exists already, our task is (presumably) done.
    if Entry.objects.exists():
        transaction.commit()
        return

    # Otherwise, dig in.
    import os
    import xml.etree.ElementTree as ET
    data_path = '/home/.../webapps/.../data.xml'

    # ... gunk ... #

    c = connection.cursor()

    # These are used to track the size of the query and the number of
    # 'insert' statements since the last transaction.
    #  data_count:   number of items per insert
    #  insert_count: number of inserts per commit

    data_count = 0
    insert_count = 0

    query_string = '''INSERT INTO dict_entry
                        (word, data)
                         VALUES (%s,%s)'''
    query_list = []

    context = ET.iterparse(monier)
    for event, elem in context:
        if elem.tag == 'entry':
            # -- Handle the element -- #
            word = elem.find('word').text
            data = ET.tostring(elem)
            query_list.append((word, data))

            # Insert as necessary.
            data_count += 1
            if data_count == 10:
                data_count = 0
                insert_count += 1

                c.executemany(query_string, query_list)
                query_list = []
                if insert_count == 200:
                    transaction.commit()
                    insert_count = 0

            # -- Dispose of the element -- #
            elem.clear()

            # # The lines below, mysteriously, don't work.
            # while elem.getprevious() is not None:
            #    del elem.getparent()[0]
    del context

    # Wrap up.
    c.executemany(query_string, query_list)
    transaction.commit()

While executing, this code peaked at a whopping 242MB of memory, more than three times the size of the input file! [Edit: and the process persisted until I manually killed it.]

PID   RSS COMMAND
17872 242372 /home/.../webapps/.../httpd.worker -f /home/.../webapps/.../httpd.conf -k start

Thankfully, I'll never need to run this function again. But I might need to run functions like it, especially if I'm parsing more XML in the future. Quite simply, my question is: why is this happening? This is what I've considered so far:

• DEBUG = True. Nope, that wasn't the issue. DEBUG is and was False.
• Bad transaction management. I was using commit_on_success earlier, but the process definitely used the version above, which uses commit_manually and commits on every 200 transactions (= every 2000 entries).

Otherwise, I don't know what could be causing this. I'd really appreciate some help. Thanks for reading!