Python усекает длинную строку

Ответ 1

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

Ответ 2

Еще короче:

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

Ответ 3

Еще более кратким:

data = data[:75]

Если оно меньше 75 символов, изменений не будет.

Ответ 4

Если вы используете Python 3.4+, вы можете использовать textwrap.shorten из стандартной библиотеки:

Свернуть и усечь заданный текст в соответствии с заданной шириной.

Сначала пробелы в тексте сбрасываются (все пробелы заменяются одиночными пробелами). Если результат соответствует ширине, он возвращается. В противном случае с конца удаляются достаточное количество слов, чтобы оставшиеся слова плюс заполнитель в ширину:

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

Ответ 5

Для решения Django (которое не упоминалось в вопросе):

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

Взгляните на исходный код Truncator, чтобы оценить проблему: https://github.com/django/django/blob/master/django/utils/text.py#L66

Об усечении с Django: укорочение HTML Django

Ответ 6

Вы можете использовать этот однострочный слой:

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

Ответ 7

С regex:

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

Длинные строки усекаются:

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

Более короткие строки никогда не обрезаются:

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

Таким образом, вы также можете "срезать" среднюю часть строки, что в некоторых случаях лучше:

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

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

Ответ 8

Этот метод не использует, если:

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

Ответ 9

Еще одно решение. С True и False вы получите небольшую обратную связь о тесте в конце.

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

Ответ 10

Это только в:

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...

Ответ 11

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

Ответ 12

Вы не можете на самом деле "обрезать" строку Python, как вы можете сделать динамически выделенную строку C. Строки в Python неизменяемы. То, что вы можете сделать, - это отрезать строку, как описано в других ответах, с получением новой строки, содержащей только символы, определенные смещениями среза и шагом. В некоторых (не практических) случаях это может быть немного раздражающим, например, когда вы выбираете Python в качестве языка собеседования, а интервьюер просит вас удалить повторяющиеся символы из строки на месте. Doh.

Ответ 13

Нет необходимости в регулярном выражении, но вы хотите использовать форматирование строк, а не конкатенацию строк в принятом ответе.

Это, пожалуй, самый канонический, Pythonic способ обрезать строку data на 75 символов.

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

Ответ 14

Здесь функция, которую я сделал как часть нового класса String... Она позволяет добавить суффикс (если строка имеет размер после обрезки и добавление ее достаточно длинная, хотя вам не нужно форсировать абсолютный размер)

Я был в процессе изменения нескольких вещей вокруг, поэтому есть некоторые бесполезные логические затраты (если _truncate... например), где это больше не нужно, и есть возврат наверху...

Но, это по-прежнему хорошая функция для усечения данных...

##
## 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 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 ]

Ответ 15

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

Ответ 16

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