Python truncar 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; 

Related of "Python truncar una cadena larga"

 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 es menos de 75 caracteres no habrá cambio.

Si está utilizando Python 3.4+, puede usar textwrap.shorten desde la biblioteca estándar:

Contrae y trunca el texto dado para que se ajuste al ancho dado.

Primero se contrae el espacio en blanco en el texto (todos los espacios en blanco se reemplazan por espacios individuales). Si el resultado se ajusta al ancho, se devuelve. De lo contrario, se eliminan suficientes palabras del final para que las palabras restantes más el marcador de posición se ajusten al 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

Respecto al truncamiento con Django: Truncamiento de HTML Django

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 cuerdas largas están truncadas:

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

Las cuerdas 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 central 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 True y False , obtienes un poco de retroalimentación sobre la prueba al final.

 data = {True: data[:75] + '..', False: data}[len(data) > 75] 
  >>> info = lambda data: len(data)>10 and data[:10]+'...' or data >>> info('sdfsdfsdfsdfsdfsdfsdfsdfsdfsdfsdf') 'sdfsdfsdfs...' >>> info('sdfsdf') 'sdfsdf' >>> 

Esto acaba de llegar:

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

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

Aquí hay una función que hice como parte de una nueva clase de cadena … Permite agregar un sufijo (si la cadena es tamaño después de recortarla y agregarla 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 de lógica 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 '') 

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 pythonica de truncar los data cadena en 75 caracteres.

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