python - separar - Truncar una cadena sin terminar en el medio de una palabra

python separar string por caracter

Question

Estoy buscando una manera de truncar una cadena en Python que no corte la cadena en el medio de una palabra.

Por ejemplo:

Original: "This is really awesome." "Dumb" truncate: "This is real..." "Smart" truncate: "This is really..."

Estoy buscando una manera de lograr el truncado "inteligente" desde arriba.

Answer 1

Aquí hay una versión ligeramente mejor de la última línea en la solución de Adam:

return content[:length].rsplit('' '', 1)[0]+suffix

(Esto es un poco más eficiente, y arroja un resultado más razonable en el caso de que no haya espacios en la parte frontal de la cadena).

Answer 2

De hecho, escribí una solución para esto en un proyecto mío reciente. He comprimido la mayor parte para ser un poco más pequeño.

def smart_truncate(content, length=100, suffix=''...''):
if len(content) <= length:
return content
else:
return '' ''.join(content[:length+1].split('' '')[0:-1]) + suffix

Lo que ocurre es que la instrucción if comprueba si su contenido ya es inferior al punto de corte. Si no es así, se trunca en la longitud deseada, se divide en el espacio, elimina el último elemento (para que no se corte una palabra) y luego vuelve a unirse (mientras se marca el ''...'') .

Answer 3

Hay algunas sutilezas que pueden o no ser problemas para usted, como el manejo de pestañas (por ejemplo, si las muestra como 8 espacios, pero tratándolas como 1 carácter internamente), manejando varios sabores de ruptura y no- romper espacios en blanco, o permitir romper la separación silábica, etc. Si algo de esto es deseable, es posible que desee echar un vistazo al módulo de envoltura de texto. p.ej:

def truncate(text, max_size):
if len(text) <= max_size:
return text
return textwrap.wrap(text, max_size-3)[0] + "..."

El comportamiento predeterminado para palabras mayores que max_size es romperlas (haciendo que max_size sea un límite estricto). Puede cambiar al límite suave utilizado por algunas de las otras soluciones pasando aquí break_long_words = False to wrap (), en cuyo caso devolverá la palabra completa. Si desea este comportamiento, cambie la última línea a:

 lines = textwrap.wrap(text, max_size-3, break_long_words=False)
return lines[0] + ("..." if len(lines)>1 else "")

Hay algunas otras opciones como expand_tabs que pueden ser de interés dependiendo del comportamiento exacto que desee.

Answer 4

def smart_truncate1(text, max_length=100, suffix=''...''):
"""Returns a string of at most `max_length` characters, cutting
only at word-boundaries. If the string was truncated, `suffix`
will be appended.
"""
if len(text) > max_length:
pattern = r''^(.{0,%d}/S)/s.*'' % (max_length-len(suffix)-1)
return re.sub(pattern, r''/1'' + suffix, text)
else:
return text

O

def smart_truncate2(text, min_length=100, suffix=''...''):
"""If the `text` is more than `min_length` characters long,
it will be cut at the next word-boundary and `suffix`will
be appended.
"""
pattern = r''^(.{%d,}?/S)/s.*'' % (min_length-1)
return re.sub(pattern, r''/1'' + suffix, text)

O

def smart_truncate3(text, length=100, suffix=''...''):
"""Truncates `text`, on a word boundary, as close to
the target length it can come.
"""
slen = len(suffix)
pattern = r''^(.{0,%d}/S)/s+/S+'' % (length-slen-1)
if len(text) > length:
match = re.match(pattern, text)
if match:
length0 = match.end(0)
length1 = match.end(1)
if abs(length0+slen-length) < abs(length1+slen-length):
return match.group(0) + suffix
else:
return match.group(1) + suffix
return text

Answer 5

def smart_truncate(s, width):
if s[width].isspace():
return s[0:width];
else:
return s[0:width].rsplit(None, 1)[0]

Probándolo:

>>> smart_truncate(''The quick brown fox jumped over the lazy dog.'', 23) + "..."
''The quick brown fox...''

Answer 6

>>> import textwrap
>>> textwrap.wrap(''The quick brown fox jumps over the lazy dog'', 12)
[''The quick'', ''brown fox'', ''jumps over'', ''the lazy dog'']

Simplemente toma el primer elemento de eso y listo ...

Answer 7

Desde Python 3.4+ puedes usar textwrap.shorten . Con el ejemplo OP:

>>> import textwrap
>>> original = "This is really awesome."
>>> textwrap.shorten(original, width=20, placeholder="...")
''This is really...''

textwrap.shorten (texto, ancho, ** kwargs)

Contraiga y trunque el texto dado para que se ajuste al ancho dado.

En primer lugar, el espacio en blanco en el texto se contrae (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 quepan dentro del ancho: