Python cắt một chuỗi dài

Làm thế nào để cắt một chuỗi thành 75 ký tự trong Python?

Đây là cách nó được thực hiện trong JavaScript:

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

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

Thậm chí ngắn hơn:

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

Thậm chí ngắn gọn hơn:

data = data[:75]

Nếu nó ít hơn 75 ký tự thì sẽ không có thay đổi.

Nếu bạn đang sử dụng Python 3.4+, bạn có thể sử dụng textwrap.shortentừ thư viện chuẩn:

Thu gọn và cắt bớt văn bản đã cho để phù hợp với chiều rộng nhất định.

Đầu tiên khoảng trắng trong văn bản được thu gọn (tất cả khoảng trắng được thay thế bằng khoảng trắng đơn). Nếu kết quả phù hợp với chiều rộng, nó được trả về. Mặt khác, đủ các từ được bỏ từ cuối để các từ còn lại cộng với giữ chỗ phù hợp với chiều rộng:

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

Đối với giải pháp Django (chưa được đề cập trong câu hỏi):

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

Hãy xem mã nguồn của Truncator để đánh giá vấn đề: https://github.com/django/django/blob/master/django/utils/text.py#L66

Liên quan đến việc cắt ngắn với Django: Cắt ngắn Django HTML

Bạn có thể sử dụng một lớp lót này:

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

Với regex:

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

Các chuỗi dài được cắt ngắn:

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

Chuỗi ngắn hơn không bao giờ bị cắt ngắn:

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

Bằng cách này, bạn cũng có thể "cắt" phần giữa của chuỗi, đẹp hơn trong một số trường hợp:

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

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

Phương pháp này không sử dụng bất kỳ nếu:

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

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

Một giải pháp khác. Với Truevà Falsebạn nhận được một chút thông tin phản hồi về bài kiểm tra cuối cùng.

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

Điều này chỉ trong:

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

Bạn thực sự không thể "cắt" một chuỗi Python như bạn có thể thực hiện một chuỗi C được phân bổ động. Chuỗi trong Python là bất biến. Những gì bạn có thể làm là cắt một chuỗi như được mô tả trong các câu trả lời khác, thu được một chuỗi mới chỉ chứa các ký tự được xác định bởi các lát cắt và bước. Trong một số trường hợp (không thực tế), điều này có thể hơi khó chịu, chẳng hạn như khi bạn chọn Python làm ngôn ngữ phỏng vấn và người phỏng vấn yêu cầu bạn xóa các ký tự trùng lặp khỏi một chuỗi tại chỗ. Doh.

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

Không cần biểu thức chính quy nhưng bạn muốn sử dụng định dạng chuỗi hơn là nối chuỗi trong câu trả lời được chấp nhận.

Đây có lẽ là cách Pythonic kinh điển nhất để cắt xâu chuỗi dataở 75 ký tự.

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

Đây là một hàm tôi đã tạo như một phần của lớp String mới ... Nó cho phép thêm hậu tố (nếu chuỗi có kích thước sau khi cắt và thêm nó đủ dài - mặc dù bạn không cần phải ép kích thước tuyệt đối)

Tôi đang trong quá trình thay đổi một vài thứ xung quanh nên có một số chi phí logic vô dụng (ví dụ: _truncate ... chẳng hạn) khi nó không còn cần thiết và có sự trở lại ở đầu ...

Nhưng, nó vẫn là một chức năng tốt để cắt bớt dữ liệu ...

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