Python trunca una cadena larga

¿Cómo se trunca una cadena a 75 caracteres en Python?

Así es como se hace en JavaScript:

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

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

Aún más corto:

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

Aún más conciso:

data = data[:75]

Si tiene menos de 75 caracteres, no habrá cambios.

Si está utilizando Python 3.4+, puede usarlo textwrap.shortendesde la biblioteca estándar:

Contraer y truncar el texto dado para que quepa en el ancho dado.

Primero, el espacio en blanco en el texto se contrae (todo el espacio en blanco se reemplaza por espacios individuales). Si el resultado se ajusta al ancho, se devuelve. De lo contrario, se sueltan suficientes palabras desde el final para que las palabras restantes más el marcador de posición encajen dentro del ancho:

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

Para una solución Django (que no se ha mencionado en la pregunta):

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

Eche un vistazo al código fuente de Truncator para apreciar el problema: https://github.com/django/django/blob/master/django/utils/text.py#L66

Con respecto al truncamiento con Django: Django HTML truncation

Podrías usar este one-liner:

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

Con regex:

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

Las cadenas largas se truncan:

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

Las cadenas más cortas nunca se truncan:

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

De esta manera, también puede "cortar" la parte media de la cadena, que en algunos casos es más agradable:

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 no usa ninguno si:

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

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

Otra solución más. Con Truey Falseobtienes un pequeño comentario sobre la prueba al final.

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

Esto acaba de entrar:

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

En realidad, no puede "truncar" una cadena de Python como puede hacer una cadena C asignada dinámicamente. Las cadenas en Python son inmutables. Lo que puede hacer es cortar una cadena como se describe en otras respuestas, produciendo una nueva cadena que contiene solo los caracteres definidos por las compensaciones de corte y el paso. En algunos casos (no prácticos) esto puede ser un poco molesto, como cuando elige Python como idioma de la entrevista y el entrevistador le pide que elimine los caracteres duplicados de una cadena en el lugar. Doh

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

No hay necesidad de una expresión regular, pero sí desea utilizar el formato de cadena en lugar de la concatenación de cadena en la respuesta aceptada.

Esta es probablemente la forma más canónica y pitónica de truncar la cadena dataa 75 caracteres.

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

Aquí hay una función que hice como parte de una nueva clase de Cadena ... Permite agregar un sufijo (si la cadena es de tamaño después de recortar y agregar es lo suficientemente larga, aunque no es necesario forzar el tamaño absoluto)

Estaba en el proceso de cambiar algunas cosas, por lo que hay algunos costos lógicos inútiles (si _truncate ... por ejemplo) donde ya no es necesario y hay un retorno en la parte superior ...

Pero, sigue siendo una buena función para truncar datos ...

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