Python uzun bir dizeyi kısaltıyor

Bir dize Python'da 75 karaktere nasıl kesilir?

JavaScript'te şu şekilde yapılır:

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

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

Daha da kısa:

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

Daha da özlü:

data = data[:75]

75 karakterden azsa değişiklik olmaz.

Python 3.4+ kullanıyorsanız textwrap.shorten, standart kitaplıktan kullanabilirsiniz:

Belirtilen genişliğe sığması için verilen metni daraltın ve kesin.

Önce metindeki boşluk daraltılır (tüm boşluk yerine tek boşluk bırakılır). Sonuç genişliğe sığarsa döndürülür. Aksi takdirde, kalan kelimeler artı yer tutucunun genişliğe sığması için sonuna kadar yeterli kelime bırakılır:

>>> textwrap.shorten("Hello  world!", width=12)
'Hello world!'
>>> textwrap.shorten("Hello  world!", width=11)
'Hello [...]'
>>> textwrap.shorten("Hello world", width=10, placeholder="...")
'Hello...'

Django çözümü için (soruda belirtilmemiş olan):

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

Sorunu takdir etmek için Truncator'un kaynak koduna bakın: https://github.com/django/django/blob/master/django/utils/text.py#L66

Django ile kesme hakkında: Django HTML kesme

Bu tek astarı kullanabilirsiniz:

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

Normal ifade ile:

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

Uzun teller kesilir:

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

Kısa dizeler asla kesilmez:

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

Bu şekilde, bazı durumlarda daha güzel olan dizenin orta kısmını da "kesebilirsiniz":

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

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

Bu yöntem aşağıdaki durumlarda hiçbirini kullanmaz:

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

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

Yine başka bir çözüm. İle Trueve Falsesonunda test hakkında küçük bir geri bildirim alırsınız.

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

Bu sadece:

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

Dinamik olarak ayrılmış bir C dizesi gibi bir Python dizesini "kesemezsiniz". Python'daki dizeler değişmezdir. Yapabileceğiniz şey, diğer cevaplarda açıklandığı gibi bir dize dilimlemek ve yalnızca dilim ofsetleri ve adım tarafından tanımlanan karakterleri içeren yeni bir dize oluşturmaktır. Bazı (pratik olmayan) durumlarda, bu biraz can sıkıcı olabilir, örneğin görüşme dili olarak Python'u seçtiğinizde ve görüşmeci sizden bir dizeden yinelenen karakterleri kaldırmanızı ister. Hamuru.

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

Normal bir ifadeye gerek yoktur, ancak kabul edilen yanıtta dize birleştirmesi yerine dize biçimlendirmesi kullanmak istersiniz.

Bu muhtemelen dizeyi data75 karakterde kısaltmanın en kanonik, Pythonic yoludur .

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

İşte yeni bir String sınıfının parçası olarak yaptığım bir işlev ... Bir sonek eklemeye izin verir (eğer dize kırptıktan sonra boyutsa ve ekleyerek yeterince uzunsa da - mutlak boyutu zorlamanız gerekmez)

Etrafta birkaç şey değiştirme sürecindeydim, bu yüzden artık gerekli olmadığı ve üstte bir dönüş olduğu bazı işe yaramaz mantık maliyetleri var (örneğin, _truncate ... örneğin).

Ancak, verileri kesmek için hala iyi bir işlevdir ...

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