<meewords>
	<words>
		<word>
			the 
		</word>
		<translation>
			 определенный артикль
		</translation>
	</words>
	<words>
		<word>
			be 
		</word>
		<translation>
			 быть
		</translation>
	</words>
	<words>
		<word>
			of 
		</word>
		<translation>
			 предлог родительного падежа
		</translation>
	</words>

class Pars():
     def run(self):
          counter=0
          for self.wrd in open(self.fal1):
               self.s = self.wrd.split(' ')
               del self.s[0]               
               if self.s[-1] ==  '\n':
                    del self.s[-1]
               if self.s[1] == 'n' or self.s[1] == 'v':
                    del self.s[1]
               self.s=' '.join(self.s)
               self.i = self.s.find('-')
               counter=counter+1
               print 'processing words', counter
               self.runXml()
          

class DomXml(Pars):
     def __init__(self):
          self.dom = minidom.Document()
          self.a1 = self.dom.createElement("meewords")
          self.dom.appendChild(self.a1)

     def runXml(self):
          self.b1 = self.dom.createElement("words")
          self.a1.appendChild(self.b1)
          self.c1 = self.dom.createElement("word")
          self.c1.appendChild(self.dom.createTextNode(self.s[0:self.i]))
          self.c2 = self.dom.createElement("translation")
          self.c2.appendChild(self.dom.createTextNode(self.s[self.i + 1:]))
          self.b1.appendChild(self.c1)
          self.b1.appendChild(self.c2)
          self.save()
          
class Start(DomXml):
     def __init__(self, fal1, fal2):
          DomXml.__init__(self)
          self.fal1 = fal1
          self.fal2 = fal2
          self.run()

     def save(self):
          self.res = open(self.fal2, 'w')
          self.res.writelines(self.dom.toprettyxml())
          self.res.close()

if self.s[-1] ==  '\n':
    del self.s[-1]

class Pars():
     def run(self):
          counter=0
          for self.s in open(self.fal1):
               self.s = self.s.split(' ')
               del self.s[0]               
               if 'n' in self.s: del self.s[self.s.index('n')]
               if 'v' in self.s: del self.s[self.s.index('v')]
               self.s = ' '.join(self.s)
               self.s = self.s.strip()
               self.i = self.s.find('-')
               counter+=1
               print 'processing words', counter
               self.runXml()

from xml.dom import minidom

def parse(infile):
    with open(infile, "r") as f:
        for p1, p2 in ([_.strip() for _ in l.split("-")] for l in f if l.strip()):
            if p1.endswith(" n") or p1.endswith(" v"):
                p1 = p1[:-2]
            _, p1 = p1.split(" ", 1)
            yield p1, p2

def create_xml(words, outfile):
    xml = minidom.Document()
    root = xml.createElement("meewords")
    xml.appendChild(root)

    for w, t in words:
        node = xml.createElement("words")
        root.appendChild(node)

        x = xml.createElement("word")
        node.appendChild(x)
        x.appendChild(xml.createTextNode(w))

        x = xml.createElement("translation")
        node.appendChild(x)
        x.appendChild(xml.createTextNode(t))

    with open(outfile, "w") as f:
        f.write(xml.toprettyxml())

if "__main__" == __name__:
    create_xml(parse("text.txt"), "out.xml")

raceback (most recent call last):
  File "<pyshell#12>", line 1, in <module>
    for p1, p2 in ([_.strip() for _ in l.split("-")] for l in f if l.strip()):
ValueError: too many values to unpack

do_strip = lambda a: a.strip()

def parse(infile):
    with open(infile) as f:
        for line in filter(bool, map(do_strip, f)):
            p1, p2 = map(do_strip, line.split('-'))
            if p1.endswith((' n', ' v')):
                p1 = p1[:-2]
            p1 = p1.split(' ', 1)[1]
            yield p1, p2