Python网络编程:手写生成html表格

最新推荐文章于 2025-05-31 06:00:00 发布

小基基o_O

最新推荐文章于 2025-05-31 06:00:00 发布

阅读量2.7k

点赞数 1

CC 4.0 BY-SA版权

文章标签： python html 树形结构树结构表格

本文链接：https://blog.youkuaiyun.com/Yellow_python/article/details/100546841

玩Python 专栏收录该内容

30 篇文章

订阅专栏

本文详细介绍HTML表格的标签使用，包括如何生成基本表格、带有列名的表格、跨行表格以及从字典生成表格的方法。同时，文章还介绍了如何将树形结构转化为跨行表格，以及NLP领域中实体识别在表格生成的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

html表格标签

标签	描述
<table>	表格
<th>	表格的表头
<tr>	表格的行
<td>	表格单元
<caption>	表格标题
<colgroup>	表格列的组
<col>	用于表格列的属性
<thead>	表格的页眉
<tbody>	表格的主体
<tfoot>	表格的页脚

常用标签生成函数

body = lambda x: '<html><head><meta charset="UTF-8"></head><body>%s</body></html>' % x
h1 = lambda x: '<h1>{}</h1>'.format(x)  # 标题1
h2 = lambda x: '<h2>{}</h2>'.format(x)  # 标题2
mark = lambda x: '<mark>{}</mark>'.format(x)  # 高亮
pre = lambda x: '<pre>%s</pre>' % x  # 预格化
font = lambda x, s=5, c='red': '<font size="%d" color="%s">%s</font>' % (s, c, x)  # 字体
href = lambda x, url: '<a href="{}" target="_blank">{}</a>'.format(url, x)  # 超链接（新窗口打开）
hr = '\n<hr>\n'  # 分割线
table = lambda x: '<table border="1">%s</table>' % x  # 表格
tr = lambda x: '<tr>%s</tr>' % x  # 表格：行
th = lambda x: '<th bgcolor="#66B3FF">%s</th>' % x  # 表头单元（蓝色背景）
td = lambda x: '<td>{}</td>'.format(x)  # 表格：单元
colspan = lambda x, i: '<td colspan="%d">%s</td>' % (i, x)  # 跨列
rowspan = lambda x, i: '<td rowspan="%d">%s</td>' % (i, x)  # 跨行
ls2td = lambda ls: tr(''.join(td(x) for x in ls))  # list转表格行（表头）
ls2th = lambda ls: tr(''.join(th(x) for x in ls))  # list转表格行

嵌套列表 -> 表格

极简版

def make_tb(ls_of_ls):
    return table(''.join(tr(''.join(td(i) for i in ls)) for ls in ls_of_ls))

lss = [['笑菊花', '深扣菊花舔指笑，菊花一闪误终身'], ['菊花红', '接天莲叶无穷碧，硬日菊花别样红']]
print(make_tb(lss))

笑菊花	深扣菊花舔指笑，菊花一闪误终身
菊花红	接天莲叶无穷碧，硬日菊花别样红

+列名

def make_tb(ls_of_ls, fields):
    _tb = ''.join(tr(''.join(td(i) for i in ls)) for ls in ls_of_ls)
    _th = tr(''.join(th(i) for i in fields))  # 表头
    return table(_th + _tb)

lss = [['笑菊花', '深扣菊花舔指笑，菊花一闪误终身'], ['菊花红', '接天莲叶无穷碧，硬日菊花别样红']]
print(make_tb(lss, ['title', 'text']))

title	text
笑菊花	深扣菊花舔指笑，菊花一闪误终身
菊花红	接天莲叶无穷碧，硬日菊花别样红

字典 -> 跨行表格

列数=2

def make_tb(dt_of_ls, fields):
    _th = tr(''.join(th(i) for i in fields))  # 表头
    # _tb = ''
    # for k, v in dt_of_ls.items():
    #     le = len(v)
    #     for i in range(le):
    #         _tb += '<tr>'
    #         if i == 0:
    #             _tb += '<td rowspan="%d">%s</td>' % (le, k)
    #         _tb += '<td>%s</td>' % v[i]
    #         _tb += '</tr>'
    _tb = ''.join(tr((rowspan(k, len(v))if i == 0else'')+td(v[i]))for k, v in dt_of_ls.items()for i in range(len(v)))
    return table(_th + _tb)

dts = {'苹果': ['苹果醋'], '华为': [], '小米': ['小米粥', '小米蛋', '小米肠']}
print(make_tb(dts, ['title', 'article']))

title	article
苹果	苹果醋
小米	小米粥
	小米蛋
	小米肠

列数>2

def make_tb(dt_of_lss, fields):
    _th = tr(''.join(th(i) for i in fields))  # 表头
    # _tb = ''
    # for k, v in dt_of_lss.items():
    #     le = len(v)
    #     for i in range(le):
    #         _tb += '<tr>'
    #         if i == 0:
    #             _tb += '<td rowspan="%d">%s</td>' % (le, k)
    #         for j in v[i]:
    #             _tb += '<td>%s</td>' % j
    #         _tb += '</tr>'
    _tb = ''.join(
        tr((rowspan(k, len(v)) if i == 0 else '')+''.join(td(j) for j in v[i]))
        for k, v in dt_of_lss.items()
        for i in range(len(v)))
    return table(_th+_tb)

dtss = {
    '用小米机买小米粥和苹果汁': [('小米机', '小米'), ('小米粥', '小米'), ('苹果汁', '苹果')],
    '买华为送大米': [],
    '买大米送苹果醋': [('苹果醋', '苹果')],
}
print(make_tb(dtss, ['text', 'phrase', 'word']))

text	phrase	word
用小米机买小米粥和苹果汁	小米机	小米
	小米粥	小米
	苹果汁	苹果
买大米送苹果醋	苹果醋	苹果

邻接表（树形结构） -> 跨行表

名称	说明	例子
线性结构	有序数据元素的集合	栈、队列、一维数组
非线性结构	其逻辑特征是一个结点元素可能有多个直接前驱和多个直接后继	树、图、多维数组
树形结构	数据元素之间存在着【一对多】的树形关系	二叉树
邻接表	存储方法跟树的孩子链表示法相类似，是一种顺序分配和链式分配相结合的存储结构

def make_tree(adjacency_list):
    tree = {'root': set()}
    depth: dict[int, set[str]] = {0: {'root'}}
    for node, parent_node in adjacency_list:
        # 树
        if parent_node is None:
            parent_node = 'root'
        if parent_node not in tree:
            tree[parent_node] = set()
        tree[parent_node].add(node)
        # 树深度
        lvl = int(len(node) / 2)
        if lvl not in depth:
            depth[lvl] = set()
        depth[lvl].add(node)
    # 行数
    rows: dict[str, int] = dict()
    for lvl in sorted(depth.keys(), reverse=True):
        for node in depth[lvl]:
            if node in tree:
                rows[node] = sum(rows[n] for n in tree[node])
            else:
                rows[node] = 1
    return tree, depth, rows


def make_tb(tree, depth, rows):
    def order(node: str) -> list:
        ls = [node]
        for child_node in sorted(tree.get(node, [])):
            ls.extend(order(child_node))
        return ls

    # 表头
    columns = sorted(depth.keys())
    columns_th = ls2th(columns)
    # 表数据
    tr_ls = ['']
    order_ls = order('root')
    for n in order_ls:
        tr_ls[-1] += rowspan(n, rows[n])
        if rows[n] == 1:
            tr_ls[-1] = tr(tr_ls[-1])
            tr_ls.append('')
    print(tree, depth, rows, order_ls, sep='\n')
    return table(columns_th + '\n' + '\n'.join(t for t in tr_ls if t))


if __name__ == '__main__':
    _adjacency_list = (
        ('44', None),
        ('4403', '44'),
        ('440305', '4403'),
        ('440306', '4403'),
        ('4406', '44'),
        ('440604', '4406'),
        ('440605', '4406'),
        ('440606', '4406'),
        ('440607', '4406'),
        ('440608', '4406'),
        ('45', None),
        ('4501', '45'),
        ('450102', '4501'),
        ('450103', '4501'))
    print(make_tb(*make_tree(_adjacency_list)))

NLP版（NER）

from jieba import tokenize
replace_word = lambda clause, word, head, tail: clause[:head] + mark(word) + clause[tail:]

def make_tb(dt_of_lss, fields):
    _th = tr(''.join(th(i) for i in fields))  # 表头
    _tb = ''.join(
        '<tr>%s%s</tr>' % (rowspan(k, len(v)) if i == 0 else '', ''.join(td(j) for j in v[i]))
        for k, v in dt_of_lss.items() for i in range(len(v)))
    return table(_th+_tb)

def ner(texts, entities):
    dt_of_lss = dict()
    for text in texts:
        dt_of_lss[text] = []
        for clause in text.split('，'):  # 切句
            for word, head, tail in tokenize(clause):  # 分词+位置
                if word in entities:  # NER
                    dt_of_lss[text].append([replace_word(clause, word, head, tail), word])
    return dt_of_lss

dtss = ner(['买小米机，送了袋小米和苹果', '诺基亚', '买华为送苹果'], {'小米', '苹果'})
print(make_tb(dtss, ['text', 'phrase', 'word']))

text	phrase	word
买小米机，送了袋小米和苹果	买小米机	小米
	送了袋小米和苹果	小米
	送了袋小米和苹果	苹果
买华为送苹果	买华为送苹果	苹果

<table border="1">
<tr><th bgcolor="#66B3FF">text</th><th bgcolor="#66B3FF">phrase</th><th bgcolor="#66B3FF">word</th></tr>
<tr><td rowspan="3">买小米机，送了袋小米和苹果</td><td>买<mark>小米</mark>机</td><td>小米</td></tr>
<tr><td>送了袋<mark>小米</mark>和苹果</td><td>小米</td></tr>
<tr><td>送了袋小米和<mark>苹果</mark></td><td>苹果</td></tr>
<tr><td rowspan="1">买华为送苹果</td><td>买华为送<mark>苹果</mark></td><td>苹果</td></tr>
</table>

ALL

body = lambda x: '<html><head><meta charset="UTF-8"></head><body>%s</body></html>' % x
h1 = lambda x: '<h1>{}</h1>'.format(x)  # 标题1
h2 = lambda x: '<h2>{}</h2>'.format(x)  # 标题2
mark = lambda x: '<mark>{}</mark>'.format(x)  # 高亮
pre = lambda x: '<pre>%s</pre>' % x  # 预格化
font = lambda x, s=5, c='red': '<font size="%d" color="%s">%s</font>' % (s, c, x)  # 字体
href = lambda x, url: '<a href="{}" target="_blank">{}</a>'.format(url, x)  # 超链接（新窗口打开）
hr = '\n<hr>\n'  # 分割线
table = lambda x: '<table border="1">%s</table>' % x  # 表格
tr = lambda x: '<tr>%s</tr>' % x  # 表格：行
th = lambda x: '<th bgcolor="#66B3FF">%s</th>' % x  # 表头单元（蓝色背景）
td = lambda x: '<td>{}</td>'.format(x)  # 表格：单元
colspan = lambda x, i: '<td colspan="%d">%s</td>' % (i, x)  # 跨列
rowspan = lambda x, i: '<td rowspan="%d">%s</td>' % (i, x)  # 跨行
ls2td = lambda ls: tr(''.join(td(x) for x in ls))  # list转表格行（表头）
ls2th = lambda ls: tr(''.join(th(x) for x in ls))  # list转表格行


def make_tb(ls_of_ls):
    return table(''.join(tr(''.join(td(i) for i in ls)) for ls in ls_of_ls))


lss = [['笑菊花', '深扣菊花舔指笑，菊花一闪误终身'], ['菊花红', '接天莲叶无穷碧，硬日菊花别样红']]
print(make_tb(lss))
print('-'*99)


def make_tb(ls_of_ls, fields):
    _tb = ''.join(tr(''.join(td(i) for i in ls)) for ls in ls_of_ls)
    _th = tr(''.join(th(i) for i in fields))  # 表头
    return table(_th + _tb)


lss = [['笑菊花', '深扣菊花舔指笑，菊花一闪误终身'], ['菊花红', '接天莲叶无穷碧，硬日菊花别样红']]
print(make_tb(lss, ['title', 'text']))
print('-'*99)


def make_tb(dt_of_ls, fields):
    _th = tr(''.join(th(i) for i in fields))  # 表头
    _tb = ''.join(tr((rowspan(k, len(v))if i == 0else'')+td(v[i]))for k, v in dt_of_ls.items()for i in range(len(v)))
    return table(_th + _tb)


dts = {'苹果': ['苹果醋'], '华为': [], '小米': ['小米粥', '小米蛋', '小米肠']}
print(make_tb(dts, ['title', 'article']))
print('-'*99)


def make_tb(dt_of_lss, fields):
    _th = tr(''.join(th(i) for i in fields))  # 表头
    _tb = ''.join(
        tr((rowspan(k, len(v)) if i == 0 else '')+''.join(td(j) for j in v[i]))
        for k, v in dt_of_lss.items()
        for i in range(len(v)))
    return table(_th+_tb)


dtss = {
    '用小米机买小米粥和苹果汁': [('小米机', '小米'), ('小米粥', '小米'), ('苹果汁', '苹果')],
    '买华为送大米': [],
    '买大米送苹果醋': [('苹果醋', '苹果')],
}
print(make_tb(dtss, ['text', 'phrase', 'word']))
print('-'*99)


from jieba import tokenize
replace_word = lambda clause, word, head, tail: clause[:head] + mark(word) + clause[tail:]


def make_tb(dt_of_lss, fields):
    _th = tr(''.join(th(i) for i in fields))  # 表头
    _tb = ''.join(
        '<tr>%s%s</tr>' % (rowspan(k, len(v)) if i == 0 else '', ''.join(td(j) for j in v[i]))
        for k, v in dt_of_lss.items()
        for i in range(len(v)))
    return table(_th+_tb)


def ner(texts, entities):
    dt_of_lss = dict()
    for text in texts:
        dt_of_lss[text] = []
        for clause in text.split('，'):  # 切句
            for word, head, tail in tokenize(clause):  # 分词+位置
                if word in entities:  # NER
                    dt_of_lss[text].append([replace_word(clause, word, head, tail), word])
    return dt_of_lss


dtss = ner(['买小米机，送了袋小米和苹果', '诺基亚', '买华为送苹果'], {'小米', '苹果'})
print(make_tb(dtss, ['text', 'phrase', 'word']))