Len() com reconhecimento de tabstop em Python e funções de preenchimento

Question

As funções len() e de preenchimento do Python, como string.ljust(), não reconhecem tabstop, ou seja,eles tratam ' ' como qualquer outro caractere de largura única e não arredondam len para o múltiplo mais próximo de tabstop.Exemplo:

len('Bear\tnecessities\t')

é 17 em vez de 24 (ou seja,4+(8-4)+11+(8-3) )

e dizer que também quero uma função pad_with_tabs(s) de tal modo que

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

Procurando implementações simples destes - compactação e legibilidade em primeiro lugar, eficiência em segundo.Esta é uma pergunta básica, mas irritante.@gnibbler - você pode mostrar uma solução puramente Pythonic, mesmo que seja 20x menos eficiente?

Claro que você poderia converter para frente e para trás usando str.expandtabs(TABWIDTH), mas isso é desajeitado.Importando matemática para obter TABWIDTH * int( math.ceil(len(s)*1.0/TABWIDTH) ) também parece um grande exagero.

Não consegui fazer nada mais elegante do que o seguinte:

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

e como as strings do Python são imutáveis ​​e, a menos que queiramos corrigir nossa função no módulo de string para adicioná-la como um método, também devemos atribuir ao resultado da função:

s = pad_with_tabs(s, ...)

Em particular, não consegui abordagens limpas usando compreensão de lista ou string.join(...)

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

sem maiúsculas e minúsculas especiais, os casos em que len(s) é < um múltiplo inteiro de TABWIDTH, ou len(s)>=maxlen já.

Alguém pode mostrar funções len() e pad_with_tabs() melhores?

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)

Por que eu usei expandtabs()?
Bem, é rápido

$ 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

Qualquer coisa que itere sobre sua string será mais lenta, porque apenas a iteração é cerca de 4 vezes mais lenta que expandtabs mesmo quando você não faz nada no loop.

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

Até mesmo a divisão em guias leva mais tempo.Você ainda precisaria iterar sobre a divisão e preencher cada item na tabstop

Answer 2

Acredito que o gnibbler é o melhor para a maioria dos casos práticos.Mas de qualquer forma, aqui está uma solução ingênua (sem contabilização de CR, LF etc) para calcular o comprimento da string sem criar uma cópia expandida:

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

Provavelmente poderia ser útil para algumas strings enormes ou até mesmo arquivos mapeados na memória.E aqui está a função de preenchimento um pouco otimizada:

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) ) é de fato um enorme exagero;você pode obter o mesmo resultado de maneira muito mais simples.Para positivo i e n, usar:

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

Este procedimento funciona em praticamente qualquer idioma que já usei, após a tradução apropriada.

Então você pode fazer next_pos = round_up_positive_int(len(s), TABWIDTH)

Para um ligeiro aumento na elegância do seu código, em vez de

while(s_len < maxlen):

usa isto:

while s_len < maxlen: