Python truncar uma cadeia longa

Como alguém trunca uma string com 75 caracteres em Python?

É assim que é feito em JavaScript:

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

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

Ainda mais curto:

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

Ainda mais conciso:

data = data[:75]

Se tiver menos de 75 caracteres, não haverá alterações.

Se você estiver usando o Python 3.4+, poderá usar a textwrap.shortenpartir da biblioteca padrão:

Recolha e trunque o texto fornecido para caber na largura especificada.

Primeiro, o espaço em branco no texto é recolhido (todo o espaço em branco é substituído por espaços únicos). Se o resultado couber na largura, ele é retornado. Caso contrário, palavras suficientes serão descartadas do final para que as palavras restantes e o espaço reservado se ajustem à largura:

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

Para uma solução Django (que não foi mencionada na pergunta):

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

Dê uma olhada no código-fonte do Truncator para apreciar o problema: https://github.com/django/django/blob/master/django/utils/text.py#L66

Sobre o truncamento com o Django: Truncamento de HTML no Django

Você pode usar esta linha:

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

Com regex:

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

Seqüências longas são truncadas:

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

Strings mais curtas nunca são truncadas:

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

Dessa forma, você também pode "cortar" a parte do meio da string, o que é melhor em alguns casos:

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

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

Este método não usa nenhum se:

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

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

Mais uma solução. Com Truee Falsevocê recebe um pequeno feedback sobre o teste no final.

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

Isso apenas em:

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

Na verdade, você não pode "truncar" uma cadeia de caracteres Python como uma cadeia C alocada dinamicamente. Strings em Python são imutáveis. O que você pode fazer é cortar uma sequência como descrito em outras respostas, produzindo uma nova sequência contendo apenas os caracteres definidos pelas compensações e pela etapa da fatia. Em alguns casos (não práticos), isso pode ser um pouco chato, como quando você escolhe Python como sua linguagem de entrevista e o entrevistador pede para você remover caracteres duplicados de uma string no local. Doh.

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

Não há necessidade de uma expressão regular, mas você deseja usar a formatação de sequência em vez da concatenação de sequência na resposta aceita.

Esta é provavelmente a maneira Python mais canônica de truncar a string datacom 75 caracteres.

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

Aqui está uma função que eu fiz como parte de uma nova classe String ... Permite adicionar um sufixo (se a string for do tamanho após o corte e a adição for longa o suficiente - embora você não precise forçar o tamanho absoluto)

Eu estava no processo de mudar algumas coisas para que houvesse alguns custos lógicos inúteis (se _ truncados ... por exemplo), onde não é mais necessário e há um retorno no topo ...

Mas, ainda é uma boa função para truncar dados ...

##
## 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 '')