파이썬은 긴 문자열을 자릅니다

파이썬에서 문자열을 75 자로 자르는 방법은 무엇입니까?

이것이 JavaScript에서 수행되는 방법입니다.

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

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

더 짧은 :

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

더 간결한 :

data = data[:75]

75 자 미만이면 변경되지 않습니다.

Python 3.4+를 사용 textwrap.shorten하는 경우 표준 라이브러리에서 사용할 수 있습니다 .

주어진 너비에 맞게 주어진 텍스트를 축소하고 자릅니다.

먼저 텍스트의 공백이 축소됩니다 (모든 공백이 단일 공백으로 바)). 결과가 너비에 맞는 경우 반환됩니다. 그렇지 않으면 나머지 단어와 자리 표시자가 너비에 맞도록 끝에서 충분한 단어가 삭제됩니다.

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

Django 솔루션 (문제에 언급되지 않은) :

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

https://github.com/django/django/blob/master/django/utils/text.py#L66 : 문제를 이해하기 위해 Truncator의 소스 코드를 살펴보십시오.

Django를 사용한 잘림 관련 : Django HTML 잘림

이 하나의 라이너를 사용할 수 있습니다.

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

정규식으로 :

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

긴 문자열이 잘립니다.

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

더 짧은 문자열은 절대로 잘리지 않습니다.

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

이런 식으로 문자열의 중간 부분을 "잘라낼"수도 있습니다.

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

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

이 방법은 다음과 같은 경우를 사용하지 않습니다.

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

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

또 다른 해결책. 로 True와 False당신은 마지막 시험에 대한 약간의 피드백을 얻을.

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

이것은 단지 :

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

동적으로 할당 된 C 문자열을 수행 할 수있는 것처럼 실제로 파이썬 문자열을 "잘라낼 수"없습니다. 파이썬의 문자열은 변경할 수 없습니다. 당신이 할 수있는 일은 다른 답변에서 설명한대로 문자열을 슬라이스하여 슬라이스 오프셋과 단계로 정의 된 문자 만 포함하는 새 문자열을 생성하는 것입니다. 실용적이지 않은 일부 경우에는 인터뷰 언어로 Python을 선택하고 면접관이 문자열에서 중복 문자를 제자리에서 제거하도록 요청할 때와 같이 약간 성 가실 수 있습니다. 도

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

정규 표현식이 필요하지 않지만 허용되는 답변에 문자열 연결 대신 문자열 형식을 사용하고 싶습니다.

이것은 아마도 문자열 data을 75 자로 자르는 가장 정식적인 Pythonic 방법 일 것입니다 .

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

여기에 새로운 String 클래스의 일부로 만든 함수가 있습니다 ... 접미사를 추가 할 수 있습니다 (문자열이 자르고 크기가 길어지면 길이가 길다면 절대 크기를 강요 할 필요는 없지만)

나는 몇 가지 사항을 바꾸는 과정에 있었고 더 이상 필요하지 않고 쓸데없는 논리 비용 (예 : _truncate ... 등)이 있습니다.

그러나 여전히 데이터를 자르는 데 유용한 기능입니다 ...

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