百度360必应搜狗淘宝本站头条
nodejsbufferorg.jsoupsetnocountoncv2.bitwise_nottime.strptime
当前位置：网站首页 > 编程字典 > 正文

加了个小班，整理了下python进阶的知识点，分享给大家!

toyiye 2024-07-09 22:55 17 浏览 0 评论

Python 2 or Python 3 ?

看代码之前先欣赏一下美女舒缓一下内心

Python编码

转码思路

字符串在Python内部的表示是unicode编码，在编码转换时通常需要以unicode作为中间编码。

先将其他编码的字符串解码(decode)成unicode，再从unicode编码(encode)成另一种编码。

转码举例

s.decode('utf-8', 'ignore').encode('gbk', 'ignore')

先由utf-8转为unicode，再由unicode转为gbk，ignore表示忽略非法字符

s = u'中文' # s为unicode
print isinstance(s, unicode) # True
print s.encode('utf-8', 'ignore') # 中文
# 由unicode转为utf-8，ignore表示忽略非法字符

异常处理

try-except-finall结构

import traceback
try:
 xxx
except Exception, e:
 print e
 print traceback.format_exc()
 raise
finally:
 print 'end'

记录错误

import logging
except StandardError, e:
 logging.exception(e)

字符串

不可变类型

>>> a = 'abc'
>>> a
'abc'
>>> b = a.replace('a', 'A')
>>> a
'abc'
>>> b
'Abc'

带关键字与不带关键字的格式化

>>> 'Hello %(name)s !' % {'name': 'James'}
'Hello James !'
>>> 'Hello %s !' % 'James'
'Hello James !'
>>> 'Hello {name} !'.format(name='James')
'Hello James !'
>>> 'Hello {} !'.format('James')
'Hello James !'

列表

列表是由一系列元素组成的有序的序列。

append与extend

list1.append(xxx) # 表示在list1后添加元素xxx
list1.extend(list2) # 表示在list1后添加序列list2

zip函数

>>> list1 = ['a', 'b']
>>> list2 = ['1', '2']
>>> zip(list1, list2)
[('a', '1'), ('b', '2')]
>>> zip(*[list1, list2])
[('a', '1'), ('b', '2')]

enumerate函数：把list变成'索引-元素'对

>>> word = ['c', 'b', 'd', 'a']
>>> word.sort()
>>> word
['a', 'b', 'c', 'd']
>>> for i, value in enumerate(word):
 print i, value
0 a
1 b
2 c
3 d

enumerate函数实现

def enumerate(sequence, start=0):
 n = start
 for elem in sequence:
 yield n, elem
 n += 1

列表去重

>>> l = [1, 2, 4, 7, 2, 1, 8, 6, 1]
>>> list(set(l)) # 不保证顺序
[1, 2, 4, 6, 7, 8]
>>> sorted(list(set(l)), reverse=True) # 顺序
[8, 7, 6, 4, 2, 1]
>>> {}.fromkeys(l).keys() # 不保证顺序
[1, 2, 4, 6, 7, 8]
>>> from collections import OrderedDict
>>> OrderedDict().fromkeys(l).keys() # 按照原有序列顺序
[1, 2, 4, 7, 8, 6]

列表推导式

>>> [x*x for x in range(10)] # 一层循环
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> [m + n for m in 'ABC' for n in 'XYZ'] # 两层循环
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

引用、浅复制、深复制

>>> import copy
>>> l = [0, [1, 2], 3]
>>> l1 = l # 引用
>>> l2 = l[:] # 浅复制
>>> l3 = copy.copy(l) # 浅复制
>>> l4 = copy.deepcopy(l) # 深复制
>>> l
[0, [1, 2], 3]
>>> l1, l2, l3, l4
([0, [1, 2], 3], [0, [1, 2], 3], [0, [1, 2], 3], [0, [1, 2], 3])
>>> l[0] = 9
>>> l
[9, [1, 2], 3]
>>> l1, l2, l3, l4
([9, [1, 2], 3], [0, [1, 2], 3], [0, [1, 2], 3], [0, [1, 2], 3])
>>> l[1][1] = 9
>>> l
[9, [1, 9], 3]
>>> l1, l2, l3, l4
([9, [1, 9], 3], [0, [1, 9], 3], [0, [1, 9], 3], [0, [1, 2], 3])

is 与 ==

is 比较两个对象的标识(引用)

== 比较两个对象的值(内容)

>>> a = [1, 2, 3]
>>> b = a
>>> b is a
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True
def fib1(max_num):
 L = []
 n, a, b = 0, 0, 1
 while n < max_num:
 L.append(b)
 a, b = b, a + b
 n += 1
 return L

迭代器 iterator

__iter__()方法：返回迭代器对象本身。

next()方法：返回迭代器的下一个对象。

生成器 generator

g = (x*x for x in range(5)) # generator

yield

迭代器实现Fibonacci数列

class fib2(object):
 def __init__(self, max_num):
 self.max_num = max_num
 self.n, self.a, self.b = 0, 0, 1
 def __iter__(self):
 return self
 def next(self):
 if self.n < self.max_num:
 r = self.b
 self.a, self.b = self.b, self.a + self.b
 self.n += 1
 return r
 raise StopIteration()

生成器实现Fibonacci数列

def fib3(max_num):
 n, a, b = 0, 0, 1
 while n < max_num:
 yield b
 a, b = b, a + b
 n += 1
>>> g_gen = fib3(10)
>>> g_gen
<generator object fib3 at 0x0000000002716678>
>>> for i in g_gen:
 print i
1
1
2
3
5
8
13
21
34
55

协程 coroutine

生成器是数据的生产者，协程则是数据的消费者。

def my_coroutine(a=None):
 print 'coroutine start...'
 while True:
 f = (yield a)
 print 'result: {}'.format(f)
>>> c = my_coroutine()
>>> next(c)
coroutine start...
>>> c.send('first')
result: first
>>> c.send('second')
result: second
>>> c.close()

元组

元组是只读的列表，不能对其修改。

定义一个只有1个元素的tuple：

建议

t = ('xxx',)

不建议，为什么？

t = ('xxx')

字典

字典是由键key和值value的对应组合成的无序的序列。

字典构造

>>> dict([('a', '1'), ('b', '2')])
{'a': '1', 'b': '2'}
>>> dict.fromkeys(['a', 'b'], 1)
{'a': 1, 'b': 1}
>>> dict.fromkeys('ab', 1)
{'a': 1, 'b': 1}
>>> {'a':'1', 'b':'2'}
{'a': '1', 'b': '2'}
>>> dict(zip(['a', 'b'], ['1', '2']))
{'a': '1', 'b': '2'}
>>> dict([('a', '1'), ('b', '2')])
{'a': '1', 'b': '2'}
>>> dict(a='1', b='2')
{'a': '1', 'b': '2'}
>>> dict(a=1, b=2)
{'a': 1, 'b': 2}

判断一个字典是否有某个key

key in Dict
Dict.has_key(key)

获得指定key的值

Dict.get(key, default) 
# 如果没有key，返回default值，在Dict中不添加该键值。
Dict.setdefault(key, default) 
# 如果没有key，返回default值，并且在Dict中添加该键值。
Dict[key] # 如果没有key，返回error。

items(), keys(), values()

>>> Dict = {'a':1, 'b':2, 'c':3, 'd':4}
>>> Dict.items()
[('a', 1), ('c', 3), ('b', 2), ('d', 4)]
>>> Dict.keys()
['a', 'c', 'b', 'd']
>>> Dict.values()
[1, 3, 2, 4]
>>> Dict.iteritems()
<dictionary-itemiterator object at 0x0000000002BBACC8>
>>> for k, v in Dict.iteritems():
 print k, v
a 1
c 3
b 2
d 4
>>> Dict.iterkeys()
<dictionary-keyiterator object at 0x0000000002BBACC8>
>>> Dict.itervalues()
<dictionary-valueiterator object at 0x0000000002BBAD18>
>>> dct = dict()
>>> dct['foo']
Traceback (most recent call last):
 File "<pyshell#55>", line 1, in <module>
 dct['foo']
KeyError: 'foo'

特殊方法 __missing__

class Dict(dict):
 def __missing__(self, key): ## 当查找不到key的时候，会执行该方法 
 self[key] = []
 return self[key]
>>> dct = Dict()
>>> dct['foo']
[]

按照values值进行降序排列

>>> x = {'a': 2, 'b': 4, 'c': 3, 'd': 1, 'e': 0}
>>> x.items()
[('a', 2), ('c', 3), ('b', 4), ('e', 0), ('d', 1)]

方法1

>>> sorted_x = sorted(x.items(), key=lambda xx:xx[1], reverse=True)
>>> sorted_x
[('b', 4), ('c', 3), ('a', 2), ('d', 1), ('e', 0)]

方法2

>>> sorted_x = x.items()
>>> sorted_x.sort(key=lambda xx:xx[1], reverse=True)
>>> sorted_x
[('b', 4), ('c', 3), ('a', 2), ('d', 1), ('e', 0)]

合并字典

def merge(ds):
 r = {}
 for d in ds:
 for k in d:
 if k in r:
 r[k] += d.get(k)
 else:
 r[k] = d.get(k)
 return r
>>> d1 = {'a':1, 'b':2, 'c':3}
>>> d2 = {'b':4, 'd':5, 'e':6}
>>> d3 = {'b':3, 'c':1, 'e':1}
>>> d = merge([d1, d2, d3])
>>> d
{'a': 1, 'c': 4, 'b': 9, 'e': 7, 'd': 5}

集合

集合与字典类似，也是一组key的集合，但不存储value。

集合构造

>>> set(['a', 'b', 'c'])
set(['a', 'c', 'b'])
>>> set('abc')
set(['a', 'c', 'b'])
>>> {'a', 'b', 'c'}
set(['a', 'c', 'b'])

交集、并集、差集、对称差集

x.intersection(y) 或 x&y
x.union(y) 或 x|y
x.difference(y) 或 x-y
x.symmetric_difference(y) 或 x^y

类与对象

普通继承

class Bird(object):
 def __init__(self):
 self.hungry = True
 def eat(self):
 if self.hungry:
 print 'Aaaah...'
 self.hungry = False
 else:
 print 'No, thanks!'
class SongBird(Bird):
 def sing(self):
 pass
>>> s = SongBird()
>>> s.sing()
>>> s.eat()
Aaaah...
>>> s.eat()
No, thanks!

super继承

class SongBird(Bird):
 def __init__(self):
 self.sound = 'Squawk!'
 def sing(self):
 print self.sound
>>> s = SongBird()
>>> s.sing()
Squawk!
>>> s.eat()
Traceback (most recent call last):
 File "<pyshell#67>", line 1, in <module>
 s.eat()
 File "<pyshell#53>", line 5, in eat
 if self.hungry:
AttributeError: 'SongBird' object has no attribute 'hungry'

super继承

class SongBird(Bird):
 def __init__(self):
 # Bird.__init__(self)
 super(SongBird, self).__init__()
 self.sound = 'Squawk!'
 def sing(self):
 print self.sound
>>> s = SongBird()
>>> s.sing()
Squawk!
>>> s.eat()
Aaaah...
>>> s.eat()
No, thanks!

直接调用内部属性

class Student(object):
 def __init__(self, name, score):
 self.name = name
 self.score = score
>>> s = Student('Bart', 59)
>>> s.score
59
>>> s.score = 60
>>> '%s: %s' % (s.name, s.score)
'Bart: 60'

通过类成员访问内部属性

class Student(object):
 def __init__(self, name, score):
 self._name = name
 self._score = score
 def get_score(self):
 return self._score
 def set_score(self, value):
 self._score = value
 def print_score(self):
 print '%s: %s' % (self._name, self._score)
>>> s = Student('Bart', 59)
>>> s.get_score()
59
>>> s.set_score(60)
>>> s.print_score()
Bart: 60

@property与property()

class Student(object):
 def __init__(self, name, score):
 self._name = name
 self._score = score
 @property
 def score(self):
 return self._score
 @score.setter
 def score(self, value):
 self._score = value
 @score.deleter
 def score(self):
 del self._score
>>> s = Student('Bart', 59)
>>> s.score
59
>>> s.score = 60
>>> s.score
60
>>> del s.score

@property与property()

class Student(object):
 def __init__(self, name, score):
 self._name = name
 self._score = score
 def get_score(self):
 return self._score
 def set_score(self, value):
 self._score = value
 def del_score(self):
 del self._score
 score = property(get_score, set_score, del_score)
>>> s = Student('Bart', 59)
>>> s.score
59
>>> s.score = 60
>>> s.score
60
>>> del s.score

动态绑定

from types import MethodType
class Student(object):
 pass
def set_age(self, age):
 self.age = age
def set_score(self, score):
 self.score = score
>>> s = Student()
>>> s.name = 'Michael'
>>> s.name
'Michael'
>>> s.set_age = MethodType(set_age, s, Student)
>>> s.set_age(25)
>>> s.age
25
>>> Student.set_score = MethodType(set_score, None, Student)
>>> s.set_score(100)
>>> s.score
100

限制变量 __slots__

from types import MethodType
class Student(object):
 __slots__ = ('name', 'age', 'set_age')
>>> s = Student()
>>> s.name = 'Michael'
>>> s.name
'Michael'
>>> s.set_age = MethodType(set_age, s, Student)
>>> s.set_age(25)
>>> s.age
25
>>> Student.set_score = MethodType(set_score, None, Student)
>>> s.set_score(100)
Traceback (most recent call last):
 File "<pyshell#136>", line 1, in <module>
 s.set_score(100)
 File "<pyshell#120>", line 2, in set_score
 self.score = score
AttributeError: 'Student' object has no attribute 'score'

type 动态创建类

def __init__(cls, func):
 cls.func = func
def hello(cls):
 print 'hello world'
Hello = type('Hello', (object,),
 {'__init__':__init__, 'hello':hello})
>>> h = Hello(lambda a, b: a+b)
>>> h.hello()
hello world
>>> type(Hello)
<type 'type'>
>>> type(h)
<class '__main__.Hello'>

元类 __metaclass__ 动态创建类

class HelloMeta(type):
 def __new__(cls, name, bases, dct):
 def __init__(cls, func):
 cls.func = func
 def hello(cls):
 print 'hello world'
 # t = type.__new__(cls, name, bases, dct)
 t = super(HelloMeta, cls).__new__(cls, name, bases, dct)
 t.__init__ = __init__
 t.hello = hello
 return t
class New_Hello(object):
 __metaclass__ = HelloMeta
>>> h = New_Hello(lambda a, b: a+b)
>>> h.hello()
hello world
>>> type(New_Hello)
<class '__main__.HelloMeta'>
>>> type(h)
<class '__main__.New_Hello'>

魔法方法 Magic Method

会话管理器

enter：定义当使用with语句定义一个代码块时会话管理器应该做什么。

exit：定义当一个代码块被执行或者终止后会话管理器应该做什么。

class FileObject(object):
 def __init__(self, filepath='sample.txt'):
 self.file = open(filepath, 'r+')
 def __enter__(self): # 与with语句对应
 return self.file
 def __exit__(self, exc_type, exc_val, exc_tb):
 self.file.close()
 del self.file
with FileObject() as fp:
 print fp.read()

对象的魔法方法

getattr：查询不在dict系统中的对象属性或者对象方法。

class A(object):
 def __getattr__(self, attr):
 def _(*args, **kw):
 print args, kw
 return _
 pass
>>> a = A()
>>> a.xxx
<function _ at 0x0000000002C05F28>
>>> a.xxx1(1, 2, key='ssss')
(1, 2) {'key': 'ssss'}
>>> a.xxx2(1, 2)
(1, 2) {}
>>> a.xxx3(1, 2, 3)
(1, 2, 3) {}

魔法方法举例

class Student(object):
 def __init__(self, name):
 self.name = name
 def __str__(self):
 return 'Student object (name: %s)' % self.name
 def __call__(self):
 print 'Student object (name: %s)' % self.name
 def __getattr__(self, attr):
 if attr == 'score':
 return 99
 else:
 def func(*args, **kw):
 return args, kw
 return func

魔法方法举例

>>> print(s) # 调用__str__方法
Student object (name: Michael)
>>> s() # 调用__call__方法
Student object (name: Michael)
>>> s.name # 调用存在的属性name
'Michael'
>>> s.score # 调用不存在的属性score
99
>>> s.score1 # 调用不存在的属性score1
<function func at 0x0000000002B3E9E8>
>>> s.function(1, 2, 3) # 调用不存在的方法function
((1, 2, 3), {})

函数的参数传递

参数定义

在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。

def func(a, b, c=0, *args, **kw):
 print 'a =', a, 'b =', b, 'c =', c, \
 'args =', args, 'kw =', kw
>>> func(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> func(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> func(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> func(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
>>> args = (1, 2, 3, 4)
>>> kw = {'x': 99}
>>> func(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'x': 99}

默认参数

默认参数必须为不可变对象，如None，string，tuple，不可为list类型。

def add_end(L=[]):
 L.append('END')
 return L
>>> add_end()
['END']
>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']

改为

def add_end(L=None):
 if L is None:
 L = []
 L.append('END')
 return L

可变参数

任意函数都可以表示成func(*args, **kw)形式。

def func(a, b, c):
 print a, b, c
>>> l = [1, 2, 3]
>>> d = {'a':1, 'b':2, 'c':3}
>>> func(*l)
1 2 3
>>> func(**d)
1 2 3

函数式编程

lambda函数

可以动态生成一个函数对象，但该函数只能有一个表达式。

f = lambda x: x*x
def f(x):
 return x*x

map(), reduce(), filter()

>>> range(0,10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> map(lambda x:x*2, range(0,10))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> reduce(lambda x,y:x*10+y, range(0,10))
123456789
>>> filter(lambda x:x%2==0, range(0,10))
[0, 2, 4, 6, 8]

偏函数 partial

不需要定义新的函数，把函数的某些参数固定，返回一个新的函数。

实现sequence的加法和乘法

>>> from functools import partial
>>> import operator
>>> l = [i for i in range(1, 10)]
>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> sum = partial(reduce, operator.add)
>>> sum(l)
45
>>> product = partial(reduce, operator.mul)
>>> product(l)
362880

闭包 closure

指延伸了作用域的函数，它能访问定义体之外定义的环境变量，这个函数和它的环境变量合在一起，就构成了一个闭包。

def lazy_sum(*args):
 def sum(x=0): # sum函数和变量args构成闭包
 ax = x
 for n in args: # 闭包变量args是只读的，不能修改
 ax = ax + n
 return ax
 return sum
>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> 
>>> f
<function sum at 0x0000000002B3E208>
>>> f()
25
>>> f(1)
26

装饰器 decorator

不修改函数的定义，在代码运行期间动态增加功能的方式。

函数装饰器

def decorator(func):
 def wrapper(*args, **kw):
 print 'input:', args, kw
 return func(*args, **kw)
 return wrapper
@decorator
def square_sum(*args, **kw):
 sum = 0
 for i in args:
 sum += i**2
 for j in kw.values():
 sum += j**2
 return sum
>>> square_sum(3, 4, key=5)
input: (3, 4) {'key': 5}
50

类装饰器

class decorator(object):
 def __init__(self, func):
 self.func = func
 def __call__(self, *args, **kw):
 print 'input:', args, kw
 return self.func(*args, **kw)
@decorator
def square_sum(*args, **kw):
 sum = 0
 for i in args:
 sum += i**2
 for j in kw.values():
 sum += j**2
 return sum
>>> square_sum(3, 4, key=5)
input: (3, 4) {'key': 5}

带参数的装饰器

def decorator(*args, **kw):
 text = args
 def _(func):
 def wrapper(*args, **kw):
 print 'text: %s' % text
 print 'input:', args, kw
 return func(*args, **kw)
 return wrapper
 return _

注意：decorator中的(*args, **kw) vs wrapper中的(*args, **kw)

最后再欣赏一下美女吧~

相关推荐

为何越来越多的编程语言使用JSON（为什么编程）

JSON是JavascriptObjectNotation的缩写，意思是Javascript对象表示法，是一种易于人类阅读和对编程友好的文本数据传递方法，是JavaScript语言规范定义的一个子...

何时在数据库中使用 JSON（数据库用json格式存储）

在本文中，您将了解何时应考虑将JSON数据类型添加到表中以及何时应避免使用它们。每天?分享?最新?软件?开发?，Devops，敏捷?，测试?以及?项目?管理?最新?，最热门?的?文章?，每天?花?...

MySQL 从零开始:05 数据类型（mysql数据类型有哪些,并举例）

前面的讲解中已经接触到了表的创建，表的创建是对字段的声明，比如：上述语句声明了字段的名称、类型、所占空间、默认值和是否可以为空等信息。其中的int、varchar、char和decimal都...

JSON对象花样进阶（json格式对象）

一、引言在现代Web开发中，JSON（JavaScriptObjectNotation）已经成为数据交换的标准格式。无论是从前端向后端发送数据，还是从后端接收数据，JSON都是不可或缺的一部分。...

深入理解 JSON 和 Form-data（json和formdata提交区别）

在讨论现代网络开发与API设计的语境下，理解客户端和服务器间如何有效且可靠地交换数据变得尤为关键。这里，特别值得关注的是两种主流数据格式：...

JSON 语法（json 语法 priority）

JSON语法是JavaScript语法的子集。JSON语法规则JSON语法是JavaScript对象表示法语法的子集。数据在名称/值对中数据由逗号分隔花括号保存对象方括号保存数组JS...

JSON语法详解（json的语法规则）

JSON语法规则JSON语法是JavaScript对象表示法语法的子集。数据在名称/值对中数据由逗号分隔大括号保存对象中括号保存数组注意：json的key是字符串,且必须是双引号，不能是单引号...

MySQL JSON数据类型操作（mysql的json）

概述mysql自5.7.8版本开始，就支持了json结构的数据存储和查询，这表明了mysql也在不断的学习和增加nosql数据库的有点。但mysql毕竟是关系型数据库，在处理json这种非结构化的数据...

JSON的数据模式（json数据格式示例）

像XML模式一样，JSON数据格式也有Schema，这是一个基于JSON格式的规范。JSON模式也以JSON格式编写。它用于验证JSON数据。JSON模式示例以下代码显示了基本的JSON模式。{"...

前端学习——JSON格式详解（后端json格式）

JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。它基于JavaScriptProgrammingLa...

什么是 JSON:详解 JSON 及其优势（什么叫json）

现在程序员还有谁不知道JSON吗？无论对于前端还是后端，JSON都是一种常见的数据格式。那么JSON到底是什么呢？JSON的定义...

PostgreSQL JSON 类型:处理结构化数据

PostgreSQL提供JSON类型，以存储结构化数据。JSON是一种开放的数据格式，可用于存储各种类型的值。什么是JSON类型？JSON类型表示JSON(JavaScriptO...

JavaScript:JSON、三种包装类（javascript 包）

JOSN:我们希望可以将一个对象在不同的语言中进行传递，以达到通信的目的，最佳方式就是将一个对象转换为字符串的形式JSON（JavaScriptObjectNotation）-JS的对象表示法...

Python数据分析 只要1分钟 教你玩转JSON 全程干货

Json简介：Json，全名JavaScriptObjectNotation,JSON(JavaScriptObjectNotation(记号、标记))是一种轻量级的数据交换格式。它基于J...

比较一下JSON与XML两种数据格式?（json和xml哪个好）

JSON（JavaScriptObjectNotation）和XML（eXtensibleMarkupLanguage）是在日常开发中比较常用的两种数据格式，它们主要的作用就是用来进行数据的传...

取消回复欢迎 你 发表评论:

请填写验证码
一周热门
最近发表
标签列表