Tronquer une chaîne sans fin, au milieu d'un mot

Je suis à la recherche d'un moyen de tronquer une chaîne de caractères en Python qui n'aura pas couper la corde en son milieu d'un mot.

Par exemple:

Original: "C'est vraiment génial." 
"Muets" truncate: "C'est vrai..." 
"Smart" truncate: "C'est vraiment..."

Je suis à la recherche d'un moyen d'atteindre le "smart" tronquer à partir de ci-dessus.

InformationsquelleAutor Jack | 2008-10-30
  1. 60

    J'ai en fait écrit une solution pour cela sur un récent projet de la mine. J'ai compressé la majorité de celui-ci vers le bas pour être un peu plus petit.

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

    Ce qui se passe est le if vérifie si le contenu est déjà moins que le point de coupure. Si elle ne l'est pas, il tronque à la longueur désirée, divise l'espace, supprime le dernier élément (de sorte que vous ne pas couper un mot), et rejoint ensuite remis ensemble (tout en clouant sur la '...').

    • C'est vraiment concis... je l'avais ajouter un test pour éviter les cordes à vide dans le cas où il n'y a pas du tout des espaces dans la première des "caractères de longueur.
    • La troncature a eu à examiner le suffixe longueur : return ' '.join(content[:length+1-len(suffix)].split(' ')[0:-1]) + suffix
    • Il y a un coin de cas ici qui pourrait mordre quelqu'un: si content[:length+1] arrive à la fin dans un espace, la chaîne retournée sera plus long que length. Il en va de même pour content[:length+1-len(suffix) de @Stan commentaire.
    InformationsquelleAutor Adam
  2. 45

    Voici un peu plus de version de la dernière ligne Adam solution:

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

    (Ce qui est légèrement plus efficace, et renvoie un plus raisonnable résultat dans le cas où il n'existe aucun espace à l'avant de la chaîne.)

    • C'est intéressant au sujet de la rsplit. Je suppose que je n'ai jamais couru à travers elle.
    • Un test rapide de ces deux approches (Python 2.4.3): Adam code: >>> smart_truncate ("The quick brown fox a sauté par dessus le chien paresseux.', 26) "The quick brown fox a sauté..." Avec bobince de code: >>> smart_truncate ("The quick brown fox a sauté par dessus le chien paresseux.', 26) Le quick brown fox...
    • Ouais, j'ai ajouté dans la longueur+1 sur la troncature à gérer si la troncature divise exactement à la fin d'un mot, naturellement.
    • C'est mieux. Mais je l'avais mis sous le si et ignorer le reste, c'est plus pythonix.
    • Eh bien, alors, nous allons utiliser l'expression conditionnelle: def smart_truncate(contenu, longueur=100, suffix='...'): return (contenu si len(contenu) <= longueur d'autre contenu[:longueur].rsplit(' ', 1)[0]+suffixe)
    • Donc, nous allons être sûr, la chaîne résultante est pas plus longueur: return content if len(content) <= length else content[:length-len(suffix)].rsplit(' ', 1)[0] + suffix

    InformationsquelleAutor bobince
  3. 11

    Il y a quelques subtilités qui peuvent ou peuvent ne pas être les problèmes pour vous, comme la gestion des onglets (par exemple. si vous êtes en les présentant comme des 8 espaces, mais de les traiter comme 1 caractère interne), le traitement des différentes saveurs de la rupture et de non-rupture des espaces, ou de permettre à la rupture sur la coupure de mots, etc. Si tout cela est souhaitable, vous voudrez peut-être prendre un coup d'oeil au module d'habillage de texte. par exemple:

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

    Le comportement par défaut pour les mots de plus de max_size est pour les casser (prise de max_size une dure limite). Vous pouvez modifier la limite douce utilisée par les autres solutions ici en passant break_long_words=False pour wrap(), auquel cas il sera de retour le mot en entier. Si vous voulez que ce changement de comportement de la dernière ligne:

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

    Il ya quelques autres options comme expand_tabs qui peuvent être d'intérêt selon la nature exacte de comportement que vous voulez.

    InformationsquelleAutor Brian
  4. 7
    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'' + suffix, text)
    else:
        return text

    OU

    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'' + suffix, text)

    OU

    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
    • j'ai toujours l'amour de la regex de solutions basées sur 🙂
    • (au moins la partie supérieure de la solution) fonctionne même pour les chaînes de caractères sans les espaces (puis il coupe la frontière de mot), bien que dans ce cas, il n'est pas, ajoutez le suffixe 🙂
    InformationsquelleAutor Markus Jarderot
  5. 6
    >>> import textwrap
>>> textwrap.wrap('The quick brown fox jumps over the lazy dog', 12)
['The quick', 'brown fox', 'jumps over', 'the lazy dog']

    Vous suffit de prendre le premier élément de cette et vous avez terminé...

    • textwrap.shorten("Hello world", width=10, placeholder="...") serait de produire des "Hello..." docs.python.org/3.5/library/textwrap.html
    • J'ai juste essayé celui-ci et il s'est cassé en plein milieu d'un graphème cluster, de sorte qu'il n'est pas même en faisant le bon caractère de rupture, sans parler de l'analyse lexicale.
    InformationsquelleAutor Antonio
  6. 3
    def smart_truncate(s, width):
    if s[width].isspace():
        return s[0:width];
    else:
        return s[0:width].rsplit(None, 1)[0]

    De le tester:

    >>> smart_truncate('The quick brown fox jumped over the lazy dog.', 23) + "..."
'The quick brown fox...'
    • Remarque: Si la largeur > len(s), vous obtenez un hors limites sur les s[largeur]. Vous voulez probablement une vérification supplémentaire pour le cas où la troncature n'est pas nécessaire.
    InformationsquelleAutor Vebjorn Ljosa
  7. 1

    De Python 3.4+ vous pouvez utiliser d'habillage de texte.raccourcir. Avec l'OP exemple:

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

    d'habillage de texte.raccourcir(texte, la largeur, **kwargs)

    Effondrement et de tronquer le texte donné pour tenir dans la largeur.

    D'abord les espaces dans le texte est effondré (tous les espaces sont remplacés par des espaces simples). Si le résultat s'adapte à la largeur, il est
    retournés. Sinon, assez de mots sont supprimés à partir de la fin de sorte que le
    autres mots, plus l'espace réservé à l'ajustement à l'intérieur de la largeur:

    InformationsquelleAutor marcanuy