Question

Python的len（）和padding函数（如string.ljust（））不能识别tabstop，即它们将'\ t'视为任何其他单宽度字符，并且不会将len舍入到最接近tabstop的倍数。示例：

len('Bear\tnecessities\t')

是17而不是24（即4+（8-4）+11+（8-3））

并说我还想要一个函数pad_with_tabs(s)，以便

pad_with_tabs('Bear', 15) = 'Bear\t\t'

寻找这些的简单实现 - 首先是紧凑性和可读性，效率第二。这是一个基本但令人恼火的问题。 @gnibbler - 你能展示一个纯粹的Pythonic解决方案，即使效率低20倍吗？

当然你可以使用str.expandtabs（TABWIDTH）来回转换，但那很笨重。导入数学以获得TABWIDTH * int( math.ceil(len(s)*1.0/TABWIDTH) )似乎也是一种大规模的过度杀伤。

我无法管理比以下更优雅的东西：

TABWIDTH = 8

def pad_with_tabs(s,maxlen):
  s_len = len(s)
  while s_len < maxlen:
    s += '\t'
    s_len += TABWIDTH - (s_len % TABWIDTH)
  return s

并且由于Python字符串是不可变的，除非我们想将我们的函数修补为字符串模块以将其添加为方法，否则我们还必须分配函数的结果：

s = pad_with_tabs(s, ...)

特别是我无法使用list-comprehension或string.join（...）

获得干净的方法

''.join([s, '\t' * ntabs])

没有特殊套管的情况下，len（s）是＆lt; TABWIDTH的整数倍，或len（s）＆gt; =已经是maxlen。

任何人都可以显示更好的len（）和pad_with_tabs（）函数吗？

Answer 1

TABWIDTH=8
def my_len(s):
    return len(s.expandtabs(TABWIDTH))

def pad_with_tabs(s,maxlen):
    return s+"\t"*((maxlen-len(s)-1)/TABWIDTH+1)

为什么我使用expandtabs()？
嗯，这很快

$ python -m timeit '"Bear\tnecessities\t".expandtabs()'
1000000 loops, best of 3: 0.602 usec per loop
$ python -m timeit 'for c in "Bear\tnecessities\t":pass'
100000 loops, best of 3: 2.32 usec per loop
$ python -m timeit '[c for c in "Bear\tnecessities\t"]'
100000 loops, best of 3: 4.17 usec per loop
$ python -m timeit 'map(None,"Bear\tnecessities\t")'
100000 loops, best of 3: 2.25 usec per loop

任何迭代你的字符串的东西都会变慢，因为即使你在循环中什么都不做，迭代也比expandtabs快〜4倍。

$ python -m timeit '"Bear\tnecessities\t".split("\t")'
1000000 loops, best of 3: 0.868 usec per loop

即使只是在标签上拆分也需要更长的时间。您仍然需要迭代拆分并将每个项目填充到tabstop

Answer 2

我相信gnibbler对大多数情况都是最好的。但无论如何，这是一个天真的（没有会计CR，LF等）解决方案来计算字符串的长度而不创建扩展副本：

def tab_aware_len(s, tabstop=8):
    pos = -1
    extra_length = 0
    while True:
        pos = s.find('\t', pos+1)
        if pos<0:
            return len(s) + extra_length
        extra_length += tabstop - (pos+extra_length) % tabstop - 1

对于某些大字符串甚至是内存映射文件，它可能很有用。这里的填充函数有点优化：

def pad_with_tabs(s, max_len, tabstop=8):
    length = tab_aware_len(s, tabstop)
    if length<max_len:
        s += '\t' * ((max_len-1)//tabstop + 1 - length//tabstop)
    return s

Answer 3

TABWIDTH * int( math.ceil(len(s)*1.0/TABWIDTH) )确实是一次大规模的过度杀戮;你可以更简单地得到相同的结果。对于正面i和n，请使用：

def round_up_positive_int(i, n):
    return ((i + n - 1) // n) * n

在适当的翻译后，此程序几乎适用于我曾经使用的任何语言。

然后你可以next_pos = round_up_positive_int(len(s), TABWIDTH)

稍微增加代码的优雅，而不是

while(s_len < maxlen):

使用它：

while s_len < maxlen:

Answer 4

不幸的是，我无法按原样使用已接受的答案，因此这里进行了一些修改，以防万一有人遇到相同的问题并通过搜索发现该帖子：

from decimal import Decimal, ROUND_HALF_UP
TABWIDTH = 4

def pad_with_tabs(src, max_len):
    return src + "\t" * int(
        Decimal((max_len - len(src.expandtabs(TABWIDTH))) / TABWIDTH + 1).quantize(0, ROUND_HALF_UP))


def pad_fields(input):
    result = []
    longest = max(len(x) for x in input)
    for row in input:
        result.append(pad_with_tabs(row, longest))
    return result

输出列表包含正确填充的行，这些行的制表符计数取整，因此，在原始答案中未添加制表符的情况下，无论转角.5情况如何，结果数据都将具有相同的缩进级别。

Python tabstop-aware len（）和填充函数

4 个答案: