按字符和元素的切片列表，Python

Question

I have a text column of limited width, and each row is a list of multiple elements, delimited by by semicolons. I would like to remove all list elements that cause the row to pass the character limit.

Previously, I was using

   if len(row[7].split(';')) > 5:
        row[7] = ('; '.join(row[7].split(';')[1:5]).strip())[:45]

This creates two obvious problems:

• Some lists have fewer than 5 elements and more than 45 characters, so the conditional does not delete the extra elements like it should
• List elements get cut off mid-word.

This is an example input:

 Foo; Bar; Aoicsdeadwcwewrw; owierwicowmwoemow; aoweirwoer
 ODIFUWE
 acowierwe; asodicjwoer; s; ow; w; w

This is the corresponding example output:

 Foo; Bar; Aoicsdeadwcwewrw
 ODIFUWE
 acowierwe; asodicjwoer; s; ow; w

The limit is 5 elements or 45 characters, and if the line reaches either of these limits the trailing elements should be cut off.

Answer 1

I think this generator is the most efficient way to determine where to cut your list of strings:

def limit(iterable, max_num, max_length, padding_length):
    seen_length = -padding_length  # the first value will not be padded so start negative
    for i, s in enumerate(iterable, 1):
        if i > max_num or seen_length + padding_length + len(s) > max_length:
            return
        seen_length += padding_length + len(s)
        yield s

Use it like this:

row[7] = "; ".join(limit(row[7].split("; "), 5, 45, 2)

The generator doesn't join any strings, just adds their lengths together, so using it and one join will be O(N+M) where N is the number of strings and M is the length of the result string. This is better than gnibbler 's solution, which is O(N*M) due to repeated join s. This algorithmic improvement probably doesn't matter much for relatively short and few strings, like you describe, but if you were trying to limit things to say, 500 items and a length of thousands of characters, you'd probably notice the difference.

Answer 2

>>> data = """ Foo; Bar; Aoicsdeadwcwewrw; owierwicowmwoemow; aoweirwoer
...  ODIFUWE
...  acowierwe; asodicjwoer; s; ow; w; w""".split("\n")
>>> 
>>> for row in data:
...     row = row.split(";")[:5]
...     res = []
...     for item in row:
...         if len(";".join(res + [item])) > 45: break
...         res.append(item)
...     print ";".join(res)
... 
 Foo; Bar; Aoicsdeadwcwewrw
 ODIFUWE
 acowierwe; asodicjwoer; s; ow; w

Answer 3

Here is a functional breakdown, which should make it more obvious what is going on:

data = [
    " Foo; Bar; Aoicsdeadwcwewrw; owierwicowmwoemow; aoweirwoer",
    " ODIFUWE",
    " acowierwe; asodicjwoer; s; ow; w; w"
]

def first_n_chars(s, break_on, n):
    if len(s) > n:
        return s[:s.rfind(break_on, 0, n + len(break_on))]
    else:
        return s

def first_n_groups(s, break_on, n):
    try:
        end = -1
        for _ in range(n):
            end = s.index(break_on, end+1)
        return s[:end]
    except ValueError:
        return s

fortyfivechars = (first_n_chars (s, '; ', 45) for s in data)
fivegroups     = (first_n_groups(s, '; ', 5)  for s in fortyfivechars)
trimmed_data   = list(fivegroups)

which results in

[' Foo; Bar; Aoicsdeadwcwewrw',
 ' ODIFUWE',
 ' acowierwe; asodicjwoer; s; ow; w']

Answer 4

def myfilter(x, wmax=5, cmax=45, d=';'):
    words = x.split(d)

    nwords = 0
    nchars = 0
    s = []
    for i in words:
        nwords += 1
        nchars += len(i) + len(d)
        if (nwords >= wmax) | (nchars > cmax+1):
            break
        s.append(i)
    return ';'.join(s)

Something like this should work.