下面的代码迭代地解析XML文件：

import lxml.etree as ET

with open("input.xml", "rb") as f:
    context = ET.iterparse(f)
    for action, elem in context:
        if elem.tag == "field1":
            field1 = elem.text

        if elem.tag == "field2":
            field2 = elem.text

        if elem.tag == "element":
            print(field1, field2)
            field1 = None
            field2 = None

这里lxml以基于事件的方式工作，每次遇到end元素（</xyz>），就会生成一个end事件，并由for循环处理。
变量field1和field2会根据元素结束的位置进行设置，这里隐含的假设是<field1>和<field2>只出现在<element>内部，并且不再嵌套。
如果这些都得到了保证，那么当我们遇到一个结束的</element>时，这两个变量就包含了预期的字符串，如果这些不一定是真的，那么在迭代过程中就需要维护某种状态。
在Python内部，这应该是最快的，因为它只依赖于在事件发生时解析事件，而根本不使用任何XPath。

您可以尝试iterparse：

from lxml import etree as ET

def parse_xml(file_name, tag_name):
    for event, element in ET.iterparse(file_name, tag = tag_name):
        if (element.xpath('field2/text()')):
            yield (element.find('field1').text, element.find('field2').text)

result = [tuple for tuple in parse_xml('input-file.xml', 'element')]

print(result)

这个答案是将备选方案4记录在@CPLTarun的OP中。
注意，这不是可生产的代码。这只是一个快速破解的基准测试。代码可能有bug。而且，它什至不能从python访问读取的数据，它只是把它保存在cython变量中，不断被覆盖。-这段代码并不打算有用，而是为完全充实的代码提供一个运行时的下限。
我可能从别人那里复制了这个代码的 backbone 。如果这个代码是你的，让我知道，我会相信你。
下面是jupyter笔记本上的代码，每个新单元格用#%%表示：

#%%
%load_ext cython

#%% cython SAX parser
%%cython
# distutils: include_dirs = <your liblxml2 include directory>
# distutils: libraries = libxml2
# distutils: library_dirs = <your liblxml2 lib directory>

from lxml.includes.xmlparser cimport (xmlParserCtxt, xmlSAXHandler, 
        xmlCreatePushParserCtxt, xmlParseChunk, xmlFreeParserCtxt, xmlCleanupParser,         
        XML_SAX2_MAGIC, xmlCtxtResetPush,
        startElementNsSAX2Func, endElementNsSAX2Func, charactersSAXFunc)
from libc.string cimport memset, memcpy, strcmp
from libc.stdlib cimport malloc, free
from lxml.includes.tree cimport const_xmlChar

cdef xmlParserCtxt* c_ctxt

cpdef void init_parser():
    global c_ctxt
    cdef xmlSAXHandler SAXHander

    memset(&SAXHander, 0, sizeof(xmlSAXHandler))
    SAXHander.initialized = XML_SAX2_MAGIC
    SAXHander.startElementNs = <startElementNsSAX2Func>OnStartElementNs
    SAXHander.endElementNs = <endElementNsSAX2Func>OnEndElementNs
    SAXHander.characters = <charactersSAXFunc>_handleSaxData

    c_ctxt = xmlCreatePushParserCtxt(&SAXHander, NULL, NULL, 0, NULL)

cpdef void parse_chunk(char* chars):
    global c_ctxt
    xmlParseChunk(c_ctxt, chars, len(chars), 0)
    xmlParseChunk(c_ctxt, NULL, 0, 1)
    xmlCtxtResetPush(c_ctxt, NULL, 0, NULL, NULL)

cpdef void cleanup_parser():
    global c_ctxt
    xmlFreeParserCtxt(c_ctxt)
    xmlCleanupParser()

cdef char* field2 = NULL
cdef char* field1 = NULL
cdef char* element = NULL

cdef char* FIELD1 = b'field1'
cdef char* FIELD2 = b'field2'

cdef void OnStartElementNs(void* ctx,
                           const_xmlChar* localname,
                           const_xmlChar* prefix,
                           const_xmlChar* URI,
                           int nb_namespaces,
                           const_xmlChar** namespaces,
                           int nb_attributes,
                           int nb_defaulted,
                           const_xmlChar** attributes):
    c_ctxt = <xmlParserCtxt*>ctx

    global element

    if strcmp(<char*>localname, b'field2') == 0:
        element = FIELD2
    elif strcmp(<char*>localname, b'field1') == 0:
        element = FIELD1

cdef void OnEndElementNs(void* ctx,
                           const_xmlChar* localname,
                           const_xmlChar* prefix,
                           const_xmlChar* URI):
    c_ctxt = <xmlParserCtxt*>ctx
    global element
    if strcmp(<char*>localname, b'element') == 0:
        if strcmp(field2, b'') != 0:
            element= NULL
    else:
        element = NULL

cdef void _handleSaxData(void* ctxt, const_xmlChar* c_data, int data_len):
    # can only be called if parsing with a target
    global field2, field1
    if element == FIELD1:
        if field1 is not NULL:
            free(field1)
        field1 = <char*>malloc(sizeof(char) * (data_len+1))
        field1[data_len] = 0
        memcpy(field1, c_data, data_len)
    if element == FIELD2:
        if field2 is not NULL:
            free(field2)
        field2 = <char*>malloc(sizeof(char) * data_len+1)
        field2[data_len] = 0
        memcpy(field2, c_data, data_len)

#%% cython libxml
%%timeit -r20
with open('benchmark.xml', 'rb') as file:
    xml = file.read()
init_parser()
parse_chunk(xml)
cleanup_parser()

注意：在清理之前，你可以在处理多个文件时只初始化解析器一次，这样可以保存时间。