Python obcina długi ciąg

Jak obciąć ciąg znaków do 75 znaków w Pythonie?

Oto jak to się robi w JavaScript:

var data="saddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddsaddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddsadddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
var info = (data.length > 75) ? data.substring[0,75] + '..' : data;

info = (data[:75] + '..') if len(data) > 75 else data

Jeszcze krótszy:

info = data[:75] + (data[75:] and '..')

Jeszcze bardziej zwięzłe:

data = data[:75]

Jeśli ma mniej niż 75 znaków, nie będzie żadnych zmian.

Jeśli używasz Python 3.4+, możesz użyć textwrap.shortenze standardowej biblioteki:

Zwiń i skróć podany tekst, aby pasował do podanej szerokości.

Najpierw białe znaki w tekście są zwinięte (wszystkie białe znaki są zastępowane pojedynczymi spacjami). Jeśli wynik mieści się w szerokości, jest zwracany. W przeciwnym razie wystarczająca liczba słów zostanie usunięta z końca, aby pozostałe słowa plus symbol zastępczy pasowały do ​​szerokości:

>>> textwrap.shorten("Hello  world!", width=12)
'Hello world!'
>>> textwrap.shorten("Hello  world!", width=11)
'Hello [...]'
>>> textwrap.shorten("Hello world", width=10, placeholder="...")
'Hello...'

W przypadku rozwiązania Django (o którym nie wspomniano w pytaniu):

from django.utils.text import Truncator
value = Truncator(value).chars(75)

Zajrzyj do kodu źródłowego Truncatora, aby docenić problem: https://github.com/django/django/blob/master/django/utils/text.py#L66

Obcięcie za pomocą Django: obcinanie Django HTML

Możesz użyć tego jednowierszowego:

data = (data[:75] + '..') if len(data) > 75 else data

Z wyrażeniem regularnym:

re.sub(r'^(.{75}).*$', '\g<1>...', data)

Długie łańcuchy są obcinane:

>>> data="11111111112222222222333333333344444444445555555555666666666677777777778888888888"
>>> re.sub(r'^(.{75}).*$', '\g<1>...', data)
'111111111122222222223333333333444444444455555555556666666666777777777788888...'

Krótsze łańcuchy nigdy nie są obcinane:

>>> data="11111111112222222222333333"
>>> re.sub(r'^(.{75}).*$', '\g<1>...', data)
'11111111112222222222333333'

W ten sposób możesz także „wyciąć” środkową część sznurka, co w niektórych przypadkach jest ładniejsze:

re.sub(r'^(.{5}).*(.{5})$', '\g<1>...\g<2>', data)

>>> data="11111111112222222222333333333344444444445555555555666666666677777777778888888888"
>>> re.sub(r'^(.{5}).*(.{5})$', '\g<1>...\g<2>', data)
'11111...88888'

Ta metoda nie używa żadnej, jeśli:

data[:75] + bool(data[75:]) * '..'

limit = 75
info = data[:limit] + '..' * (len(data) > limit)

Jeszcze inne rozwiązanie. Dzięki, Truea Falsena końcu otrzymasz małą informację zwrotną na temat testu.

data = {True: data[:75] + '..', False: data}[len(data) > 75]

To tylko w:

n = 8
s = '123'
print  s[:n-3] + (s[n-3:], '...')[len(s) > n]
s = '12345678'
print  s[:n-3] + (s[n-3:], '...')[len(s) > n]
s = '123456789'     
print  s[:n-3] + (s[n-3:], '...')[len(s) > n]
s = '123456789012345'
print  s[:n-3] + (s[n-3:], '...')[len(s) > n]

123
12345678
12345...
12345...

       >>> info = lambda data: len(data)>10 and data[:10]+'...' or data
       >>> info('sdfsdfsdfsdfsdfsdfsdfsdfsdfsdfsdf')
           'sdfsdfsdfs...'
       >>> info('sdfsdf')
           'sdfsdf'
       >>> 

Nie można tak naprawdę „obciąć” łańcucha Pythona, tak jak można zrobić dynamicznie przydzielany ciąg C. Ciągi w Pythonie są niezmienne. To, co możesz zrobić, to pokroić ciąg, jak opisano w innych odpowiedziach, uzyskując nowy ciąg zawierający tylko znaki zdefiniowane przez przesunięcia plasterka i krok. W niektórych (niepraktycznych) przypadkach może to być trochę denerwujące, na przykład gdy wybierasz Python jako język wywiadu, a ankieter prosi cię o usunięcie zduplikowanych znaków z łańcucha w miejscu. Doh

info = data[:min(len(data), 75)

Wyrażenie regularne nie jest potrzebne, ale chcesz użyć formatowania łańcucha zamiast konkatenacji łańcucha w zaakceptowanej odpowiedzi.

Jest to prawdopodobnie najbardziej kanoniczny, Pythoński sposób obcinania łańcucha datao długości 75 znaków.

>>> data = "saddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddsaddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddsadddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
>>> info = "{}..".format(data[:75]) if len(data) > 75 else data
>>> info
'111111111122222222223333333333444444444455555555556666666666777777777788888...'

Oto funkcja, którą utworzyłem w ramach nowej klasy String ... Pozwala na dodanie sufiksu (jeśli łańcuch ma rozmiar po przycięciu i jest wystarczająco długi - chociaż nie musisz wymuszać rozmiaru bezwzględnego)

Byłem w trakcie zmiany kilku rzeczy, więc są pewne bezużyteczne koszty logiczne (jeśli na przykład skracam ...), gdzie nie jest to już konieczne, a na górze jest zwrot ...

Ale nadal jest to dobra funkcja do obcinania danych ...

##
## Truncate characters of a string after _len'nth char, if necessary... If _len is less than 0, don't truncate anything... Note: If you attach a suffix, and you enable absolute max length then the suffix length is subtracted from max length... Note: If the suffix length is longer than the output then no suffix is used...
##
## Usage: Where _text = 'Testing', _width = 4
##      _data = String.Truncate( _text, _width )                        == Test
##      _data = String.Truncate( _text, _width, '..', True )            == Te..
##
## Equivalent Alternates: Where _text = 'Testing', _width = 4
##      _data = String.SubStr( _text, 0, _width )                       == Test
##      _data = _text[  : _width ]                                      == Test
##      _data = ( _text )[  : _width ]                                  == Test
##
def Truncate( _text, _max_len = -1, _suffix = False, _absolute_max_len = True ):
    ## Length of the string we are considering for truncation
    _len            = len( _text )

    ## Whether or not we have to truncate
    _truncate       = ( False, True )[ _len > _max_len ]

    ## Note: If we don't need to truncate, there's no point in proceeding...
    if ( not _truncate ):
        return _text

    ## The suffix in string form
    _suffix_str     = ( '',  str( _suffix ) )[ _truncate and _suffix != False ]

    ## The suffix length
    _len_suffix     = len( _suffix_str )

    ## Whether or not we add the suffix
    _add_suffix     = ( False, True )[ _truncate and _suffix != False and _max_len > _len_suffix ]

    ## Suffix Offset
    _suffix_offset = _max_len - _len_suffix
    _suffix_offset  = ( _max_len, _suffix_offset )[ _add_suffix and _absolute_max_len != False and _suffix_offset > 0 ]

    ## The truncate point.... If not necessary, then length of string.. If necessary then the max length with or without subtracting the suffix length... Note: It may be easier ( less logic cost ) to simply add the suffix to the calculated point, then truncate - if point is negative then the suffix will be destroyed anyway.
    ## If we don't need to truncate, then the length is the length of the string.. If we do need to truncate, then the length depends on whether we add the suffix and offset the length of the suffix or not...
    _len_truncate   = ( _len, _max_len )[ _truncate ]
    _len_truncate   = ( _len_truncate, _max_len )[ _len_truncate <= _max_len ]

    ## If we add the suffix, add it... Suffix won't be added if the suffix is the same length as the text being output...
    if ( _add_suffix ):
        _text = _text[ 0 : _suffix_offset ] + _suffix_str + _text[ _suffix_offset: ]

    ## Return the text after truncating...
    return _text[ : _len_truncate ]

info = data[:75] + ('..' if len(data) > 75 else '')