Làm thế nào tôi có thể loại bỏ một dòng mới?

Python tương đương với chompchức năng của Perl , loại bỏ ký tự cuối cùng của chuỗi nếu nó là một dòng mới?

Hãy thử phương thức rstrip()(xem doc Python 2 và Python 3 )

>>> 'test string\n'.rstrip()
'test string'

rstrip()Phương thức của Python loại bỏ tất cả các loại khoảng trắng theo mặc định, không chỉ là một dòng mới như Perl làm với chomp.

>>> 'test string \n \r\n\n\r \n\n'.rstrip()
'test string'

Để loại bỏ chỉ các dòng mới:

>>> 'test string \n \r\n\n\r \n\n'.rstrip('\n')
'test string \n \r\n\n\r '

Ngoài ra còn có các phương thức lstrip()và strip():

>>> s = "   \n\r\n  \n  abc   def \n\r\n  \n  "
>>> s.strip()
'abc   def'
>>> s.lstrip()
'abc   def \n\r\n  \n  '
>>> s.rstrip()
'   \n\r\n  \n  abc   def'

Và tôi sẽ nói cách "pythonic" để có được các dòng mà không theo dõi các ký tự dòng mới là splitlines ().

>>> text = "line 1\nline 2\r\nline 3\nline 4"
>>> text.splitlines()
['line 1', 'line 2', 'line 3', 'line 4']

Cách chính tắc để loại bỏ các ký tự cuối dòng (EOL) là sử dụng phương thức chuỗi rstrip () loại bỏ mọi dấu vết \ r hoặc \ n. Dưới đây là ví dụ cho các ký tự Mac, Windows và Unix EOL.

>>> 'Mac EOL\r'.rstrip('\r\n')
'Mac EOL'
>>> 'Windows EOL\r\n'.rstrip('\r\n')
'Windows EOL'
>>> 'Unix EOL\n'.rstrip('\r\n')
'Unix EOL'

Sử dụng '\ r \ n' làm tham số cho rstrip có nghĩa là nó sẽ loại bỏ mọi kết hợp kéo dài của '\ r' hoặc '\ n'. Đó là lý do tại sao nó hoạt động trong cả ba trường hợp trên.

Sắc thái này quan trọng trong những trường hợp hiếm hoi. Ví dụ, tôi đã từng phải xử lý một tệp văn bản chứa thông điệp HL7. Tiêu chuẩn HL7 yêu cầu dấu '\ r' là ký tự EOL của nó. Máy Windows mà tôi đang sử dụng tin nhắn này đã thêm ký tự EOL '\ r \ n' của chính nó. Do đó, phần cuối của mỗi dòng trông giống như '\ r \ r \ n'. Sử dụng rstrip ('\ r \ n') sẽ loại bỏ toàn bộ '\ r \ r \ n' không phải là điều tôi muốn. Trong trường hợp đó, tôi chỉ đơn giản là cắt bỏ hai ký tự cuối cùng để thay thế.

Lưu ý rằng không giống như chompchức năng của Perl , điều này sẽ loại bỏ tất cả các ký tự được chỉ định ở cuối chuỗi, không chỉ một:

>>> "Hello\n\n\n".rstrip("\n")
"Hello"

Lưu ý rằng rstrip không hoạt động chính xác như chomp () của Perl vì nó không sửa đổi chuỗi. Đó là, trong Perl:

$x="a\n";

chomp $x

dẫn đến $xbị "a".

nhưng trong Python:

x="a\n"

x.rstrip()

sẽ có nghĩa rằng giá trị của xlà vẫn "a\n" . Thậm chí x=x.rstrip()không phải lúc nào cũng cho kết quả giống nhau, vì nó loại bỏ tất cả khoảng trắng từ cuối chuỗi, không chỉ một dòng mới nhất.

Tôi có thể sử dụng một cái gì đó như thế này:

import os
s = s.rstrip(os.linesep)

Tôi nghĩ vấn đề với rstrip("\n")là có lẽ bạn sẽ muốn đảm bảo rằng dấu phân cách dòng là di động. (một số hệ thống cổ xưa được đồn đại sẽ sử dụng "\r\n"). Gotcha khác là rstripsẽ loại bỏ khoảng trắng lặp đi lặp lại. Hy vọng os.linesepsẽ chứa các nhân vật đúng. các công việc trên cho tôi.

Bạn có thể sử dụng line = line.rstrip('\n'). Điều này sẽ loại bỏ tất cả các dòng mới từ cuối chuỗi, không chỉ một.

s = s.rstrip()

sẽ xóa tất cả các dòng mới ở cuối chuỗi s. Việc gán là cần thiết vì rstriptrả về một chuỗi mới thay vì sửa đổi chuỗi gốc.

Điều này sẽ sao chép chính xác chomp của perl (trừ hành vi trên mảng) cho đầu cuối dòng "\ n":

def chomp(x):
    if x.endswith("\r\n"): return x[:-2]
    if x.endswith("\n") or x.endswith("\r"): return x[:-1]
    return x

(Lưu ý: nó không sửa đổi chuỗi 'tại chỗ'; nó không xóa khoảng trắng theo dõi thêm; mất \ r \ n trong tài khoản)

"line 1\nline 2\r\n...".replace('\n', '').replace('\r', '')
>>> 'line 1line 2...'

hoặc bạn luôn có thể trở nên đam mê với regexps :)

chúc vui vẻ!

bạn có thể sử dụng dải:

line = line.strip()

bản giới thiệu:

>>> "\n\n hello world \n\n".strip()
'hello world'

rstrip không làm điều tương tự như chomp, trên nhiều cấp độ. Đọc http://perldoc.perl.org/fifts/chomp.html và thấy rằng chomp thực sự rất phức tạp.

Tuy nhiên, điểm chính của tôi là chomp loại bỏ tối đa 1 dòng kết thúc, trong khi rstrip sẽ loại bỏ càng nhiều càng tốt.

Tại đây bạn có thể thấy rstrip xóa tất cả các dòng mới:

>>> 'foo\n\n'.rstrip(os.linesep)
'foo'

Một xấp xỉ gần đúng hơn của việc sử dụng chomp Perl điển hình có thể được thực hiện với re.sub, như thế này:

>>> re.sub(os.linesep + r'\Z','','foo\n\n')
'foo\n'

Cẩn thận với "foo".rstrip(os.linesep): Điều đó sẽ chỉ kiểm tra các ký tự dòng mới cho nền tảng nơi Python của bạn đang được thực thi. Ví dụ, hãy tưởng tượng bạn đang tinh chỉnh các dòng của một tệp Windows trong Linux:

$ python
Python 2.7.1 (r271:86832, Mar 18 2011, 09:09:48) 
[GCC 4.5.0 20100604 [gcc-4_5-branch revision 160292]] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import os, sys
>>> sys.platform
'linux2'
>>> "foo\r\n".rstrip(os.linesep)
'foo\r'
>>>

Sử dụng "foo".rstrip("\r\n")thay thế, như Mike nói ở trên.

Một ví dụ trong tài liệu của Python chỉ đơn giản là sử dụng line.strip().

chompHàm của Perl sẽ loại bỏ một chuỗi ngắt dòng từ cuối chuỗi chỉ khi nó thực sự ở đó.

Đây là cách tôi dự định thực hiện điều đó trong Python, nếu processvề mặt khái niệm là chức năng mà tôi cần để làm điều gì đó hữu ích cho mỗi dòng từ tệp này:

import os
sep_pos = -len(os.linesep)
with open("file.txt") as f:
    for line in f:
        if line[sep_pos:] == os.linesep:
            line = line[:sep_pos]
        process(line)

Tôi không lập trình bằng Python, nhưng tôi đã bắt gặp Câu hỏi thường gặp tại python.org ủng hộ S.rstrip ("\ r \ n") cho python 2.2 trở lên.

import re

r_unwanted = re.compile("[\n\t\r]")
r_unwanted.sub("", your_text)

Tôi thấy thuận tiện khi có thể nhận được các dòng được chia nhỏ trong iterator, song song với cách bạn có thể nhận được các dòng không được phân tách từ một đối tượng tệp. Bạn có thể làm như vậy với mã sau:

def chomped_lines(it):
    return map(operator.methodcaller('rstrip', '\r\n'), it)

Sử dụng mẫu:

with open("file.txt") as infile:
    for line in chomped_lines(infile):
        process(line)

giải pháp khắc phục cho trường hợp đặc biệt:

nếu ký tự dòng mới là ký tự cuối cùng (như trường hợp của hầu hết các đầu vào tệp), thì đối với bất kỳ phần tử nào trong bộ sưu tập, bạn có thể lập chỉ mục như sau:

foobar= foobar[:-1]

để cắt ra nhân vật dòng mới của bạn.

Nếu câu hỏi của bạn là dọn sạch tất cả các ngắt dòng trong một đối tượng str nhiều dòng (oldstr), bạn có thể chia nó thành một danh sách theo dấu phân cách '\ n' và sau đó nối danh sách này vào một str mới (newstr).

newstr = "".join(oldstr.split('\n'))

Có vẻ như không có một sự tương tự hoàn hảo cho chomp của perl . Đặc biệt, rstrip không thể xử lý các dấu phân cách dòng mới nhiều ký tự như thế nào \r\n. Tuy nhiên, splitlines không được chỉ ra ở đây . Theo câu trả lời của tôi cho một câu hỏi khác, bạn có thể kết hợp nối và chia dòng để xóa / thay thế tất cả các dòng mới từ một chuỗi s:

''.join(s.splitlines())

* Gỡ bỏ sau đúng một dấu xuống dòng (như chomp sẽ, tôi tin). Chuyển qua Truelàm keependsđối số để phân chia giữ lại các dấu phân cách. Sau đó, splitlines được gọi một lần nữa để xóa các dấu phân cách trên "dòng" cuối cùng:

def chomp(s):
    if len(s):
        lines = s.splitlines(True)
        last = lines.pop()
        return ''.join(lines + last.splitlines())
    else:
        return ''

Tôi đang làm nổi lên câu trả lời thường xuyên của mình dựa trên câu trả lời mà tôi đã đăng trước đó trong phần bình luận của câu trả lời khác. Tôi nghĩ rằng sử dụng relà một giải pháp rõ ràng rõ ràng hơn cho vấn đề này hơn str.rstrip.

>>> import re

Nếu bạn muốn loại bỏ một hoặc nhiều trailing chars xuống dòng:

>>> re.sub(r'[\n\r]+$', '', '\nx\r\n')
'\nx'

Nếu bạn muốn xóa ký tự dòng mới ở mọi nơi (không chỉ theo dõi):

>>> re.sub(r'[\n\r]+', '', '\nx\r\n')
'x'

Nếu bạn muốn loại bỏ chỉ 1-2 ký tự ký tự dòng mới (ví dụ \r, \n, \r\n, \n\r, \r\r, \n\n)

>>> re.sub(r'[\n\r]{1,2}$', '', '\nx\r\n\r\n')
'\nx\r'
>>> re.sub(r'[\n\r]{1,2}$', '', '\nx\r\n\r')
'\nx\r'
>>> re.sub(r'[\n\r]{1,2}$', '', '\nx\r\n')
'\nx'

Tôi có cảm giác rằng hầu hết mọi người thực sự muốn ở đây, là loại bỏ chỉ một lần xuất hiện của một nhân vật dòng mới, hoặc \r\nhoặc \nkhông có gì nữa.

>>> re.sub(r'(?:\r\n|\n)$', '', '\nx\n\n', count=1)
'\nx\n'
>>> re.sub(r'(?:\r\n|\n)$', '', '\nx\r\n\r\n', count=1)
'\nx\r\n'
>>> re.sub(r'(?:\r\n|\n)$', '', '\nx\r\n', count=1)
'\nx'
>>> re.sub(r'(?:\r\n|\n)$', '', '\nx\n', count=1)
'\nx'

(Việc ?:tạo một nhóm không bắt giữ.)

(Bằng cách này là không gì '...'.rstrip('\n', '').rstrip('\r', '')không mà có thể không được rõ ràng cho người khác vấp ngã khi chủ đề này. str.rstripDải như nhiều nhân vật trailing càng tốt, do đó, một chuỗi như foo\n\n\nsẽ cho kết quả dương tính giả của footrong khi bạn có thể đã muốn giữ gìn các dòng mới khác sau khi tước một dấu duy nhất.)

>>> '   spacious   '.rstrip()
'   spacious'
>>> "AABAA".rstrip("A")
  'AAB'
>>> "ABBA".rstrip("AB") # both AB and BA are stripped
   ''
>>> "ABCABBA".rstrip("AB")
   'ABC'

Chỉ dùng :

line = line.rstrip("\n")

hoặc là

line = line.strip("\n")

Bạn không cần bất kỳ thứ phức tạp này

s = '''Hello  World \t\n\r\tHi There'''
# import the module string   
import string
# use the method translate to convert 
s.translate({ord(c): None for c in string.whitespace}
>>'HelloWorldHiThere'

Với regex

s = '''  Hello  World 
\t\n\r\tHi '''
print(re.sub(r"\s+", "", s), sep='')  # \s matches all white spaces
>HelloWorldHi

Thay thế \ n, \ t, \ r

s.replace('\n', '').replace('\t','').replace('\r','')
>'  Hello  World Hi '

Với regex

s = '''Hello  World \t\n\r\tHi There'''
regex = re.compile(r'[\n\r\t]')
regex.sub("", s)
>'Hello  World Hi There'

với tham gia

s = '''Hello  World \t\n\r\tHi There'''
' '.join(s.split())
>'Hello  World Hi There'

Có ba loại kết thúc dòng mà chúng ta thường gặp phải: \n, \rvà \r\n. Một biểu thức chính quy khá đơn giản trong re.sub, cụ thể là r"\r?\n?$", có thể bắt được tất cả.

(Và chúng ta phải bắt hết chúng , phải không?)

import re

re.sub(r"\r?\n?$", "", the_text, 1)

Với đối số cuối cùng, chúng tôi giới hạn số lần xuất hiện được thay thế thành một, bắt chước chomp ở một mức độ nào đó. Thí dụ:

import re

text_1 = "hellothere\n\n\n"
text_2 = "hellothere\n\n\r"
text_3 = "hellothere\n\n\r\n"

a = re.sub(r"\r?\n?$", "", text_1, 1)
b = re.sub(r"\r?\n?$", "", text_2, 1)
c = re.sub(r"\r?\n?$", "", text_3, 1)

... nơi a == b == clà True.

Nếu bạn lo lắng về tốc độ (giả sử bạn có một danh sách các chuỗi looong) và bạn biết bản chất của char dòng mới, việc cắt chuỗi thực sự nhanh hơn rstrip. Một thử nghiệm nhỏ để minh họa điều này:

import time

loops = 50000000

def method1(loops=loops):
    test_string = 'num\n'
    t0 = time.time()
    for num in xrange(loops):
        out_sting = test_string[:-1]
    t1 = time.time()
    print('Method 1: ' + str(t1 - t0))

def method2(loops=loops):
    test_string = 'num\n'
    t0 = time.time()
    for num in xrange(loops):
        out_sting = test_string.rstrip()
    t1 = time.time()
    print('Method 2: ' + str(t1 - t0))

method1()
method2()

Đầu ra:

Method 1: 3.92700004578
Method 2: 6.73000001907

Điều này sẽ hoạt động cho cả windows và linux (bit đắt với re sub nếu bạn đang tìm kiếm giải pháp re)

import re 
if re.search("(\\r|)\\n$", line):
    line = re.sub("(\\r|)\\n$", "", line)

Các dòng đầu tiên sau đó nối chúng với bất kỳ dấu phân cách nào bạn muốn:

x = ' '.join(x.splitlines())

nên làm việc như một lá bùa.

Bắt tất cả:

line = line.rstrip('\r|\n')