I would recommend pandasread_xml() and to_csv() function, 3-liner:

Compare the documentation: to_csv, read_xml

import pandas as pd

df = pd.read_xml('employee.xml')
df.to_csv('out.csv', index=False)

Output -> (CSV-file):

id,name,age,salary,division
303,varma,20,120000,3
304,Cyril,20,900000,3
305,Yojith,20,900000,3

Using pandas and BeautifulSoup you can achieve your expected output easily:

#Code:

import pandas as pd
import itertools
from bs4 import BeautifulSoup as b
with open("file.xml", "r") as f: # opening xml file
    content = f.read()

soup = b(content, "lxml")
pkgeid =  [ values.text for values in soup.findAll("pkgeid")]
pkgname = [ values.text for values in soup.findAll("pkgname")]
time =  [ values.text for values in soup.findAll("time")]
oper =  [ values.text for values in soup.findAll("oper")]
# For python-3.x use `zip_longest` method
# For python-2.x use 'izip_longest method
data = [item for item in itertools.zip_longest(time, oper, pkgeid, pkgname)] 
df  = pd.DataFrame(data=data)
df.to_csv("sample.csv",index=False, header=None)

#output in `sample.csv` file will be as follows:
2015-09-16T04:13:20Z,Create_Product,10,BBCWRL
2015-09-16T04:13:20Z,Create_Product,18,CNNINT
2018-04-01T03:30:28Z,Deactivate_Dhct,,

This is a namespaced XML document. Therefore you need to address the nodes using their respective namespaces.

The namespaces used in the document are defined at the top:

xmlns:tc2="http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tp1="http://www.garmin.com/xmlschemas/TrackPointExtension/v1"
xmlns="http://www.topografix.com/GPX/1/1"

So the first namespace is mapped to the short form tc2, and would be used in an element like <tc2:foobar/>. The last one, which doesn't have a short form after the xmlns, is called the default namespace, and it applies to all elements in the document that don't explicitely use a namespace - so it applies to your <trkpt /> elements as well.

Therefore you would need to write root.iter('{http://www.topografix.com/GPX/1/1}trkpt') to select these elements.

In order to also get time and elevation, you can use trkpt.find() to access these elements below the trkpt node, and then element.text to retrieve those elements' text content (as opposed to attributes like lat and lon). Also, because the time and ele elements also use the default namespace you'll have to use the {namespace}element syntax again to select those nodes.

So you could use something like this:

NS = 'http://www.topografix.com/GPX/1/1'
header = ('lat', 'lon', 'ele', 'time')

with open('output.csv', 'w') as f:
    writer = csv.writer(f)
    writer.writerow(header)
    root = lxml.etree.fromstring(x)
    for trkpt in root.iter('{%s}trkpt' % NS):
        lat = trkpt.get('lat')
        lon = trkpt.get('lon')
        ele = trkpt.find('{%s}ele' % NS).text
        time = trkpt.find('{%s}time' % NS).text

        row = lat, lon, ele, time
        writer.writerow(row)

For more information on XML namespaces, see the Namespaces section in the lxml tutorial and the Wikipedia article on XML Namespaces. Also see GPS eXchange Format for some details on the .gpx format.

Use csv.DictWriter, get values from node.attrib dictionary

Your elements named TrdCapRpt have attributes, if you have such node, its attribute node.attrib holds a dictionary with key/value for each attribute.

csv.DictWriter allows writing data taken from dictionary.

First some imports (I always use lxml as it is very fast and provides extra features):

from lxml import etree
import csv

Configure file names and fields to use in each record:

xml_fname = "data.xml"
csv_fname = "data.csv"

fields = [
    "RptID", "TrdTyp", "TrdSubTyp", "ExecID", "TrdDt", "BizDt", "MLegRptTyp",
    "MtchStat" "MsgEvtSrc", "TrdID", "LastQty", "LastPx", "TxnTm", "SettlCcy",
    "SettlDt", "PxSubTyp", "VenueTyp", "VenuTyp", "OfstInst"]

Read the XML:

xml = etree.parse(xml_fname)

Iterate over elements "TrdCapRpt", write attribute values to CSV file:

with open(csv_fname, "w") as f:

    writer = csv.DictWriter(f, fields, delimiter=";", extrasaction="ignore")
    writer.writeheader()
    for node in xml.iter("TrdCaptRpt"):
        writer.writerow(node.attrib)

If you prefer using stdlib xml.etree.ElementTree, you shall manage easily as you do now, because the node.attrib is present there too.

Reading from multiple element names

In your comments, you noted, that you want to export attributes from more element names. This is also possible. To do this, I will modify the example to use xpath (which will probably work only with lxml) and add extra column "elm_name" to track, from which element is the record created:

fields = [
    "elm_name",

    "RptID", "TrdTyp", "TrdSubTyp", "ExecID", "TrdDt", "BizDt", "MLegRptTyp",
    "MtchStat" "MsgEvtSrc", "TrdID", "LastQty", "LastPx", "TxnTm", "SettlCcy",
    "SettlDt", "PxSubTyp", "VenueTyp", "VenuTyp", "OfstInst",

    "Typ", "Amt", "Ccy"
]

xml = etree.parse(xml_fname)

with open(csv_fname, "w") as f:

    writer = csv.DictWriter(f, fields, delimiter=";", extrasaction="ignore")
    writer.writeheader()
    for node in xml.xpath("//*[self::TrdCaptRpt or self::PosRpt or self::Amt]"):
        atts = node.attrib
        atts["elm_name"] = node.tag
        writer.writerow(node.attrib)

The modifications are:

• fields got extra "elm_name" field and fields from other elements (feel free to remove those you are not interested at).
• iterate over elements using xml.xpath. The XPath expression is more complex so I am not sure, if stdlib ElementTree supports that.
• before writing the record, I add name of the element into atts dictionary to provide name of the element.

Warning: the element Amt is nested inside PosRpt and this tree structure is not possible to support in CSV. The records are written, but do not hold information about where they come from (apart from following the record for parent element).

Do not use the findall function, as it will look for att tags in the whole tree. Just iterate the tree in order from top to bottom and grab the relevant elements in them.

from xml.etree import ElementTree
tree = ElementTree.parse('input.xml')
root = tree.getroot()

for att in root:
    first = att.find('attval').text
    for subatt in att.find('children'):
        second = subatt.find('attval').text
        print('{},{}'.format(first, second))

Which gives:

$ python process.py 
Data,Studyval
Data,Site
Info,age
Info,gender

You probably don't need to go through ElementTree; you can feed the xml directly to pandas. If I understand you correctly, this should do it:

df = pd.read_xml(path_to_file,"//*[local-name()='MainVIP']")
df = df.iloc[:,:4]
df

Output from your xml above:

    Date    RegisteredDate  Type    TypeDescription
0   20210616    20210216    YMBA    TYPE OF ENQUIRY

I'd do this in a very explicit way rather than trying to hack xmltodict to fit your needs.

The only downside I see with this approach is a bit of repetition with the hardcoded headers and tags names.

Also, I don't know how regular you input XML is going to be. If it's possible that some of the tags will not be present then you will need to add some error handling (because node.find will return None, then .text will cause an AttributeError).

rows = []
for abc_node in tree.findall('abc'):
    rate_node = abc_node.find('Rate')
    fee_node = abc_node.find('fee')
    row = {'id': abc_node.find('id').text,
           'uniqueid': abc_node.find('uniqueid').text,
           'Name': abc_node.find('Name').text,
           'rate_mrp': rate_node.find('mrp').text,
           'rate_discount': rate_node.find('discount').text,
           'rate_discountmonths': rate_node.find('discountmonths').text,
           'fee_type': fee_node.find('type').text,
           'fee_minimumfee': fee_node.find('minimumfee').text,
           'fee_maxfee': fee_node.find('maxfee').text}
    rows.append(row)

with open('test.csv', 'w', encoding='utf8') as f:
    headers = ['id', 'uniqueid', 'Name', 'rate_mrp', 'rate_discount', 'rate_discountmonths',
               'fee_type', 'fee_minimumfee', 'fee_maxfee']
    dict_writer = csv.DictWriter(f, fieldnames=headers, lineterminator='\n')
    dict_writer.writeheader()
    dict_writer.writerows(rows)

Output

id,uniqueid,Name,rate_mrp,rate_discount,rate_discountmonths,fee_type,fee_minimumfee,fee_maxfee
23,23_0,,6.40000,10.00%,2,off,"£1,500.75",£10K
35,35_0,,7.90000,5.00%,5,offer,£1k,"£22,000" 

If you want | as delimiter just add delimiter='|' to csv.DictWriter(f, fieldnames=headers, lineterminator='\n')

then the output is

id|uniqueid|Name|rate_mrp|rate_discount|rate_discountmonths|fee_type|fee_minimumfee|fee_maxfee
23|23_0||6.40000|10.00%|2|off|£1,500.75|£10K
35|35_0||7.90000|5.00%|5|offer|£1k|£22,000

The lxml library is capable of very powerful XML parsing, and can be used to iterate over an XML tree to search for specific elements.

from lxml import etree

with open(r'path/to/xml', 'r') as xml:
    text = xml.read()
tree = lxml.etree.fromstring(text)
row = ['', '']
for item in tree.iter('hw', 'def'):
    if item.tag == 'hw':
       row[0] = item.text
    elif item.tag == 'def':
       row[1] = item.text

line = ','.join(row)

with open(r'path/to/csv', 'a') as csv:
     csv.write(line + '\n')

How you build the CSV file is largely based upon preference, but I have provided a trivial example above. If there are multiple <dps-data> tags, you could extract those elements first (which can be done with the same tree.iter method shown above), and then apply the above logic to each of them.

EDIT: I should point out that this particular implementation reads the entire XML file into memory. If you are working with a single 150mb file at a time, this should not be a problem, but it's just something to be aware of.

ElementTree is a python XML parser ( https://docs.python.org/2/library/xml.etree.elementtree.html )

parse the XML literals in the CSV cells as strings, then iterate through the elements and resave them :

from xml.etree.ElementTree import XML

parsed = XML('''
<root>
  <group>
    <child id="a">This is child "a".</child>
    <child id="b">This is child "b".</child>
  </group>                                     // replace this with a variable that contains your XML string literals
  <group>
    <child id="c">This is child "c".</child>
  </group>
</root>
''')

print 'parsed =', parsed

for elem in parsed:
    print elem.tag
    if elem.text is not None and elem.text.strip():
        print '  text: "%s"' % elem.text
    if elem.tail is not None and elem.tail.strip():
        print '  tail: "%s"' % elem.tail
    for name, value in sorted(elem.attrib.items()):
        print '  %-4s = "%s"' % (name, value)
    print

source :https://pymotw.com/2/xml/etree/ElementTree/parse.html#parsing-strings

alternatively you can convert the XML cells directly :

http://blog.appliedinformaticsinc.com/how-to-parse-and-convert-xml-to-csv-using-python/

There are various technologies for streamed processing of XML. One of them is XSLT 3.0, where you would write

<xsl:mode streamable="yes"/>
<xsl:output method="text"/>
<xsl:template match="row">
  <xsl:value-of select="@Id, @UserId, @Name, @Class, @TagBased"
     separator=","/>
  <xsl:text>&#xa;</xsl:text>
</xsl:template>

use xml.etree.ElementTree and csv modules:

import xml.etree.ElementTree as et
import csv

tree = et.parse('node.xml')
nodes = tree.getroot()
with open('node.csv', 'w') as ff:
    cols = ['id','x','y','type']
    nodewriter = csv.writer(ff)
    nodewriter.writerow(cols)
    for node in nodes:
        values = [ node.attrib[kk] for kk in cols]
        nodewriter.writerow(values)

You can use findall function.

import xml.etree.ElementTree as ET
import csv

tree = ET.parse("/temp/test.xml")
root = tree.getroot()

f = open('/temp/test.csv', 'w')

csvwriter = csv.writer(f)

count = 0

head = ['Job Name','Task Name','Staff Name','Date','Minutes','Billable']

csvwriter.writerow(head)

for time in root.findall('Time'):
    row = []
    job_name = time.find('Job').find('Name').text
    row.append(job_name)
    task_name = time.find('Task').find('Name').text
    row.append(task_name)
    staff_name = time.find('Staff').find('Name').text
    row.append(staff_name)
    date = time.find('Date').text
    row.append(date)
    minutes = time.find('Minutes').text
    row.append(minutes)
    billable = time.find('Billable').text
    row.append(billable)
    csvwriter.writerow(row)
f.close()

Which gives:

Job Name,Task Name,Staff Name,Date,                Minutes,Billable
 My Job , My Task , My Name , 2017-05-19T00:00:00 , 480 , true 

I'm not familiar with "Magento", but this program converts your XML file to a CSV file. The resulting CSV file has one column for Name and one column for each Value.

from xml.etree import ElementTree as ET
import csv

tree = ET.parse('x.xml')
root = tree.getroot()

columns = ['Name'] + [
    value.attrib.get('AttributeID').encode('utf-8')
    for value in tree.findall('.//Product//Value')]

with open('x.csv', 'w') as ofile:
    ofile = csv.DictWriter(ofile, set(columns))
    ofile.writeheader()
    for product in tree.findall('.//Product'):
        d = {value.attrib.get('AttributeID').encode('utf-8'):
             (value.text or '').encode('utf-8')
             for value in product.findall('.//Values/Value')}
        d['Name'] = product.findtext('Name')
        ofile.writerow(d)

Use the code provided by Nk03 to convert the XML you're loading to a python dictionary.

import xmltodict

d = xmltodict.parse("""
<D1>
    <RECORD>
            <ELEC>EL-13</ELEC>
            <VAL>10</VAL>
            <POWER>Max</POWER>
            <WIRING>2.3</WIRING>
            <ENABLED>Yes</ENABLED>
    </RECORD>       
    <RECORD>
            <ELEC>EL-14</ELEC>
            <VAL>30</VAL>
            <POWER>Max</POWER>
            <WIRING>1.1</WIRING>
            <ENABLED>Yes</ENABLED>
    </RECORD>       
</D1>
""")

From there, you can generate a list of keys to use as the column names for the DataFrame:

for key in parsed_dictionary.keys():
    cols.append(key)