diff --git a/emeraldtree/ElementInclude.py b/emeraldtree/ElementInclude.py
index 9abb63b..0952631 100644
--- a/emeraldtree/ElementInclude.py
+++ b/emeraldtree/ElementInclude.py
@@ -109,7 +109,7 @@ def include(elem, loader=None):
                 node = loader(href, parse)
                 if node is None:
                     raise FatalIncludeError(
-                        "cannot load %r as %r" % (href, parse)
+                        "cannot load {!r} as {!r}".format(href, parse)
                         )
                 node = copy.copy(node)
                 if e.tail:
@@ -119,7 +119,7 @@ def include(elem, loader=None):
                 text = loader(href, parse, e.get("encoding"))
                 if text is None:
                     raise FatalIncludeError(
-                        "cannot load %r as %r" % (href, parse)
+                        "cannot load {!r} as {!r}".format(href, parse)
                         )
                 if i:
                     node = elem[i-1]
diff --git a/emeraldtree/ElementPath.py b/emeraldtree/ElementPath.py
index b0f3dd9..55b9952 100644
--- a/emeraldtree/ElementPath.py
+++ b/emeraldtree/ElementPath.py
@@ -77,14 +77,12 @@ def select(context, result):
 def prepare_star(next, token):
     def select(context, result):
         for elem in result:
-            for e in elem:
-                yield e
+            yield from elem
     return select
 
 def prepare_dot(next, token):
     def select(context, result):
-        for elem in result:
-            yield elem
+        yield from result
     return select
 
 def prepare_iter(next, token):
diff --git a/emeraldtree/tests/test_tree.py b/emeraldtree/tests/test_tree.py
index 37a0014..5aff12e 100644
--- a/emeraldtree/tests/test_tree.py
+++ b/emeraldtree/tests/test_tree.py
@@ -10,72 +10,72 @@ def serialize(elem, namespaces={}):
     return file.getvalue()
 
 def test_Element():
-    elem = Element(u'a')
+    elem = Element('a')
 
     assert isinstance(elem, Node)
-    assert elem.tag == u'a'
+    assert elem.tag == 'a'
 
 def test_Element__len__():
-    elem = Element(u'a', children=(u'1', u'2', u'3', u'4', u'5'))
+    elem = Element('a', children=('1', '2', '3', '4', '5'))
 
     assert len(elem) == 5
 
 def test_Element__nonzero__():
-    elem = Element(u'a')
+    elem = Element('a')
 
     assert elem
     assert len(elem) == 0
 
 def test_Element___getitem__():
-    elem = Element(u'a', children=(Element(u'b'), Element(u'c')))
+    elem = Element('a', children=(Element('b'), Element('c')))
 
-    assert elem[0].tag == u'b'
-    assert elem[1].tag == u'c'
+    assert elem[0].tag == 'b'
+    assert elem[1].tag == 'c'
     assert len(elem[:1]) == 1
     assert len(elem[:2]) == 2
     assert len(elem[:3]) == 2
     assert len(elem[1:3]) == 1
     assert len(elem[2:3]) == 0
-    assert elem[:2][0].tag == u'b'
-    assert elem[:2][1].tag == u'c'
+    assert elem[:2][0].tag == 'b'
+    assert elem[:2][1].tag == 'c'
 
 def test_Element___setitem__():
-    elem = Element(u'a', children=(Element(u'b1'), Element(u'b2')))
+    elem = Element('a', children=(Element('b1'), Element('b2')))
 
-    elem[0] = Element(u'c')
-    assert elem[0].tag == u'c'
-    assert elem[1].tag == u'b2'
+    elem[0] = Element('c')
+    assert elem[0].tag == 'c'
+    assert elem[1].tag == 'b2'
 
-    elem[1] = Element(u'd')
-    assert elem[0].tag == u'c'
-    assert elem[1].tag == u'd'
+    elem[1] = Element('d')
+    assert elem[0].tag == 'c'
+    assert elem[1].tag == 'd'
 
-    elem[0:0] = [Element(u'e')]
-    assert elem[0].tag == u'e'
-    assert elem[1].tag == u'c'
-    assert elem[2].tag == u'd'
+    elem[0:0] = [Element('e')]
+    assert elem[0].tag == 'e'
+    assert elem[1].tag == 'c'
+    assert elem[2].tag == 'd'
 
 def test_Element___delitem__():
-    elem = Element(u'a', children=(Element(u'b1'), Element(u'b2')))
+    elem = Element('a', children=(Element('b1'), Element('b2')))
 
     del elem[0]
     assert len(elem) == 1
-    assert elem[0].tag == u'b2'
+    assert elem[0].tag == 'b2'
 
 def test_Element_append():
-    elem = Element(u'a')
+    elem = Element('a')
 
-    elem.append(Element(u'b'))
+    elem.append(Element('b'))
     assert len(elem) == 1
-    assert elem[0].tag == u'b'
+    assert elem[0].tag == 'b'
 
-    elem.append(Element(u'c'))
+    elem.append(Element('c'))
     assert len(elem) == 2
-    assert elem[1].tag == u'c'
+    assert elem[1].tag == 'c'
 
-    elem.append(u'd')
+    elem.append('d')
     assert len(elem) == 3
-    assert elem[2] == u'd'
+    assert elem[2] == 'd'
 
 def test_Element_extend():
     pass
@@ -87,181 +87,181 @@ def test_Element_remove():
     pass
 
 def test_Element_find():
-    child_1 = Element(u'b1')
-    child_2 = Element(u'b2')
-    elem = Element(u'a', children=(child_1, child_2))
+    child_1 = Element('b1')
+    child_2 = Element('b2')
+    elem = Element('a', children=(child_1, child_2))
 
-    result = elem.find(u'b1')
+    result = elem.find('b1')
     assert result is child_1
 
-    result = elem.find(u'b2')
+    result = elem.find('b2')
     assert result is child_2
 
-    child_1 = Element(QName(u'b1', u'url1'))
-    child_2 = Element(QName(u'{url2}b2'))
-    elem = Element(u'a', children=(child_1, child_2))
+    child_1 = Element(QName('b1', 'url1'))
+    child_2 = Element(QName('{url2}b2'))
+    elem = Element('a', children=(child_1, child_2))
 
-    result = elem.find(u'{url1}b1')
+    result = elem.find('{url1}b1')
     assert result is child_1
 
 def test_Element_findall():
-    child_1 = Element(u'b1')
-    child_2 = Element(u'b2')
-    child_3 = u"text"
-    elem = Element(u'a', children=(child_1, child_2, child_3))
+    child_1 = Element('b1')
+    child_2 = Element('b2')
+    child_3 = "text"
+    elem = Element('a', children=(child_1, child_2, child_3))
 
-    result = list(elem.findall(u'b1'))
+    result = list(elem.findall('b1'))
     assert len(result) == 1
     assert result[0] is child_1
 
-    result = list(elem.findall(u'b2'))
+    result = list(elem.findall('b2'))
     assert len(result) == 1
     assert result[0] is child_2
 
-    result = list(elem.findall(u'*'))
+    result = list(elem.findall('*'))
     assert len(result) == 3
     assert result[0] is child_1
     assert result[1] is child_2
     assert result[2] is child_3
 
-    child_1 = Element(QName(u'b1', u'url1'))
-    child_2 = Element(QName(u'{url2}b2'))
-    elem = Element(u'a', children=(child_1, child_2))
+    child_1 = Element(QName('b1', 'url1'))
+    child_2 = Element(QName('{url2}b2'))
+    elem = Element('a', children=(child_1, child_2))
 
-    result = list(elem.findall(u'{url1}b1'))
+    result = list(elem.findall('{url1}b1'))
     assert len(result) == 1
     assert result[0] is child_1
 
 def test_Element_findall_tag_multimatch():
-    c1 = Element(u'c')
-    c2 = Element(u'c')
-    text = u"text"
-    b1 = Element(u'b', children=(c1, text, c2))
-    b2 = Element(u'b')
-    a1 = Element(u'a', children=(b1, b2, ))
-
-    result = list(b1.findall(u'c'))
+    c1 = Element('c')
+    c2 = Element('c')
+    text = "text"
+    b1 = Element('b', children=(c1, text, c2))
+    b2 = Element('b')
+    a1 = Element('a', children=(b1, b2, ))
+
+    result = list(b1.findall('c'))
     assert len(result) == 2
     assert result[0] is c1
     assert result[1] is c2
 
-    result = list(a1.findall(u'c'))
+    result = list(a1.findall('c'))
     assert len(result) == 0 # no 'c' childs
 
-    result = list(a1.findall(u'*/c'))
+    result = list(a1.findall('*/c'))
     assert len(result) == 2 # but 2 'c' grandchilds
     assert result[0] is c1
     assert result[1] is c2
 
 def test_Element_findall_bracketed_tag():
-    c1 = Element(u'c')
-    c2 = Element(u'c')
-    text = u"text"
-    b1 = Element(u'b', children=(c1, text, c2))
-    b2 = Element(u'b')
-    a1 = Element(u'a', children=(b1, b2, ))
-
-    result = list(b1.findall(u'[c]'))
+    c1 = Element('c')
+    c2 = Element('c')
+    text = "text"
+    b1 = Element('b', children=(c1, text, c2))
+    b2 = Element('b')
+    a1 = Element('a', children=(b1, b2, ))
+
+    result = list(b1.findall('[c]'))
     assert len(result) == 1
     assert result[0] is b1 # b1 has 'c' childs
 
-    result = list(a1.findall(u'*/[c]'))
+    result = list(a1.findall('*/[c]'))
     assert len(result) == 1
     assert result[0] is b1 # b1 has 'c' childs
 
 def test_Element_findall_dotdot():
     pytest.skip('broken')
-    c1 = Element(u'c')
-    c2 = Element(u'c')
-    text = u"text"
-    b1 = Element(u'b', children=(c1, text, c2))
-    b2 = Element(u'b')
-    a1 = Element(u'a', children=(b1, b2, ))
+    c1 = Element('c')
+    c2 = Element('c')
+    text = "text"
+    b1 = Element('b', children=(c1, text, c2))
+    b2 = Element('b')
+    a1 = Element('a', children=(b1, b2, ))
     
-    result = list(c1.findall(u'../c'))
+    result = list(c1.findall('../c'))
     assert len(result) == 2
     assert result[0] is c1
     assert result[1] is c2
 
 def test_Element_findall_slashslash():
     pytest.skip('broken')
-    c1 = Element(u'c')
-    c2 = Element(u'c')
-    text = u"text"
-    b1 = Element(u'b', children=(c1, text, c2))
-    b2 = Element(u'b')
-    a1 = Element(u'a', children=(b1, b2, ))
+    c1 = Element('c')
+    c2 = Element('c')
+    text = "text"
+    b1 = Element('b', children=(c1, text, c2))
+    b2 = Element('b')
+    a1 = Element('a', children=(b1, b2, ))
 
     a1t = ElementTree(element=a1) # we need a tree to use //
-    result = list(a1t.findall(u'//c'))
+    result = list(a1t.findall('//c'))
     assert len(result) == 2
     assert result[0] is c1
     assert result[1] is c2
 
 def test_Element_findall_dotslashslash():
     pytest.skip('broken')
-    c1 = Element(u'c')
-    c2 = Element(u'c')
-    text = u"text"
-    b1 = Element(u'b', children=(c1, text, c2))
-    b2 = Element(u'b')
-    a1 = Element(u'a', children=(b1, b2, ))
-
-    result = list(a1.findall(u'.//c'))
+    c1 = Element('c')
+    c2 = Element('c')
+    text = "text"
+    b1 = Element('b', children=(c1, text, c2))
+    b2 = Element('b')
+    a1 = Element('a', children=(b1, b2, ))
+
+    result = list(a1.findall('.//c'))
     assert len(result) == 2
     assert result[0] is c1
     assert result[1] is c2
 
 def test_Element_findall_attribute():
-    c1 = Element(u'c')
-    c2 = Element(u'c', testattr='testvalue')
-    text = u"text"
-    b1 = Element(u'b', children=(c1, text, c2))
-    b2 = Element(u'b')
-    a1 = Element(u'a', children=(b1, b2, ))
-
-    result = list(b1.findall(u"c[@testattr]"))
+    c1 = Element('c')
+    c2 = Element('c', testattr='testvalue')
+    text = "text"
+    b1 = Element('b', children=(c1, text, c2))
+    b2 = Element('b')
+    a1 = Element('a', children=(b1, b2, ))
+
+    result = list(b1.findall("c[@testattr]"))
     # note: does not work without c, like b1.findall(u"[@testattr]") - should it?
     assert len(result) == 1
     assert result[0] is c2
 
-    result = list(b1.findall(u"c[@testattr='testvalue']"))
+    result = list(b1.findall("c[@testattr='testvalue']"))
     # note: does not work without c, like b1.findall(u"[@testattr='testvalue']") - should it?
     assert len(result) == 1
     assert result[0] is c2
 
-    result = list(b1.findall(u"c[@testattr='othervalue']"))
+    result = list(b1.findall("c[@testattr='othervalue']"))
     # note: does not work without c, like b1.findall(u"[@testattr='othervalue']") - should it?
     assert len(result) == 0
 
 def test_Element_findall_position():
     pytest.skip('not supported')
-    c1 = Element(u'c')
-    c2 = Element(u'c')
-    text = u"text"
-    b1 = Element(u'b', children=(c1, text, c2))
-    b2 = Element(u'b')
-    a1 = Element(u'a', children=(b1, b2, ))
-
-    result = list(b1.findall(u'c[1]')) # note: index is 1-based, [1] (not [0]) is first
+    c1 = Element('c')
+    c2 = Element('c')
+    text = "text"
+    b1 = Element('b', children=(c1, text, c2))
+    b2 = Element('b')
+    a1 = Element('a', children=(b1, b2, ))
+
+    result = list(b1.findall('c[1]')) # note: index is 1-based, [1] (not [0]) is first
     assert len(result) == 1
     assert result[0] is c1
 
-    result = list(b1.findall(u'c[2]'))
+    result = list(b1.findall('c[2]'))
     assert len(result) == 1
     assert result[0] is c2
 
 def test_Element_findtext_default():
-    elem = Element(u'a')
-    default_text = u'defaulttext'
-    result = elem.findtext(u'doesnotexist', default=default_text)
+    elem = Element('a')
+    default_text = 'defaulttext'
+    result = elem.findtext('doesnotexist', default=default_text)
     assert result is default_text
 
 def test_Element_findtext():
-    child_text = u"text"
-    child = Element(u'b', children=(child_text, ))
-    elem = Element(u'a', children=(child, ))
-    result = elem.findtext(u'b')
+    child_text = "text"
+    child = Element('b', children=(child_text, ))
+    elem = Element('a', children=(child, ))
+    result = elem.findtext('b')
     assert result is child_text
 
 def test_Element_clear():
@@ -280,143 +280,143 @@ def test_Element_items():
     pass
 
 def test_Element_iter():
-    elem = Element(u'a')
+    elem = Element('a')
     l = list(elem.iter())
     assert len(l) == 1
 
-    elem.append(u'b')
+    elem.append('b')
     l = list(elem.iter())
     assert len(l) == 2
 
-    elem.append(Element(u'c'))
+    elem.append(Element('c'))
     l = list(elem.iter())
     assert len(l) == 3
 
-    elem.append(u'd')
+    elem.append('d')
     l = list(elem.iter())
     assert len(l) == 4
 
 def test_Element_itertext():
-    elem = Element(u'a')
+    elem = Element('a')
     l = list(elem.itertext())
     assert len(l) == 0
 
-    elem.append(u'b')
+    elem.append('b')
     l = list(elem.itertext())
     assert len(l) == 1
 
 def test_Element_iter_elements():
-    elem = Element(u'a')
+    elem = Element('a')
     assert len(list(elem.iter_elements())) == 0
 
-    elem.append(Element(u'c'))
+    elem.append(Element('c'))
     assert len(list(elem.iter_elements())) == 1
 
-    elem.append(u'b')
+    elem.append('b')
     assert len(list(elem.iter_elements())) == 1
 
 def test_Element_iter_elements_tree():
-    elem = Element(u'a')
+    elem = Element('a')
     assert len(list(elem.iter_elements_tree())) == 1
 
-    elem.append(u'b')
+    elem.append('b')
     assert len(list(elem.iter_elements_tree())) == 1
 
-    elem.append(Element(u'c'))
+    elem.append(Element('c'))
     assert len(list(elem.iter_elements_tree())) == 2
 
-    elem.append(u'd')
+    elem.append('d')
     assert len(list(elem.iter_elements_tree())) == 2
 
 def test_Comment():
-    elem = Comment(u'a')
-    assert serialize(elem) == u'<!--a-->'
+    elem = Comment('a')
+    assert serialize(elem) == '<!--a-->'
     assert isinstance(elem, Node)
 
 def test_ProcessingInstruction():
-    elem = ProcessingInstruction(u'a')
-    assert serialize(elem) == u'<?a?>'
+    elem = ProcessingInstruction('a')
+    assert serialize(elem) == '<?a?>'
     assert isinstance(elem, ProcessingInstruction)
 
-    elem = ProcessingInstruction(u'a', u'b')
-    assert serialize(elem) == u'<?a b?>'
+    elem = ProcessingInstruction('a', 'b')
+    assert serialize(elem) == '<?a b?>'
 
 def test_QName___init__():
-    qname = QName(u'a')
+    qname = QName('a')
     assert qname.uri is None
-    assert qname.name == u'a'
+    assert qname.name == 'a'
     assert isinstance(qname.name, str)
-    assert str(qname) == u'a'
+    assert str(qname) == 'a'
 
-    qname = QName(u'{b}a')
-    assert qname.uri == u'b'
+    qname = QName('{b}a')
+    assert qname.uri == 'b'
     assert isinstance(qname.uri, str)
-    assert qname.name == u'a'
-    assert str(qname) == u'{b}a'
+    assert qname.name == 'a'
+    assert str(qname) == '{b}a'
 
-    qname = QName(u'a', u'b')
-    assert qname.uri == u'b'
-    assert qname.name == u'a'
-    assert str(qname) == u'{b}a'
+    qname = QName('a', 'b')
+    assert qname.uri == 'b'
+    assert qname.name == 'a'
+    assert str(qname) == '{b}a'
 
-    pytest.raises(ValueError, QName, u'{bau')
-    pytest.raises(ValueError, QName, u'{b}a', u'c')
+    pytest.raises(ValueError, QName, '{bau')
+    pytest.raises(ValueError, QName, '{b}a', 'c')
 
 def test_QName___cmp__():
-    qname1 = QName(u'a')
-    qname2 = QName(u'a')
+    qname1 = QName('a')
+    qname2 = QName('a')
 
     assert qname1 == qname2
-    assert qname1 == u'a'
-    assert u'a' == qname1
+    assert qname1 == 'a'
+    assert 'a' == qname1
 
-    qname1 = QName(u'a', u'b')
-    qname2 = QName(u'{b}a')
+    qname1 = QName('a', 'b')
+    qname2 = QName('{b}a')
 
     assert qname1 == qname2
-    assert qname1 == u'{b}a'
-    assert u'{b}a' == qname1
+    assert qname1 == '{b}a'
+    assert '{b}a' == qname1
 
 def test_XMLParser_simple1():
-    elem = XML(u'<a />')
-    assert elem.tag == u'a'
+    elem = XML('<a />')
+    assert elem.tag == 'a'
     assert len(elem) == 0
 
 def test_XMLParser_simple2():
-    elem = XML(u'<a><b /></a>')
-    assert elem.tag == u'a'
+    elem = XML('<a><b /></a>')
+    assert elem.tag == 'a'
     assert len(elem) == 1
-    assert elem[0].tag == u'b'
+    assert elem[0].tag == 'b'
     assert len(elem[0]) == 0
 
 def test_XMLParser_text1():
-    elem = XML(u'<a>b</a>')
-    assert elem.tag == u'a'
+    elem = XML('<a>b</a>')
+    assert elem.tag == 'a'
     assert isinstance(elem, Element)
     assert len(elem) == 1
-    assert elem[0] == u'b'
+    assert elem[0] == 'b'
     assert isinstance(elem[0], str)
 
 def test_XMLParser_text2():
-    elem = XML(u'<a>b<c>d</c>d</a>')
-    assert elem.tag == u'a'
+    elem = XML('<a>b<c>d</c>d</a>')
+    assert elem.tag == 'a'
     assert len(elem) == 3
-    assert elem[0] == u'b'
-    assert elem[1].tag == u'c'
-    assert elem[2] == u'd'
+    assert elem[0] == 'b'
+    assert elem[1].tag == 'c'
+    assert elem[2] == 'd'
 
 def test_XMLParser_namespace_1():
-    elem = XML(u'<b xmlns="c" d="e"/>')
+    elem = XML('<b xmlns="c" d="e"/>')
     assert isinstance(elem.tag, QName)
-    assert elem.tag == QName(u'b', u'c')
-    assert elem.attrib == {QName(u'd', None): u'e'}
-    assert serialize(elem) == u'<ns0:b d="e" xmlns:ns0="c" />'
-    assert serialize(elem, namespaces={u'c': u''}) == u'<b d="e" xmlns="c" />'
+    assert elem.tag == QName('b', 'c')
+    assert elem.attrib == {QName('d', None): 'e'}
+    assert serialize(elem) == '<ns0:b d="e" xmlns:ns0="c" />'
+    assert serialize(elem, namespaces={'c': ''}) == '<b d="e" xmlns="c" />'
 
 def test_XMLParser_namespace_2():
-    elem = XML(u'<a:b xmlns:a="c" d="e" a:f="g"/>')
+    elem = XML('<a:b xmlns:a="c" d="e" a:f="g"/>')
     assert isinstance(elem.tag, QName)
-    assert elem.tag == QName(u'b', u'c')
-    assert elem.attrib == {u'd': u'e', QName(u'f', u'c'): u'g'}
-    assert serialize(elem) == u'<ns0:b d="e" ns0:f="g" xmlns:ns0="c" />'
-    assert serialize(elem, namespaces={u'c': u''}) == u'<b d="e" f="g" xmlns="c" />'
+    assert elem.tag == QName('b', 'c')
+    assert elem.attrib == {'d': 'e', QName('f', 'c'): 'g'}
+    assert serialize(elem) == '<ns0:b d="e" ns0:f="g" xmlns:ns0="c" />'
+    assert serialize(elem, namespaces={'c': ''}) == '<b d="e" f="g" xmlns="c" />'
diff --git a/emeraldtree/tree.py b/emeraldtree/tree.py
index 865adc3..817566b 100644
--- a/emeraldtree/tree.py
+++ b/emeraldtree/tree.py
@@ -70,7 +70,7 @@ class ParseError(SyntaxError):
 
 # --------------------------------------------------------------------
 
-class Node(object):
+class Node:
     """
     Node class.
     """
@@ -153,7 +153,7 @@ def __init__(self, tag, attrib=None, children=(), **extra):
         self._children = list(children)
 
     def __repr__(self):
-        return "<Element %s at %x>" % (repr(self.tag), id(self))
+        return "<Element {} at {:x}>".format(repr(self.tag), id(self))
 
     ##
     # Returns the number of subelements.
@@ -368,8 +368,7 @@ def iter(self, tag=None):
     def itertext(self):
         for e in self:
             if isinstance(e, Element):
-                for s in e.itertext():
-                    yield s
+                yield from e.itertext()
             elif isinstance(e, str):
                 yield e
 
@@ -487,7 +486,7 @@ def __getstate__(self):
         pass
 
     def __repr__(self):
-        return '%s(%r, %r)' % (self.__class__.__name__, self.name, self.uri)
+        return '{}({!r}, {!r})'.format(self.__class__.__name__, self.name, self.uri)
 
     def __setattr__(self, key, value):
         raise AttributeError('read-only')
@@ -504,7 +503,7 @@ def __setattr__(self, key, value):
 # @keyparam file Optional file handle or file name.  If given, the
 #     tree is initialized with the contents of this XML file.
 
-class ElementTree(object):
+class ElementTree:
 
     def __init__(self, element=None, file=None):
         assert element is None or isinstance(element, Node)
@@ -680,7 +679,7 @@ def tostring(element, encoding=None, method=None):
 # @since 1.3
 
 def tostringlist(element, encoding=None, method=None):
-    class dummy(object):
+    class dummy:
         pass
     data = []
     file = dummy()
@@ -742,7 +741,7 @@ def iterparse(source, events=None, parser=None):
         parser = XMLParser(target=TreeBuilder())
     return _IterParseIterator(source, events, parser)
 
-class _IterParseIterator(object):
+class _IterParseIterator:
 
     def __init__(self, source, events, parser):
         self._file = source
@@ -889,7 +888,7 @@ def fromstringlist(sequence, parser=None):
 # @param element_factory Optional element factory.  This factory
 #    is called to create new Element instances, as necessary.
 
-class TreeBuilder(object):
+class TreeBuilder:
 
     def __init__(self, element_factory=None):
         self._data = [] # data collector
@@ -958,7 +957,7 @@ def end(self, tag):
         self._flush()
         self._last = self._elem.pop()
         assert self._last.tag == tag,\
-               "end tag mismatch (expected %s, got %s)" % (
+               "end tag mismatch (expected {}, got {})".format(
                    self._last.tag, tag)
         return self._last
 
@@ -975,7 +974,7 @@ def end(self, tag):
 # @see #ElementTree
 # @see #TreeBuilder
 
-class XMLParser(object):
+class XMLParser:
 
     def __init__(self, html=0, target=None, encoding=None):
         try:
@@ -1127,7 +1126,7 @@ def close(self):
         del self.target, self._parser # get rid of circular references
         return tree
 
-class BaseWriter(object):
+class BaseWriter:
     def __init__(self, encoding=None, namespaces={}):
         self.encoding = encoding
         self.namespaces = namespaces
@@ -1181,7 +1180,7 @@ def add_qname(qname):
                         if prefix != "xml":
                             used_namespaces[uri] = prefix
                     if prefix:
-                        qnames[qname] = "%s:%s" % (prefix, qname.name)
+                        qnames[qname] = "{}:{}".format(prefix, qname.name)
                     else:
                         qnames[qname] = qname.name
                 else:
@@ -1214,7 +1213,7 @@ def add_qname(qname):
     @staticmethod
     def _raise_serialization_error(text):
         raise TypeError(
-            "cannot serialize %r (type %s)" % (text, type(text).__name__)
+            "cannot serialize {!r} (type {})".format(text, type(text).__name__)
             )
 
     ##
@@ -1231,7 +1230,7 @@ def _raise_serialization_error(text):
     @classmethod
     def register_namespace(cls, prefix, uri):
         import re
-        if re.match("ns\d+$", prefix):
+        if re.match(r"ns\d+$", prefix):
             raise ValueError("Prefix format reserved for internal use")
         for k, v in cls._namespace_map.items():
             if k == uri or v == prefix:
@@ -1282,7 +1281,7 @@ class MLBaseWriter(BaseWriter):
     def _attrib_string(self, d, qnames):
         """create a attribute string from a dict d"""
         if not d:
-            return u''
+            return ''
         items = sorted(d.items(), key=lambda x: x[0])
         result = []
         for k, v in items:
@@ -1292,32 +1291,32 @@ def _attrib_string(self, d, qnames):
             else:
                 v = self._escape_attrib(str(v))
             # FIXME: handle boolean attributes for HTML
-            result.append(u' %s="%s"' % (k, v))
-        return u''.join(result)
+            result.append(' {}="{}"'.format(k, v))
+        return ''.join(result)
 
     def _namespace_string(self, d):
         """create a namespace string from a dict d"""
         if not d:
-            return u''
+            return ''
         items = sorted(d.items(), key=lambda x: x[1]) # sort on prefix
         result = []
         for v, k in items:
             if k:
-                k = u':' + k
-            result.append(u' xmlns%s="%s"' % (k, self._escape_attrib(v)))
-        return u''.join(result)
+                k = ':' + k
+            result.append(' xmlns{}="{}"'.format(k, self._escape_attrib(v)))
+        return ''.join(result)
 
     def _serialize_element(self, write, elem, qnames, namespaces):
         raise NotImplementedError
 
     def _serialize_comment(self, write, elem):
-        write(u"<!--%s-->" % self._escape_cdata(elem.text))
+        write("<!--%s-->" % self._escape_cdata(elem.text))
 
     def _serialize_pi(self, write, elem):
         text = self._escape_cdata(elem.target)
         if elem.text is not None:
             text += ' ' + self._escape_cdata(elem.text)
-        write(u"<?%s?>" % text)
+        write("<?%s?>" % text)
 
     def _serialize_cdata(self, write, elem):
         write(self._escape_cdata(str(elem)))
@@ -1341,12 +1340,12 @@ def _serialize_element(self, write, elem, qnames, namespaces):
             attrib_str = self._attrib_string(elem.attrib, qnames)
             namespace_str = self._namespace_string(namespaces)
             if len(elem):
-                write(u"<%s%s%s>" % (tag, attrib_str, namespace_str))
+                write("<{}{}{}>".format(tag, attrib_str, namespace_str))
                 for e in elem:
                     self.serialize(write, e, qnames)
-                write(u"</%s>" % tag)
+                write("</%s>" % tag)
             else:
-                write(u"<%s%s%s />" % (tag, attrib_str, namespace_str))
+                write("<{}{}{} />".format(tag, attrib_str, namespace_str))
 
         else:
             for e in elem:
@@ -1354,7 +1353,7 @@ def _serialize_element(self, write, elem, qnames, namespaces):
 
     def serialize_document_start(self, write):
         if self.encoding and self.encoding not in ("utf-8", "us-ascii"):
-            write(u"<?xml version='1.0' encoding='%s'?>\n" % self.encoding)
+            write("<?xml version='1.0' encoding='%s'?>\n" % self.encoding)
 
 
 class HTMLWriter(MLBaseWriter):
@@ -1363,7 +1362,7 @@ class HTMLWriter(MLBaseWriter):
 
     def __init__(self, encoding=None, namespaces={}):
         namespaces["http://www.w3.org/1999/xhtml"] = ''
-        super(HTMLWriter, self).__init__(encoding, namespaces)
+        super().__init__(encoding, namespaces)
 
     def _serialize_element(self, write, elem, qnames, namespaces):
         tag = qnames[elem.tag]
@@ -1371,14 +1370,14 @@ def _serialize_element(self, write, elem, qnames, namespaces):
         if tag is not None:
             attrib_str = self._attrib_string(elem.attrib, qnames)
             namespace_str = self._namespace_string(namespaces)
-            write(u"<%s%s%s>" % (tag, attrib_str, namespace_str))
+            write("<{}{}{}>".format(tag, attrib_str, namespace_str))
             if tag.lower() in ('script', 'style'):
-                write(u''.join(elem.itertext()))
+                write(''.join(elem.itertext()))
             else:
                 for e in elem:
                     self.serialize(write, e, qnames)
             if tag not in self.empty_elements:
-                write(u"</%s>" % tag)
+                write("</%s>" % tag)
 
         else:
             for e in elem:
@@ -1394,7 +1393,7 @@ class PolyglotWriter(MLBaseWriter):
 
     def __init__(self, encoding=None, namespaces={}):
         namespaces["http://www.w3.org/1999/xhtml"] = ''
-        super(PolyglotWriter, self).__init__(encoding, namespaces)
+        super().__init__(encoding, namespaces)
 
     def _serialize_element(self, write, elem, qnames, namespaces):
         tag = qnames[elem.tag]
@@ -1403,19 +1402,19 @@ def _serialize_element(self, write, elem, qnames, namespaces):
             attrib_str = self._attrib_string(elem.attrib, qnames)
             namespace_str = self._namespace_string(namespaces)
             if len(elem):
-                write(u"<%s%s%s>" % (tag, attrib_str, namespace_str))
+                write("<{}{}{}>".format(tag, attrib_str, namespace_str))
                 for e in elem:
                     self.serialize(write, e, qnames)
-                write(u"</%s>" % tag)
+                write("</%s>" % tag)
             elif tag in self.void_elements:
-                write(u"<%s%s%s />" % (tag, attrib_str, namespace_str))
+                write("<{}{}{} />".format(tag, attrib_str, namespace_str))
             else:
-                write(u"<%s%s%s></%s>" % (tag, attrib_str, namespace_str, tag))
+                write("<{}{}{}></{}>".format(tag, attrib_str, namespace_str, tag))
 
         else:
             for e in elem:
                 self.serialize(write, e, qnames)
 
     def serialize_document_start(self, write):
-        write(u"<!DOCTYPE html>\n")
+        write("<!DOCTYPE html>\n")