<?xml version="1.0" encoding="UTF-8"?>
<!-- 這是注釋 -->
<library>                          <!-- 根元素 -->
    <book id="001">                <!-- 元素 + 屬性 -->
        <title>Python編程</title>   <!-- 子元素 -->
        <author>張三</author>
        <price>59.00</price>
    </book>
</library>

import xml.etree.ElementTree as ET
# 方法1：解析文件（推薦用于文件）
tree = ET.parse('books.xml')  # 返回 ElementTree 對象
root = tree.getroot()         # 獲取根元素
# 方法2：解析字符串（用于從網(wǎng)絡(luò)或內(nèi)存讀?。?
xml_string = """<?xml version="1.0"?>
<library>
    <book id="001">
        <title>Python編程</title>
    </book>
</library>"""
root = ET.fromstring(xml_string)  # 直接返回根元素

<?xml version="1.0" encoding="UTF-8"?>
<library location="北京">
    <book id="001" category="編程">
        <title>Python編程：從入門到實踐</title>
        <author>埃里克·馬瑟斯</author>
        <price currency="CNY">89.00</price>
        <publish_date>2020-05</publish_date>
    </book>
    <book id="002" category="小說">
        <title>百年孤獨</title>
        <author>加西亞·馬爾克斯</author>
        <price currency="CNY">55.00</price>
        <publish_date>2011-06</publish_date>
    </book>
    <book id="003" category="編程">
        <title>流暢的Python</title>
        <author>盧西亞諾·拉馬略</author>
        <price currency="CNY">139.00</price>
        <publish_date>2017-05</publish_date>
    </book>
</library>

import xml.etree.ElementTree as ET
def parse_library():
    """解析圖書館 XML 文件"""
    try:
        # 解析 XML 文件
        tree = ET.parse('books.xml')
        root = tree.getroot()
        print(f"根元素標(biāo)簽: {root.tag}")
        print(f"根元素屬性: {root.attrib}")
        print(f"子元素數(shù)量: {len(root)}")
        print("-" * 50)
        # 遍歷所有 book 元素
        for book in root.findall('book'):
            book_id = book.get('id')           # 獲取屬性
            category = book.get('category')
            title = book.find('title').text    # 獲取文本內(nèi)容
            author = book.find('author').text
            price_elem = book.find('price')
            price = price_elem.text
            currency = price_elem.get('currency')
            print(f"圖書ID: {book_id}")
            print(f"類別: {category}")
            print(f"書名: {title}")
            print(f"作者: {author}")
            print(f"價格: {currency} {price}")
            print("-" * 50)
    except ET.ParseError as e:
        print(f"XML 解析錯誤: {e}")
    except FileNotFoundError:
        print("文件未找到，請確保 books.xml 存在")
if __name__ == "__main__":
    parse_library()

import xml.etree.ElementTree as ET
def iterate_xml():
    """使用迭代器遍歷大型 XML"""
    # iterparse 在解析時生成事件，適合大文件
    context = ET.iterparse('books.xml', events=('start', 'end'))
    context = iter(context)
    event, root = next(context)
    book_count = 0
    for event, elem in context:
        # 'start' 事件：元素開始
        # 'end' 事件：元素結(jié)束（此時元素已完整）
        if event == 'end' and elem.tag == 'book':
            book_count += 1
            title = elem.find('title').text
            print(f"處理第 {book_count} 本書: {title}")
            # 處理完后清除元素釋放內(nèi)存
            elem.clear()
            root.clear()
    print(f"總共處理了 {book_count} 本書")
# 遞歸遍歷所有元素
def recursive_walk(element, level=0):
    """遞歸打印 XML 結(jié)構(gòu)"""
    indent = "  " * level
    print(f"{indent}<{element.tag}> {element.attrib if element.attrib else ''}")
    if element.text and element.text.strip():
        print(f"{indent}  文本: {element.text.strip()}")
    for child in element:
        recursive_walk(child, level + 1)
    print(f"{indent}</{element.tag}>")
# 使用示例
tree = ET.parse('books.xml')
recursive_walk(tree.getroot())

def traverse_by_level(root):
    """按層級遍歷（廣度優(yōu)先）"""
    from collections import deque
    queue = deque([(root, 0)])
    while queue:
        elem, level = queue.popleft()
        indent = "  " * level
        print(f"{indent}[{level}] {elem.tag}: {elem.attrib}")
        for child in elem:
            queue.append((child, level + 1))
traverse_by_level(tree.getroot())

import xml.etree.ElementTree as ET
tree = ET.parse('books.xml')
root = tree.getroot()
# 1. find() - 查找第一個匹配的直接子元素
first_book = root.find('book')
print(f"第一本書: {first_book.find('title').text}")
# 2. findall() - 查找所有匹配的直接子元素
all_books = root.findall('book')
print(f"圖書總數(shù): {len(all_books)}")
# 3. iter() - 遞歸查找所有指定標(biāo)簽
all_prices = root.iter('price')
print("所有價格:")
for price in all_prices:
    print(f"  {price.text} {price.get('currency')}")
# 4. 帶條件的查找（XPath 語法）
# 查找 category="編程" 的所有圖書
programming_books = root.findall(".//book[@category='編程']")
print(f"\n編程類圖書數(shù)量: {len(programming_books)}")
# 5. 復(fù)雜 XPath 示例
# 查找價格大于 100 的圖書（需要遍歷判斷）
expensive_books = []
for book in root.findall('book'):
    price = float(book.find('price').text)
    if price > 100:
        expensive_books.append(book.find('title').text)
print(f"高價圖書: {expensive_books}")
# 6. 查找特定路徑
# 查找第一個 book 下的 title
title = root.find('./book[1]/title')
print(f"第一本書書名: {title.text}")

import xml.etree.ElementTree as ET
from dataclasses import dataclass
from typing import List, Optional, Dict
@dataclass
class Book:
    """圖書數(shù)據(jù)類"""
    id: str
    category: str
    title: str
    author: str
    price: float
    currency: str
    publish_date: str
class XMLExtractor:
    """XML 數(shù)據(jù)提取器"""
    def __init__(self, xml_file: str):
        self.tree = ET.parse(xml_file)
        self.root = self.tree.getroot()
    def get_root_info(self) -> Dict:
        """獲取根元素信息"""
        return {
            'tag': self.root.tag,
            'attributes': dict(self.root.attrib),
            'children_count': len(self.root)
        }
    def extract_all_books(self) -> List[Book]:
        """提取所有圖書信息"""
        books = []
        for book_elem in self.root.findall('book'):
            book = Book(
                id=book_elem.get('id', ''),
                category=book_elem.get('category', ''),
                title=self._get_text(book_elem, 'title'),
                author=self._get_text(book_elem, 'author'),
                price=float(self._get_text(book_elem, 'price')),
                currency=book_elem.find('price').get('currency', 'CNY'),
                publish_date=self._get_text(book_elem, 'publish_date')
            )
            books.append(book)
        return books
    def _get_text(self, parent: ET.Element, tag: str, default: str = '') -> str:
        """安全獲取子元素文本"""
        elem = parent.find(tag)
        return elem.text if elem is not None else default
    def get_books_by_category(self, category: str) -> List[Dict]:
        """按類別篩選圖書"""
        results = []
        xpath = f".//book[@category='{category}']"
        for book in self.root.findall(xpath):
            results.append({
                'id': book.get('id'),
                'title': book.find('title').text,
                'author': book.find('author').text
            })
        return results
    def get_statistics(self) -> Dict:
        """獲取統(tǒng)計信息"""
        books = self.extract_all_books()
        if not books:
            return {}
        prices = [b.price for b in books]
        categories = {}
        for b in books:
            categories[b.category] = categories.get(b.category, 0) + 1
        return {
            'total_books': len(books),
            'avg_price': sum(prices) / len(prices),
            'max_price': max(prices),
            'min_price': min(prices),
            'categories': categories
        }
# 使用示例
if __name__ == "__main__":
    extractor = XMLExtractor('books.xml')
    print("=== 根元素信息 ===")
    print(extractor.get_root_info())
    print("\n=== 所有圖書 ===")
    for book in extractor.extract_all_books():
        print(f"{book.id}: {book.title} ({book.author}) - {book.currency}{book.price}")
    print("\n=== 編程類圖書 ===")
    print(extractor.get_books_by_category('編程'))
    print("\n=== 統(tǒng)計信息 ===")
    stats = extractor.get_statistics()
    print(f"圖書總數(shù): {stats['total_books']}")
    print(f"平均價格: ￥{stats['avg_price']:.2f}")
    print(f"價格區(qū)間: ￥{stats['min_price']:.2f} - ￥{stats['max_price']:.2f}")
    print(f"類別分布: {stats['categories']}")

import xml.etree.ElementTree as ET
def modify_xml():
    """修改 XML 內(nèi)容"""
    tree = ET.parse('books.xml')
    root = tree.getroot()
    # 1. 修改屬性
    root.set('updated', '2024-01-01')
    root.set('location', '上海')  # 修改現(xiàn)有屬性
    # 2. 修改元素文本
    for book in root.findall('book'):
        price_elem = book.find('price')
        old_price = float(price_elem.text)
        # 打 8 折
        new_price = old_price * 0.8
        price_elem.text = f"{new_price:.2f}"
        price_elem.set('discount', '0.8')
    # 3. 添加新元素
    for book in root.findall('book'):
        stock = ET.SubElement(book, 'stock')
        stock.text = '100'
        stock.set('warehouse', 'A1')
    # 4. 刪除元素
    # 刪除第一本書的 publish_date
    first_book = root.find('book')
    publish_date = first_book.find('publish_date')
    if publish_date is not None:
        first_book.remove(publish_date)
    # 5. 保存修改
    tree.write('books_modified.xml', 
               encoding='utf-8', 
               xml_declaration=True,
               short_empty_elements=False)
    print("修改完成，已保存到 books_modified.xml")
modify_xml()

class XMLModifier:
    """XML 批量修改器"""
    def __init__(self, input_file: str):
        self.tree = ET.parse(input_file)
        self.root = self.tree.getroot()
        self.modified = False
    def update_prices(self, increase_rate: float = 0.1):
        """批量更新價格"""
        for price_elem in self.root.iter('price'):
            old_price = float(price_elem.text)
            new_price = old_price * (1 + increase_rate)
            price_elem.text = f"{new_price:.2f}"
            price_elem.set('updated', 'true')
        self.modified = True
        print(f"已更新所有價格，漲幅 {increase_rate*100}%")
    def add_element_to_all(self, tag: str, text: str, attrib: dict = None):
        """為所有 book 添加子元素"""
        attrib = attrib or {}
        for book in self.root.findall('book'):
            elem = ET.SubElement(book, tag, attrib)
            elem.text = text
        self.modified = True
        print(f"已為所有圖書添加 <{tag}> 元素")
    def remove_element_by_tag(self, tag: str):
        """刪除所有指定標(biāo)簽的元素"""
        count = 0
        for parent in self.root.iter():
            for child in list(parent):  # 使用 list 避免迭代時修改
                if child.tag == tag:
                    parent.remove(child)
                    count += 1
        self.modified = True
        print(f"已刪除 {count} 個 <{tag}> 元素")
    def save(self, output_file: str = None):
        """保存文件"""
        if not self.modified:
            print("沒有修改需要保存")
            return
        output = output_file or 'modified.xml'
        self.tree.write(output, 
                       encoding='utf-8',
                       xml_declaration=True)
        print(f"已保存到: {output}")
# 使用示例
modifier = XMLModifier('books.xml')
modifier.update_prices(0.15)  # 漲價 15%
modifier.add_element_to_all('status', '在售', {'available': 'true'})
modifier.save('books_updated.xml')

import xml.etree.ElementTree as ET
from datetime import datetime
def create_library_xml():
    """創(chuàng)建圖書館 XML 文件"""
    # 創(chuàng)建根元素
    root = ET.Element('library')
    root.set('version', '1.0')
    root.set('created', datetime.now().isoformat())
    # 添加注釋
    comment = ET.Comment(' 這是一個自動生成的圖書館數(shù)據(jù)文件 ')
    root.append(comment)
    # 創(chuàng)建圖書數(shù)據(jù)
    books_data = [
        {
            'id': '004',
            'category': '科幻',
            'title': '三體',
            'author': '劉慈欣',
            'price': '98.00',
            'currency': 'CNY',
            'tags': ['雨果獎', '科幻經(jīng)典', '系列作品']
        },
        {
            'id': '005',
            'category': '技術(shù)',
            'title': '深度學(xué)習(xí)',
            'author': '伊恩·古德費洛',
            'price': '168.00',
            'currency': 'CNY',
            'tags': ['AI', '機(jī)器學(xué)習(xí)', '教材']
        }
    ]
    for book_data in books_data:
        # 創(chuàng)建 book 元素
        book = ET.SubElement(root, 'book')
        book.set('id', book_data['id'])
        book.set('category', book_data['category'])
        # 添加子元素
        title = ET.SubElement(book, 'title')
        title.text = book_data['title']
        author = ET.SubElement(book, 'author')
        author.text = book_data['author']
        price = ET.SubElement(book, 'price')
        price.text = book_data['price']
        price.set('currency', book_data['currency'])
        # 添加標(biāo)簽列表
        tags = ET.SubElement(book, 'tags')
        for tag_text in book_data['tags']:
            tag = ET.SubElement(tags, 'tag')
            tag.text = tag_text
    # 創(chuàng)建 ElementTree 對象
    tree = ET.ElementTree(root)
    # 美化輸出（縮進(jìn)）
    ET.indent(tree, space='    ', level=0)
    # 保存到文件
    tree.write('new_library.xml', 
               encoding='utf-8',
               xml_declaration=True,
               short_empty_elements=False)
    print("成功創(chuàng)建 new_library.xml")
    # 同時返回字符串形式
    return ET.tostring(root, encoding='unicode')
xml_string = create_library_xml()
print("\n生成的 XML 內(nèi)容:")
print(xml_string)

<?xml version='1.0' encoding='utf-8'?>
<library created="2024-01-15T10:30:00" version="1.0">
    <!-- 這是一個自動生成的圖書館數(shù)據(jù)文件 -->
    <book category="科幻" id="004">
        <title>三體</title>
        <author>劉慈欣</author>
        <price currency="CNY">98.00</price>
        <tags>
            <tag>雨果獎</tag>
            <tag>科幻經(jīng)典</tag>
            <tag>系列作品</tag>
        </tags>
    </book>
    ...
</library>

def create_element_factory():
    """使用工廠模式創(chuàng)建 XML"""
    def create_book(id, title, author, **kwargs):
        """創(chuàng)建圖書元素的工廠函數(shù)"""
        book = ET.Element('book', {'id': id})
        ET.SubElement(book, 'title').text = title
        ET.SubElement(book, 'author').text = author
        for key, value in kwargs.items():
            if isinstance(value, dict):
                # 帶屬性的元素
                elem = ET.SubElement(book, key, value.get('attrib', {}))
                elem.text = value.get('text', '')
            else:
                ET.SubElement(book, key).text = str(value)
        return book
    # 構(gòu)建 XML
    root = ET.Element('catalog')
    book1 = create_book(
        '006', 
        'Python數(shù)據(jù)科學(xué)手冊',
        '杰克·萬托布拉斯',
        price={'text': '128.00', 'attrib': {'currency': 'CNY'}},
        publisher='人民郵電出版社',
        year='2020'
    )
    root.append(book1)
    # 保存
    tree = ET.ElementTree(root)
    ET.indent(tree, space='  ')
    tree.write('catalog.xml', encoding='utf-8', xml_declaration=True)
    print("創(chuàng)建 catalog.xml 成功")
create_element_factory()

import xml.etree.ElementTree as ET
import os
class ConfigManager:
    """XML 配置文件管理器"""
    CONFIG_FILE = 'app_config.xml'
    def __init__(self):
        self.tree = None
        self.root = None
        self._load_or_create()
    def _load_or_create(self):
        """加載或創(chuàng)建配置文件"""
        if os.path.exists(self.CONFIG_FILE):
            self.tree = ET.parse(self.CONFIG_FILE)
            self.root = self.tree.getroot()
        else:
            self.root = ET.Element('configuration')
            self.root.set('version', '1.0')
            self.tree = ET.ElementTree(self.root)
            self._save()
    def _save(self):
        """保存配置"""
        ET.indent(self.tree, space='    ')
        self.tree.write(self.CONFIG_FILE, encoding='utf-8', xml_declaration=True)
    def get(self, section: str, key: str, default=None):
        """獲取配置值"""
        section_elem = self.root.find(f".//section[@name='{section}']")
        if section_elem is None:
            return default
        item = section_elem.find(f"item[@key='{key}']")
        if item is None:
            return default
        return item.get('value')
    def set(self, section: str, key: str, value: str):
        """設(shè)置配置值"""
        section_elem = self.root.find(f".//section[@name='{section}']")
        if section_elem is None:
            section_elem = ET.SubElement(self.root, 'section')
            section_elem.set('name', section)
        item = section_elem.find(f"item[@key='{key}']")
        if item is None:
            item = ET.SubElement(section_elem, 'item')
            item.set('key', key)
        item.set('value', str(value))
        self._save()
    def get_database_config(self) -> dict:
        """獲取數(shù)據(jù)庫配置"""
        return {
            'host': self.get('database', 'host', 'localhost'),
            'port': int(self.get('database', 'port', '3306')),
            'username': self.get('database', 'username', 'root'),
            'password': self.get('database', 'password', ''),
            'database': self.get('database', 'database', 'test')
        }
# 使用示例
config = ConfigManager()
config.set('database', 'host', '192.168.1.100')
config.set('database', 'port', '5432')
config.set('app', 'debug', 'true')
print(config.get_database_config())

import csv
import xml.etree.ElementTree as ET
from datetime import datetime
def csv_to_xml(csv_file: str, xml_file: str, root_tag: str = 'data'):
    """將 CSV 文件轉(zhuǎn)換為 XML"""
    root = ET.Element(root_tag)
    root.set('generated', datetime.now().isoformat())
    root.set('source', csv_file)
    with open(csv_file, 'r', encoding='utf-8') as f:
        reader = csv.DictReader(f)
        for i, row in enumerate(reader, 1):
            record = ET.SubElement(root, 'record')
            record.set('id', str(i))
            for key, value in row.items():
                # 清理標(biāo)簽名（XML 標(biāo)簽不能以數(shù)字開頭，不能包含空格）
                clean_key = key.strip().replace(' ', '_')
                if clean_key[0].isdigit():
                    clean_key = 'f_' + clean_key
                field = ET.SubElement(record, clean_key)
                field.text = value
    # 美化并保存
    tree = ET.ElementTree(root)
    ET.indent(tree, space='    ')
    tree.write(xml_file, encoding='utf-8', xml_declaration=True)
    print(f"成功轉(zhuǎn)換: {csv_file} -> {xml_file}")
# 示例 CSV 內(nèi)容：
# name,age,city
# 張三,28,北京
# 李四,32,上海
# csv_to_xml('data.csv', 'output.xml')

# ? 錯誤：默認(rèn)編碼可能不支持中文
tree.write('output.xml')
# ? 正確：指定 UTF-8 編碼
tree.write('output.xml', encoding='utf-8', xml_declaration=True)

# 處理帶命名空間的 XML
xml_with_ns = """<?xml version="1.0"?>
<root xmlns:ns="http://example.com/ns">
    <ns:item>內(nèi)容</ns:item>
</root>"""
root = ET.fromstring(xml_with_ns)
# 方法1：使用完整標(biāo)簽名
for elem in root.findall('{http://example.com/ns}item'):
    print(elem.text)
# 方法2：定義命名空間字典
namespaces = {'ns': 'http://example.com/ns'}
for elem in root.findall('ns:item', namespaces):
    print(elem.text)

# XML 是大小寫敏感的
root.find('Book')  # 找不到 <book>
root.find('book')  # 正確

# 大文件處理（>100MB）
# ? 錯誤：一次性加載
tree = ET.parse('huge.xml')
# ? 正確：迭代解析
for event, elem in ET.iterparse('huge.xml', events=('end',)):
    if elem.tag == 'record':
        process(elem)
        elem.clear()  # 釋放內(nèi)存

# ET 自動處理特殊字符
root = ET.Element('test')
root.text = '<特殊內(nèi)容> & "引號"'
# 輸出: &lt;特殊內(nèi)容&gt; &amp; &quot;引號&quot;