Len() e funzioni di riempimento compatibili con tabstop di Python

Question

Len() e le funzioni di riempimento di Python come string.ljust() non supportano il tabstop, ad es.trattano " " come qualsiasi altro carattere a larghezza singola e non arrotondano per eccesso al multiplo più vicino di tabstop.Esempio:

len('Bear\tnecessities\t')

è 17 invece di 24 (cioè4+(8-4)+11+(8-3) )

e dire che voglio anche una funzione pad_with_tabs(s) tale che

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

Alla ricerca di semplici implementazioni di questi: innanzitutto compattezza e leggibilità, poi efficienza.Questa è una domanda elementare ma irritante.@gnibbler: puoi mostrare una soluzione puramente Pythonica, anche se dice 20 volte meno efficiente?

Certo potresti convertire avanti e indietro usando str.expandtabs(TABWIDTH), ma è goffo.Importazione della matematica per ottenere TABWIDTH * int( math.ceil(len(s)*1.0/TABWIDTH) ) sembra anche un enorme eccessivo.

Non potrei fare niente di più elegante di quanto segue:

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 poiché le stringhe Python sono immutabili e, a meno che non vogliamo patchare la nostra funzione nel modulo string per aggiungerla come metodo, dobbiamo anche assegnare al risultato della funzione:

s = pad_with_tabs(s, ...)

In particolare non sono riuscito a ottenere approcci puliti utilizzando list-comprehension o string.join(...)

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

senza caratteri speciali i casi in cui len(s) è < un multiplo intero di TABWIDTH, o già len(s)>=maxlen.

Qualcuno può mostrare funzioni len() e pad_with_tabs() migliori?

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)

Perché ho usato expandtabs()?
Beh, è ​​veloce

$ 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

Tutto ciò che scorre sulla tua stringa sarà più lento, perché solo l'iterazione è ~ 4 volte più lenta di expandtabs anche quando non fai nulla nel ciclo.

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

Anche solo la suddivisione in schede richiede più tempo.Avresti comunque bisogno di ripetere la divisione e riempire ogni elemento fino al punto di tabulazione

Answer 2

Credo gnibbler è il migliore per la maggior parte dei casi prectical. Ma in ogni caso, qui è un ingenuo (senza tener conto CR, LF ecc), soluzione per calcolare la lunghezza della stringa senza creare copia ampliato:

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

Probabilmente potrebbe essere utile per alcune stringhe di grandi o anche file di memoria mappata. E qui è la funzione imbottitura un po 'ottimizzato:

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) ) è davvero un enorme eccesso di uccidere; è possibile ottenere lo stesso risultato molto più semplicemente. Per i positivo e n, utilizzare:

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

Questa procedura funziona in quasi tutte le lingue che abbia mai usato, dopo la traduzione appropriata.

Poi si può fare next_pos = round_up_positive_int(len(s), TABWIDTH)

Per un leggero aumento nell'eleganza del codice, invece di

while(s_len < maxlen):

utilizzare questo:

while s_len < maxlen: