Mô-đun này cung cấp các lớp và chức năng để so sánh trình tự. Ví dụ, nó có thể được sử dụng để so sánh các tệp và có thể tạo thông tin về sự khác biệt của tệp ở các định dạng khác nhau, bao gồm HTML và ngữ cảnh và các khác biệt thống nhất. Để so sánh các thư mục và tệp, hãy xem thêm mô-đun
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu3lớp diflib. trình so khớp trình tự
Đây là lớp linh hoạt để so sánh các cặp trình tự thuộc bất kỳ loại nào, miễn là các phần tử trình tự có thể băm . Thuật toán cơ bản có trước, và hơi lạ mắt hơn một chút so với thuật toán được Ratcliff và Obershelp xuất bản vào cuối những năm 1980 dưới cái tên hyperbolic “khớp mẫu cử chỉ”. ” Ý tưởng là tìm dãy con khớp liền kề dài nhất không chứa phần tử “rác”; . [Xử lý rác là một phần mở rộng của thuật toán Ratcliff và Obershelp. ] Ý tưởng tương tự sau đó được áp dụng đệ quy cho các phần của chuỗi bên trái và bên phải của chuỗi con phù hợp. Điều này không mang lại trình tự chỉnh sửa tối thiểu, nhưng có xu hướng mang lại kết quả phù hợp “có vẻ phù hợp” với mọi người.
thời gian. Thuật toán Ratcliff-Obershelp cơ bản là thời gian bậc ba trong trường hợp xấu nhất và thời gian bậc hai trong trường hợp dự kiến.
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu4 là thời gian bậc hai đối với trường hợp xấu nhất và có hành vi trong trường hợp dự kiến phụ thuộc một cách phức tạp vào số lượng phần tử chung của các chuỗi;
Heuristic rác tự động.
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu4 hỗ trợ một heuristic tự động coi các mục trình tự nhất định là rác. Heuristic đếm số lần mỗi mục riêng lẻ xuất hiện trong chuỗi. Nếu các mục trùng lặp của một mục [sau mục đầu tiên] chiếm hơn 1% trình tự và chuỗi dài ít nhất 200 mục, thì mục này được đánh dấu là "phổ biến" và được coi là rác cho mục đích khớp trình tự. Có thể tắt phương pháp phỏng đoán này bằng cách đặt đối số
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu6 thành
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu7 khi tạo
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu4
Mới trong phiên bản 3. 2. Tham số autojunk.
lớp diflib. Khác¶Đây là một lớp để so sánh trình tự của các dòng văn bản và tạo ra sự khác biệt hoặc vùng đồng bằng mà con người có thể đọc được. Differ sử dụng cả
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu4 để so sánh trình tự các dòng và để so sánh trình tự các ký tự trong các dòng tương tự [gần giống nhau]
Mỗi dòng của đồng bằng
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu0 bắt đầu bằng mã gồm hai chữ cái
Mã số
Nghĩa
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu1
dòng duy nhất cho chuỗi 1
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu2
dòng duy nhất cho chuỗi 2
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu3
đường chung cho cả hai dãy
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu4
dòng không có trong một trong hai chuỗi đầu vào
Các dòng bắt đầu bằng '
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu5' cố gắng hướng mắt đến sự khác biệt bên trong dòng và không xuất hiện trong cả hai chuỗi đầu vào. Các dòng này có thể gây nhầm lẫn nếu các chuỗi chứa các ký tự tablớp diflib. HtmlDiff¶
Lớp này có thể được sử dụng để tạo một bảng HTML [hoặc một tệp HTML hoàn chỉnh chứa bảng] hiển thị so sánh cạnh nhau, từng dòng của văn bản với các điểm nổi bật thay đổi giữa các dòng và trong dòng. Bảng có thể được tạo ở chế độ khác biệt đầy đủ hoặc theo ngữ cảnh
Hàm tạo của lớp này là
__init__[kích thước tab=8 , cột bọc=Không có , rác dòng=Không có , charjunk=IS_CHARACTER_JUNK]¶Khởi tạo phiên bản của
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu6
tabsize là một đối số từ khóa tùy chọn để chỉ định khoảng cách dừng tab và mặc định là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu7
cột quấn là một từ khóa tùy chọn để chỉ định số cột nơi các dòng bị ngắt và được ngắt dòng, mặc định là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu8 nơi các dòng không được ngắt dòng
linejunk và charjunk là các đối số từ khóa tùy chọn được chuyển vào
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu9 [được sử dụng bởi
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu6 để tạo ra sự khác biệt HTML song song]. Xem tài liệu
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu9 để biết các giá trị và mô tả mặc định của đối số
Các phương pháp sau đây là công khai
make_file[fromlines , tolines , fromdesc='' , todesc='' , bối cảnh=Sai , numlines=5 , * , bộ ký tự='utf-8']¶So sánh fromlines và tolines [danh sách các chuỗi] và trả về một chuỗi là tệp HTML hoàn chỉnh chứa bảng hiển thị sự khác biệt giữa các dòng với các thay đổi giữa các dòng và trong dòng được tô sáng
fromdesc và todesc là các đối số từ khóa tùy chọn để chỉ định chuỗi tiêu đề cột từ/đến tệp [cả hai đều mặc định là chuỗi trống]
bối cảnh và numlines đều là đối số từ khóa tùy chọn. Đặt ngữ cảnh thành
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu92 khi sự khác biệt về ngữ cảnh được hiển thị, nếu không, hãy đặt mặc định là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu7 để hiển thị toàn bộ tệp. numlines mặc định là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu94. Khi ngữ cảnh là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu92 numlines kiểm soát số lượng dòng ngữ cảnh bao quanh các điểm nổi bật khác biệt. Khi ngữ cảnh là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu7, các dòng số kiểm soát số lượng dòng được hiển thị trước phần tô sáng khác biệt khi sử dụng siêu liên kết “tiếp theo” [đặt thành 0 sẽ khiến các siêu liên kết “tiếp theo” đặt phần tô sáng khác biệt tiếp theo ở đầu trình duyệt mà không có bất kỳ phần đầu nào
Ghi chú
fromdesc và todesc được hiểu là HTML chưa thoát và phải được thoát đúng cách khi nhận đầu vào từ các nguồn không đáng tin cậy
Đã thay đổi trong phiên bản 3. 5. đối số chỉ từ khóa bộ ký tự đã được thêm vào. Bộ ký tự mặc định của tài liệu HTML đã thay đổi từ
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu97 thành
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu98. make_table[fromlines , tolines , fromdesc='' , todesc='' , bối cảnh=Sai , numlines=5]¶
So sánh fromlines và tolines [danh sách các chuỗi] và trả về một chuỗi là một bảng HTML hoàn chỉnh hiển thị sự khác biệt giữa các dòng với các thay đổi giữa các dòng và trong dòng được tô sáng
Các đối số của phương thức này giống như đối số của phương thức
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu99
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu70 là giao diện người dùng dòng lệnh cho lớp này và chứa một ví dụ điển hình về việc sử dụng nódiflib. context_diff[a , b , từ tệp='' , tofile='' , ngày nộp hồ sơ='' , tofiledate='' , n=3 , lineterm='\n']¶
So sánh a và b [danh sách các chuỗi]; . generator generating the delta lines] in context diff format.
Sự khác biệt ngữ cảnh là một cách nhỏ gọn để chỉ hiển thị các dòng đã thay đổi cộng với một vài dòng ngữ cảnh. Các thay đổi được hiển thị theo kiểu trước/sau. Số lượng dòng ngữ cảnh được đặt theo n, mặc định là ba
Theo mặc định, các dòng điều khiển khác [những dòng có
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu71 hoặc
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu72] được tạo bằng một dòng mới ở cuối. Điều này hữu ích để các đầu vào được tạo từ ________ 273 dẫn đến các khác biệt phù hợp để sử dụng với ________ 274 vì cả đầu vào và đầu ra đều có các dòng mới ở cuối
Đối với các đầu vào không có dòng mới ở cuối, hãy đặt đối số thuật ngữ dòng thành
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu75 để đầu ra sẽ không có dòng mới thống nhất
Định dạng khác biệt ngữ cảnh thường có tiêu đề cho tên tệp và thời gian sửa đổi. Bất kỳ hoặc tất cả những thứ này có thể được chỉ định bằng cách sử dụng các chuỗi cho fromfile, tofile, fromfiledate và tofiledate. Thời gian sửa đổi thường được thể hiện ở định dạng ISO 8601. Nếu không được chỉ định, các chuỗi mặc định để trống
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu3
Xem Giao diện dòng lệnh cho difflib để biết ví dụ chi tiết hơn.
diflib. get_close_matches[từ , khả năng , n=3 , cắt=0. 6]¶Trả về danh sách các trận đấu "đủ tốt" tốt nhất. từ là một chuỗi mà các kết quả khớp gần được mong muốn [thường là một chuỗi] và các khả năng là một danh sách các chuỗi để so khớp từ [thường là một danh sách các chuỗi]
Đối số tùy chọn n [mặc định là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu76] là số lần khớp gần tối đa để trả về;
Ngắt đối số tùy chọn [mặc định là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu78] là một số float trong phạm vi [0, 1]. Các khả năng không đạt điểm tối thiểu tương tự như từ sẽ bị bỏ qua
Các kết quả phù hợp nhất [không quá n] trong số các khả năng được trả về trong một danh sách, được sắp xếp theo điểm tương đồng, tương tự nhất trước
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu7diflib. ndiff[a , b , rác dòng=Không có , charjunk=IS_CHARACTER_JUNK]¶
So sánh a và b [danh sách các chuỗi]; . generator generating the delta lines].
Các tham số từ khóa tùy chọn linejunk và charjunk là các hàm lọc [hoặc
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu8]
rác rưởi. Một hàm chấp nhận một đối số chuỗi đơn và trả về true nếu chuỗi là rác hoặc sai nếu không. Mặc định là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu8. Ngoài ra còn có một hàm cấp mô-đun
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu12, lọc ra các dòng không có ký tự hiển thị, ngoại trừ nhiều nhất một ký tự pound [
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu13] – tuy nhiên, lớp
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu4 bên dưới thực hiện phân tích động về các dòng nào thường xuyên tạo thành nhiễu và
đồ bỏ đi. Một hàm chấp nhận một ký tự [chuỗi có độ dài 1] và trả về nếu ký tự đó là rác hoặc sai nếu không. Giá trị mặc định là hàm cấp mô-đun
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu15, lọc ra các ký tự khoảng trắng [trống hoặc tab; không nên đưa dòng mới vào. ]
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu16 là giao diện người dùng dòng lệnh cho chức năng này
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emudiflib. khôi phục[trình tự , mà]¶
Trả về một trong hai chuỗi đã tạo ra một đồng bằng
Đưa ra một chuỗi được tạo bởi
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu17 hoặc
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu9, trích xuất các dòng bắt nguồn từ tệp 1 hoặc 2 [tham số trong đó], loại bỏ các tiền tố của dòng
Ví dụ
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emudiflib. unified_diff[a , b , từ tệp='' , tofile='' , ngày nộp hồ sơ='' , tofiledate='' , n=3 , lineterm='\n']¶
So sánh a và b [danh sách các chuỗi]; . generator generating the delta lines] in unified diff format.
Khác biệt thống nhất là một cách nhỏ gọn để chỉ hiển thị các dòng đã thay đổi cộng với một vài dòng ngữ cảnh. Các thay đổi được hiển thị theo kiểu nội tuyến [thay vì các khối trước/sau riêng biệt]. Số lượng dòng ngữ cảnh được đặt theo n, mặc định là ba
Theo mặc định, các dòng điều khiển khác biệt [những dòng có
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu72,
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu10 hoặc
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu11] được tạo bằng một dòng mới ở cuối. Điều này hữu ích để các đầu vào được tạo từ ________ 273 dẫn đến các khác biệt phù hợp để sử dụng với ________ 274 vì cả đầu vào và đầu ra đều có các dòng mới ở cuối
Đối với các đầu vào không có dòng mới ở cuối, hãy đặt đối số thuật ngữ dòng thành
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu75 để đầu ra sẽ không có dòng mới thống nhất
Định dạng khác biệt ngữ cảnh thường có tiêu đề cho tên tệp và thời gian sửa đổi. Bất kỳ hoặc tất cả những thứ này có thể được chỉ định bằng cách sử dụng các chuỗi cho fromfile, tofile, fromfiledate và tofiledate. Thời gian sửa đổi thường được thể hiện ở định dạng ISO 8601. Nếu không được chỉ định, các chuỗi mặc định để trống
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu9
Xem Giao diện dòng lệnh cho difflib để biết ví dụ chi tiết hơn.
diflib. diff_byte[dfunc , a , b , fromfile=b'' , tofile=b'' , ngày nộp hồ sơ=b'' , tofiledate=b'' , n=3 , lineterm=b'\n']¶So sánh a và b [danh sách các đối tượng byte] bằng dfunc; . dfunc phải có thể gọi được, thường là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu15 hoặc
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu16
Cho phép bạn so sánh dữ liệu với mã hóa không xác định hoặc không nhất quán. Tất cả các đầu vào ngoại trừ n phải là đối tượng byte, không phải str. Hoạt động bằng cách chuyển đổi dễ dàng tất cả các đầu vào [ngoại trừ n] thành str và gọi
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu17. Đầu ra của dfunc sau đó được chuyển đổi trở lại thành byte, do đó, các dòng delta mà bạn nhận được có cùng mã hóa không xác định/không nhất quán như a và b
Mới trong phiên bản 3. 5
diflib. IS_LINE_JUNK[dòng]¶Trả lại
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu92 cho các dòng không thể hiểu được. Dòng có thể bỏ qua nếu dòng trống hoặc chứa một
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu13 duy nhất, nếu không thì không thể bỏ qua. Được sử dụng làm mặc định cho tham số linejunk trong
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu9 ở các phiên bản cũ hơndiflib. IS_CHARACTER_JUNK[ch]¶
Trả lại
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu92 cho các ký tự không thể hiểu được. Ký tự ch có thể bỏ qua nếu ch là dấu cách hoặc tab, nếu không thì không thể bỏ qua. Được sử dụng làm mặc định cho tham số charjunk trong
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu9
Xem thêm
Khớp mẫu. Phương pháp tiếp cận GestaltThảo luận về một thuật toán tương tự của John W. Ratcliff và D. e. metzener. Điều này đã được xuất bản trong Tiến sĩ. Tạp chí của Dobb vào tháng 7 năm 1988
Đối tượng SequenceMatcher¶
Lớp
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu4 có hàm tạo nàylớp difflib. SequenceMatcher[isjunk=Không có, a='', b='', autojunk=True]¶
Đối số tùy chọn isjunk phải là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu8 [mặc định] hoặc hàm một đối số lấy phần tử chuỗi và trả về true khi và chỉ khi phần tử đó là "rác" và nên được bỏ qua. Vượt qua
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu8 cho isjunk tương đương với việc vượt qua
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu86; . Ví dụ, vượt qua
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu7
nếu bạn đang so sánh các dòng dưới dạng chuỗi ký tự và không muốn đồng bộ hóa trên các tab trống hoặc cứng
Các đối số tùy chọn a và b là các chuỗi được so sánh; . Các phần tử của cả hai chuỗi phải có thể băm được .
Đối số tùy chọn autojunk có thể được sử dụng để vô hiệu hóa heuristic rác tự động
Mới trong phiên bản 3. 2. Tham số autojunk.
Các đối tượng SequenceMatcher nhận ba thuộc tính dữ liệu. bjunk là tập hợp các phần tử của b mà isjunk là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu92; . Cả ba đều được đặt lại bất cứ khi nào b được đặt lại với
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu88 hoặc
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu89
Mới trong phiên bản 3. 2. Các thuộc tính bjunk và bphổ biến.
Đối tượng
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu4 có các phương thức sauset_seqs[a , b]¶
Đặt hai trình tự được so sánh
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu4 tính toán và lưu trữ thông tin chi tiết về chuỗi thứ hai, vì vậy nếu bạn muốn so sánh một chuỗi với nhiều chuỗi, hãy sử dụng
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu89 để đặt chuỗi thường được sử dụng một lần và gọi
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu63 lặp lại, một lần cho mỗi chuỗi khácset_seq1[a] ¶
Đặt trình tự đầu tiên được so sánh. Chuỗi thứ hai được so sánh không bị thay đổi
set_seq2[b] ¶Đặt trình tự thứ hai được so sánh. Chuỗi đầu tiên được so sánh không bị thay đổi
find_longest_match[alo=0, ahi=None, blo=0, bhi=None]¶Tìm khối khớp dài nhất trong
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu64 và
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu65
Nếu isjunk bị bỏ qua hoặc
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu8, thì
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu67 trả về
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu68 sao cho
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu69 bằng với
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu700, trong đó
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu701 và
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu702. Đối với tất cả các
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu703 đáp ứng các điều kiện đó, các điều kiện bổ sung
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu704,
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu705 và nếu
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu706,
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu707 cũng được đáp ứng. Nói cách khác, trong số tất cả các khối khớp tối đa, hãy trả về khối bắt đầu sớm nhất trong a và trong số tất cả các khối khớp tối đa bắt đầu sớm nhất trong a, hãy trả về khối bắt đầu sớm nhất trong b
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu1
Nếu isjunk được cung cấp, đầu tiên, khối phù hợp dài nhất được xác định như trên, nhưng với hạn chế bổ sung là không có phần tử rác nào xuất hiện trong khối. Sau đó, khối đó được mở rộng hết mức có thể bằng cách khớp [chỉ] các phần tử rác ở cả hai bên. Vì vậy, khối kết quả không bao giờ khớp với rác trừ khi rác giống hệt nhau xảy ra liền kề với một trận đấu thú vị
Đây là ví dụ tương tự như trước, nhưng coi khoảng trống là rác. Điều đó ngăn
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu708 khớp trực tiếp với
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu708 ở phần cuối của chuỗi thứ hai. Thay vào đó, chỉ có ________ 3710 có thể khớp và khớp với ________ 3710 ngoài cùng bên trái trong chuỗi thứ hai
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu1
Nếu không có khối nào khớp, điều này sẽ trả về
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu712
Phương thức này trả về một bộ có tên
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu713.
Đã thay đổi trong phiên bản 3. 9. Đã thêm đối số mặc định.
get_matching_blocks[] ¶Trả về danh sách các bộ ba mô tả các chuỗi con phù hợp không chồng chéo. Mỗi bộ ba có dạng
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu714 và có nghĩa là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu715. Bộ ba đang tăng đơn điệu trong i và j
Bộ ba cuối cùng là một hình nộm và có giá trị
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu716. Nó là bộ ba duy nhất với
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu717. Nếu
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu714 và
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu719 là bộ ba liền kề trong danh sách và bộ thứ hai không phải là bộ ba cuối cùng trong danh sách, thì
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu720 hoặc
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu721;
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu8get_opcodes[] ¶
Trả về danh sách gồm 5 bộ mô tả cách biến a thành b. Mỗi bộ có dạng
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu722. Bộ đầu tiên có
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu723 và các bộ còn lại có i1 bằng i2 từ bộ trước đó và tương tự như vậy, j1 bằng j2 trước đó
Các giá trị thẻ là các chuỗi, với những ý nghĩa này
Giá trị
Nghĩa
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu724
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu725 nên được thay thế bằng
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu726
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu727
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu725 nên bị xóa. Lưu ý rằng
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu729 trong trường hợp này
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu730
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu726 nên được chèn vào tại
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu732. Lưu ý rằng
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu733 trong trường hợp này
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu734
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu735 [dãy con bằng nhau]
Ví dụ
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu6get_grouped_opcodes[n=3]¶
Trả về trình tạo nhóm có tối đa n dòng ngữ cảnh.
Bắt đầu với các nhóm được trả về bởi
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu736, phương pháp này chia ra các cụm thay đổi nhỏ hơn và loại bỏ các phạm vi xen kẽ không có thay đổi
Các nhóm được trả về ở cùng định dạng như
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu736tỷ lệ[] ¶
Trả về thước đo độ tương tự của các chuỗi dưới dạng float trong phạm vi [0, 1]
Trong đó T là tổng số phần tử trong cả hai dãy và M là số trận đấu, đây là 2. 0*M/T. Lưu ý rằng đây là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu738 nếu các chuỗi giống hệt nhau và
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu739 nếu chúng không có điểm chung
Điều này rất tốn kém để tính toán nếu
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu740 hoặc
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu736 chưa được gọi, trong trường hợp đó, bạn có thể muốn thử
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu742 hoặc
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu743 trước để có giới hạn trên
Ghi chú
thận trọng. Kết quả của một cuộc gọi
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu744 có thể phụ thuộc vào thứ tự của các đối số. Ví dụ
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu70quick_ratio[] ¶
Trả về giới hạn trên của
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu744 tương đối nhanhreal_quick_ratio[] ¶
Trả về giới hạn trên của
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu744 rất nhanh
Ba phương thức trả về tỷ lệ khớp với tổng số ký tự có thể cho các kết quả khác nhau do mức độ gần đúng khác nhau, mặc dù
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu742 và
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu743 luôn lớn ít nhất bằng
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu744
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu71
Các ví dụ về SequenceMatcher¶
Ví dụ này so sánh hai chuỗi, coi các khoảng trống là "rác"
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu72
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu744 trả về một số float trong [0, 1], đo độ giống nhau của các chuỗi. Theo nguyên tắc thông thường, giá trị
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu744 trên 0. 6 có nghĩa là các trình tự là kết hợp chặt chẽ
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu73
Nếu bạn chỉ quan tâm đến vị trí các chuỗi khớp với nhau, thì
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu740 rất hữu ích
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu74
Lưu ý rằng bộ dữ liệu cuối cùng được trả về bởi
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu740 luôn là một giá trị giả,
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu716 và đây là trường hợp duy nhất trong đó phần tử bộ dữ liệu cuối cùng [số phần tử khớp] là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu77
Nếu bạn muốn biết cách thay đổi chuỗi thứ nhất thành chuỗi thứ hai, hãy sử dụng
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu736
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu75
Xem thêm
Hàm
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu
757 trong mô-đun này cho biết cách xây dựng mã đơn giản trên>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu
4 có thể được sử dụng để thực hiện công việc hữu íchCông thức kiểm soát phiên bản đơn giản cho một ứng dụng nhỏ được xây dựng bằng
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu
4
Đối tượng khác nhau¶
Lưu ý rằng các vùng đồng bằng do
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu0 tạo không có yêu cầu bồi thường là khác biệt tối thiểu. Ngược lại, sự khác biệt tối thiểu thường phản trực giác, bởi vì chúng đồng bộ hóa bất cứ nơi nào có thể, đôi khi trùng khớp ngẫu nhiên cách nhau 100 trang. Việc hạn chế các điểm đồng bộ đối với các trận đấu liền kề sẽ bảo tồn một số khái niệm về địa phương, với chi phí không thường xuyên là tạo ra sự khác biệt dài hơn.
Lớp
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu0 có hàm tạo nàylớp difflib. Khác nhau[rác dòng=Không có, charjunk=None]
Tham số từ khóa tùy chọn linejunk và charjunk dành cho chức năng lọc [hoặc
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu8]
rác rưởi. Một hàm chấp nhận một đối số chuỗi đơn và trả về true nếu chuỗi đó là rác. Giá trị mặc định là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu8, nghĩa là không có dòng nào bị coi là rác
đồ bỏ đi. Một hàm chấp nhận một đối số ký tự đơn [chuỗi có độ dài 1] và trả về true nếu ký tự đó là rác. Giá trị mặc định là
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu8, nghĩa là không có ký tự nào được coi là rác
Các chức năng lọc rác này tăng tốc độ đối sánh để tìm sự khác biệt và không làm cho bất kỳ dòng hoặc ký tự khác nhau nào bị bỏ qua. Đọc mô tả về tham số isjunk của phương thức
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu67 để được giải thích
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu0 đối tượng được sử dụng [deltas được tạo] thông qua một phương thức duy nhấtso sánh[a , b]¶
So sánh hai chuỗi dòng và tạo delta [một chuỗi các dòng]
Mỗi chuỗi phải chứa các chuỗi một dòng riêng lẻ kết thúc bằng dòng mới. Các chuỗi như vậy có thể được lấy từ phương thức
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu767 của các đối tượng giống như tệp. Đồng bằng được tạo cũng bao gồm các chuỗi kết thúc dòng mới, sẵn sàng để được in nguyên trạng thông qua phương thức
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu768 của một đối tượng giống như tệp
Ví dụ khác¶
Ví dụ này so sánh hai văn bản. Trước tiên, chúng tôi thiết lập các văn bản, trình tự của các chuỗi một dòng riêng lẻ kết thúc bằng dòng mới [các trình tự như vậy cũng có thể được lấy từ phương thức
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu767 của các đối tượng giống như tệp]
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu76
Tiếp theo chúng ta khởi tạo một đối tượng Differ
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu77
Lưu ý rằng khi khởi tạo một đối tượng
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> diff = list[diff] # materialize the generated delta into a list >>> print[''.join[restore[diff, 1]], end=""] one two three >>> print[''.join[restore[diff, 2]], end=""] ore tree emu0, chúng ta có thể truyền các hàm để lọc ra dòng và ký tự “rác”. ” Xem nhà xây dựng
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu771 để biết chi tiết
Cuối cùng, chúng tôi so sánh hai
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu78
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu772 là một danh sách các chuỗi, vì vậy hãy in nó thật đẹp
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu79
Là một chuỗi nhiều dòng duy nhất, nó trông như thế này
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu0
Giao diện dòng lệnh cho difflib¶
Ví dụ này cho thấy cách sử dụng difflib để tạo một tiện ích giống như
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu773. Nó cũng được chứa trong bản phân phối nguồn Python, như
>>> diff = ndiff['one\ntwo\nthree\n'.splitlines[keepends=True], .. 'ore\ntree\nemu\n'.splitlines[keepends=True]] >>> print[''.join[diff], end=""] - one ? ^ + ore ? ^ - two - three ? - + tree + emu70
Một dãy con trong Python là gì?
Một dãy con là một dãy có thể được suy ra từ một dãy khác bằng cách xóa một số phần tử mà không thay đổi thứ tự của các phần tử còn lại . con trăn. chuỗi. thuật toán.
Làm cách nào để kiểm tra xem một chuỗi có phải là chuỗi con của một chuỗi khác trong Python không?
Tạo hàm "checkForSubsequence[]" để [kiểm tra xem một chuỗi có phải là chuỗi con của chuỗi khác hay không bằng cách sử dụng ngăn xếp . Nó sẽ nhận hai đầu vào "s1" và "s2" và kiểm tra xem "s1" có phải là dãy con của "s2" hay không, sau đó trả về giá trị boolean "true", nếu không thì trả về giá trị boolean "false".
Chỉnh sửa khoảng cách có thể được giải quyết bằng LCS không?
Khoảng cách Levenshtein cho phép xóa, chèn và thay thế. Khoảng cách dãy con chung dài nhất [LCS] chỉ cho phép chèn và xóa, không thay thế .
Là chức năng subsequence trong Python?
Dãy con X của Y là dãy loại bỏ các phần tử khác hoặc nhiều hơn của Y sao cho X == Y . Ví dụ, “abc” là một dãy con của “atbtc”. Đầu tiên, chúng ta cần lấy iterator của y, sau đó iterator sẽ tiếp tục di chuyển sang phải [sẽ không đặt lại] nếu có thể – thông qua bất kỳ chức năng nào.