You could also use XSLT to strip the namespaces...

XSLT 1.0 (test.xsl)

<xsl:stylesheet version="1.0" >
  <xsl:output indent="yes"/>
  <xsl:strip-space elements="*"/>

  <xsl:template match="node()">
    <xsl:copy>
      <xsl:apply-templates select="@*|node()"/>
    </xsl:copy>
  </xsl:template>

  <xsl:template match="*" priority="1">
    <xsl:element name="{local-name()}" namespace="">
      <xsl:apply-templates select="@*|node()"/>
    </xsl:element>
  </xsl:template>

  <xsl:template match="@*">
    <xsl:attribute name="{local-name()}" namespace="">
      <xsl:value-of select="."/>
    </xsl:attribute>
  </xsl:template>

</xsl:stylesheet>

Python

from lxml import etree

tree = etree.parse("metadata.xml")
xslt = etree.parse("test.xsl")

new_tree = tree.xslt(xslt)

print(etree.tostring(new_tree, pretty_print=True, xml_declaration=True, 
                     encoding="UTF-8").decode("UTF-8"))

Output

<?xml version='1.0' encoding='UTF-8'?>
<package>
  <provider>some data</provider>
  <language>en-GB</language>
</package>

you can try with lxml:

# Remove namespace prefixes
for elem in root.getiterator():
    namespace_removed = elem.xpath('local-name()')

So I realize this is an older answer with a highly up-voted and accepted answer, but if you are reading LARGE-FILES and find yourself in the same predicament I did; I hope this helps you out.

The issue with this approach is, in fact, the iteration. Regardless of how fast the parser is, doing anything say... a few 100k times is gonna eat your execution time. With that said, it came down to really thinking about the problem for me and understanding how namespaces work (or are "intended to work", because they are honestly not needed). Now if your xml truly uses namespaces, meaning you see tags that look like this: <xs:table>, then you'll need to tweak the approach here for your use-case. I'll include the full way of handling, as well.

DISCLAIMER : I cannot, with a good conscience, tell you to use regular expressions when parsing html/xml, go look at SergiyKolesnikov's answer as it WORKS, but I had an edge case so with that said... let's dive into some regex!

Problem: namespace stripping takes forever... and most of the time the namespaces only live inside of the very opening tag, or our "root". So in thinking about how python reads information in, and where our only problem-child is that root node, why not use that to our advantage.

Please NOTE: the file i'm using as my example comes as a raw, horrid, remarkably senseless structure of lulz with the promise of data in there somewhere.

my_file is the path to the file im using for our example, I cannot share it with you for professional reasons; and it has been cut down way in size just to get through this answer.

import os, sys, subprocess, re, io, json
from lxml import etree

# Your file would be '_biggest_file' if playing along at home
my_file = _biggest_file
meta_stuff = dict(
    exists = os.path.exists(_biggest_file), 
    sizeof = os.path.getsize(_biggest_file),
    extension_is_a_real_thing = any(re.findall(".(html|xml)$", my_file, re.I)),
    system_thinks_its_a = subprocess.check_output(
        ["file", "-i", _biggest_file]
    ).decode().split(":")[-1:][0].strip()
)


print(json.dumps(meta_stuff, indent = 2))

So for starters, decently sized, and system thinks at best it's html; the file extension is neither xml or html either...

{
  "exists": true,
  "sizeof": 24442371,
  "extension_is_a_real_thing": false,
  "system_thinks_its_a": "text/html; charset=us-ascii"
}

Approach:

1. In order to parse an xml file... it should at the very least be xml, so we'll need to check and add a declarations tag if one doesn't exist
2. If I have namespaces.. thats bad because I can't use xpaths, which is what I want to do
3. If my file is huge, I should only operate on the smallest imaginable parts that I need to clean before I'm ready to parse it.

Function

def speed_read(file_path):

    # We're gonna be low-brow and add our own using this string. It's fine
    _xml_dec = '<?xml version="1.0" encoding="utf-8"?>'
    # Even worse.. rgx for xml here we go
    # 
    # We'll need to extract the very first node that we find in our document, 
    # because for our purposes thats the one we know has the namespace uri's 
    # ie: "attributes"
    #    FiRsT node : <actual_name >import pandas as pd

safe_times = []
for i in range(0,5):
    s = time.time()
    safe_read(_biggest_file)
    safe_times.append(time.time() - s)


fast_times = []
for i in range(0,5):
    s = time.time()
    speed_read(_biggest_file)
    fast_times.append(time.time() - s)


pd.DataFrame({"safe":safe_times, "fast":fast_times})