Python tronquer une chaîne longue

Comment tronquer une chaîne de 75 caractères en Python?

C'est la façon dont c'est fait en JavaScript:

var data="saddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddsaddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddsadddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
var info = (data.length > 75) ? data.substring[0,75] + '..' : data;
InformationsquelleAutor Hulk | 2010-05-20
  1. 337
    info = (data[:75] + '..') if len(data) > 75 else data
    • Je voudrais changer la condition peut-être de len(data) > 77 de compte pour le double de points (il est inutile d'une tronquer que le dernier caractère de la remplacer par un point).
    • Qui ne serait pas conforme à l'original du code, mais c'est une bonne suggestion que je l'ai souligné dans la première place.
    • Notez que le comprenaient les parenthèses ne sont bien sûr facultatif.
    • Vrai, mais ils sont très utiles pour ceux qui ne me souviens pas de toutes les règles de priorité à travers les 5 à 10 langues qu'ils utilisent au quotidien.
    • qu'est-ce que [:n] appelé pour que je puisse regarder dans la documentation?
    • une tranche
    • thx j'ai pensé à elle par juste déconner w

    InformationsquelleAutor Marcelo Cantos
  2. 107

    Encore plus courte :

    info = data[:75] + (data[75:] and '..')
    • Drôle de démarche à faire. Si c'est toujours un composite one-liner. ^^
    • n'est-ce pas la solution a 77 caractères si vous incluez le '..' ?
    • Oui, comme par le code d'origine.
    • Ce une façon détournée de ^^ Devraient être reconnus.
    InformationsquelleAutor stanlekub
  3. 81

    Encore plus concise:

    data = data[:75]

    Si elle est inférieure à 75 caractères il n'y aura pas de changement.

    • Sans doute il veut points de suspension ajoutée si la chaîne est tronquée.
    • Vous avez raison - je n'ai jamais remarqué cela. Je ne peux pas penser à une meilleure façon de le faire que d'autres réponses.
    InformationsquelleAutor neil
  4. 58

    Si vous utilisez Python 3.4+, vous pouvez utiliser d'habillage de texte.raccourcir de la bibliothèque standard:

    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, elle est renvoyée.
    Sinon, assez de mots sont supprimés à partir de la fin alors que le reste des
    mots, plus l'espace réservé à l'ajustement à l'intérieur de la largeur:

    >>> textwrap.shorten("Hello  world!", width=12)
'Hello world!'
>>> textwrap.shorten("Hello  world!", width=11)
'Hello [...]'
>>> textwrap.shorten("Hello world", width=10, placeholder="...")
'Hello...'
    • Il semble que la merde de son pantalon sur de très longues chaînes de caractères (sans espaces) et sorties uniquement les points de suspension.
    • les autres parties intéressées): c'est parce que shorten() tronque mots, et non pas de simples caractères. J'ai cherché, mais il ne semble pas y avoir moyen de configurer shorten() ou un TextWrapper instance de clip unique de caractères et non pas des paroles.
    • Et il a la fâcheuse conséquence de la suppression des sauts de ligne
    • Cela ne résout pas OP question. Il tronque par la parole et même supprime les espaces blancs.
    InformationsquelleAutor Bora M. Alper
  5. 26

    Pour Django solution (qui n'a pas été mentionné dans la question):

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

    Ont un coup d'oeil à Truncator du code source à apprécier le problème:
    https://github.com/django/django/blob/master/django/utils/text.py#L66

    Concernant la troncature avec Django:
    Django HTML troncature

    InformationsquelleAutor Risadinha
  6. 9

    Vous pouvez utiliser ce one-liner:

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

    Avec la regex:

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

    Longues chaînes de caractères sont tronqués:

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

    Des chaînes plus courtes jamais obtenir tronquée:

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

    De cette façon, vous pouvez "couper" la partie centrale de la chaîne, ce qui est plus joli dans certains cas:

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

>>> data="11111111112222222222333333333344444444445555555555666666666677777777778888888888"
>>> re.sub(r'^(.{5}).*(.{5})$', '\g<1>...\g<2>', data)
'11111...88888'
    • bien que n'a pas travaillé quand vous avez de la place dans votre chaîne
    • il fonctionne pour moi! 🙂 pastebin.com/28DR9xzL
    • Pourquoi voudriez-vous utiliser les regex pour un cas simple?
    InformationsquelleAutor Davide Guerri
  8. 3

    Cette méthode n'utilise pas du tout si:


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

    • Je l'ai écrit seulement pour montrer que c'est possible. C'est contre python la lisibilité de la philosophie. Cela n'a pas d'avantage de performance en comparant avec d'autres "si" base de méthodes. Je ne l'utilise jamais et je ne recommandons pas de l'utiliser aussi.
    InformationsquelleAutor Sassan
  9. 3
    limit = 75
info = data[:limit] + '..' * (len(data) > limit)
    • C'est la solution la plus élégante. En outre, je voudrais extraire les caractères de la limite (dans ce cas 75) dans une variable pour éviter les incohérences. limit = 75; info = data[:limit] + '..' * (len(data) > limit)
    • Je suis d'accord à propos de la variable!
    InformationsquelleAutor HelloGoodbye
  10. 2

    Encore une autre solution. Avec True et False vous obtenez un peu de retour sur le test à la fin.

    data = {True: data[:75] + '..', False: data}[len(data) > 75]
    InformationsquelleAutor The Veritable Bugeater
  11. 1
           >>> info = lambda data: len(data)>10 and data[:10]+'...' or data
       >>> info('sdfsdfsdfsdfsdfsdfsdfsdfsdfsdfsdf')
           'sdfsdfsdfs...'
       >>> info('sdfsdf')
           'sdfsdf'
       >>>
    • Veuillez expliquer votre réponse?
    • autre exemple de cette fonction def info2(données): if len(data)>10: données de retour[:10]+'...' else: return données lambda de l'enseignement de l'inconnu, de la conception dans un style fonctionnel ex = lambda x:x+1 def ex(x): return x+1
    InformationsquelleAutor Spouk
  12. 1

    Seulement:

    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...
    InformationsquelleAutor dansalmo
  13. 0

    Vous ne pouvez pas réellement "tronquer" une chaîne Python comme vous pouvez le faire un C alloués dynamiquement chaîne. Chaînes de caractères en Python sont immuables. Ce que vous pouvez faire est de couper une chaîne comme décrit dans les autres réponses, ce qui donne une nouvelle chaîne contenant uniquement les caractères définis par la tranche des décalages et l'étape.
    Dans certains (non-fonctionnel) des cas cela peut être un peu ennuyeux, par exemple lorsque vous choisissez Python de votre entrevue de la langue et l'intervieweur vous demande de supprimer les doublons de caractères d'une chaîne en place. Doh.

    InformationsquelleAutor Dave
  14. 0

    Voici une fonction que j'ai faite dans le cadre d'une nouvelle classe String... Il permet l'ajout d'un suffixe ( si la chaîne est de taille après le parage et en ajoutant qu'il est assez long, mais vous n'avez pas besoin de forcer la taille absolue )

    J'étais en train de changer un peu les choses autour, donc il y a quelques inutiles logique des coûts ( si _truncate ... par exemple ) où il n'est plus nécessaire et il est de retour au sommet...

    Mais, il est toujours une bonne fonction pour tronquer les données...

    ##
## 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 ]
    InformationsquelleAutor Acecool
  15. 0
    info = data[:75] + ('..' if len(data) > 75 else '')
    InformationsquelleAutor HelloGoodbye
  16. -1

    Il n'y a pas besoin d'une expression régulière, mais vous ne voulez pas utiliser la mise en forme de chaîne plutôt que la concaténation de chaîne dans la accepté de répondre.

    C'est probablement la plus canonique, Pythonic façon de tronquer la chaîne data à 75 caractères.

    >>> data = "saddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddsaddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddsadddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
>>> info = "{}..".format(data[:75]) if len(data) > 75 else data
>>> info
'111111111122222222223333333333444444444455555555556666666666777777777788888...'
    • Je l'ai trouvé drôle de voir comment votre saddddddd... chaîne se transforme en 111111...🙂 je sais que c'est un copier-coller de la faute de frappe bien, et je suis d'accord avec vous sur les expressions régulières.
    InformationsquelleAutor Adam Nelson