Python tronque une longue chaîne

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

Voici comment cela se fait en JavaScript:

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

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

Encore plus court:

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

Encore plus concis:

data = data[:75]

S'il est inférieur à 75 caractères, il n'y aura aucun changement.

Si vous utilisez Python 3.4+, vous pouvez utiliser à textwrap.shortenpartir de la bibliothèque standard:

Réduisez et tronquez le texte donné pour qu'il tienne dans la largeur donnée.

Tout d'abord, les espaces dans le texte sont réduits (tous les espaces sont remplacés par des espaces simples). Si le résultat tient dans la largeur, il est renvoyé. Sinon, suffisamment de mots sont supprimés de la fin pour que les mots restants plus l'espace réservé tiennent dans 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...'

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

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

Jetez un œil au code source de Truncator pour apprécier le problème: https://github.com/django/django/blob/master/django/utils/text.py#L66

Concernant la troncature avec Django: la troncature HTML de Django

Vous pouvez utiliser ce one-liner:

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

Avec regex:

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

Les chaînes longues sont tronquées:

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

Les chaînes plus courtes ne sont jamais tronquées:

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

De cette façon, vous pouvez également "couper" la partie médiane de la chaîne, ce qui est plus agréable 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'

Cette méthode n'en utilise pas si:

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

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

Encore une autre solution. Avec Trueet Falsevous obtenez un petit retour sur le test à la fin.

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

Ceci juste en:

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

Vous ne pouvez pas réellement "tronquer" une chaîne Python comme vous pouvez faire une chaîne C allouée dynamiquement. Les chaînes en Python sont immuables. Ce que vous pouvez faire est de découper une chaîne comme décrit dans les autres réponses, produisant une nouvelle chaîne contenant uniquement les caractères définis par les décalages et l'étape de découpage. Dans certains cas (non pratiques), cela peut être un peu ennuyeux, comme lorsque vous choisissez Python comme langue d'interview et que l'intervieweur vous demande de supprimer les caractères en double d'une chaîne en place. Doh.

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

Il n'y a pas besoin d'une expression régulière mais vous souhaitez utiliser le formatage de chaîne plutôt que la concaténation de chaîne dans la réponse acceptée.

C'est probablement la manière la plus canonique et Pythonique de tronquer la chaîne dataà 75 caractères.

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

Voici une fonction que j'ai créée dans le cadre d'une nouvelle classe String ... Elle permet d'ajouter un suffixe (si la chaîne est de taille après l'ajustement et l'ajout est assez long - bien que vous n'ayez pas besoin de forcer la taille absolue)

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

Mais, c'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 ]

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