Ngoài ra, tôi phải thực hiện tác vụ này trên nhiều tệp cùng một lúc, các tệp được liệt kê trong kết quả tìm kiếm của studio trực quan sẽ giống như thế này
Find all "foo[", Subfolders, Find Results 1, "c:\", "*.txt"
C:\file1.txt[2]:a = foo[c]
C:\file1.txt[4]:b = foo[b]
C:\file1.txt[8]:c = foo[v]
C:\file2.txt[2]:a1 = foo[c]
C:\file2.txt[4]:a3 = foo[b]
C:\file2.txt[8]:variable1 = foo[v]
Matching lines: 6 Matching files: 2 Total files searched: 214
Find was stopped in progress.
Vì vậy, chúng tôi cần một cách để lấy tập hợp các tệp từ kết quả tìm kiếm của studio trực quan và sau đó chạy tác vụ trên từng tệp
Đây là thuật toán chính nơi
0 là dòng cần chèn, trong trường hợp này làa > b a = foo[c] a = bar[42] b = 2 b = foo[b] b = bar[42] foo bar foobar c = foo[v] c = bar[42]
1a > b a = foo[c] a = bar[42] b = 2 b = foo[b] b = bar[42] foo bar foobar c = foo[v] c = bar[42]
2 trong mẫu mà sau đó chúng tôi chèn dòng Trong trường hợp này,a > b a = foo[c] a = bar[42] b = 2 b = foo[b] b = bar[42] foo bar foobar c = foo[v] c = bar[42]
3 khớp vớia > b a = foo[c] a = bar[42] b = 2 b = foo[b] b = bar[42] foo bar foobar c = foo[v] c = bar[42]
4 chẳng hạna > b a = foo[c] a = bar[42] b = 2 b = foo[b] b = bar[42] foo bar foobar c = foo[v] c = bar[42]
5 là mẫu của các tệp chúng tôi đang tìm kiếm trong kết quả tìm kiếm của studio trực quana > b a = foo[c] a = bar[42] b = 2 b = foo[b] b = bar[42] foo bar foobar c = foo[v] c = bar[42]
Chức năng chính là
a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
6________số 8Tạo một tập hợp các tệp từ kết quả tìm kiếm phòng thu trực quan
Đây là mã sẽ lấy tập hợp các tệp trong kết quả tìm kiếm. Trong đó
a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
5 bằng với a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
8. Có nghĩa là bất kỳ tệp nào có phần mở rộng a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
9 có tên là bất kỳ ký tự từ nào Xin chào mọi người, đây là Thijmen, và trong bài viết này, tôi sẽ trình bày hai phương pháp để ghi đè các dòng đã in trước đó trong Python bằng cách sử dụng các chuỗi thoát ANSI
Bài viết này cũng có sẵn ở định dạng video trên YouTubeHoàn tác các câu lệnh in có thể rất hữu ích nếu bạn muốn cung cấp đầu ra liên tục mà không làm lộn xộn màn hình
Việc triển khai và kết quả dự định hơi khác nhau đối với từng phương pháp, vì vậy phương pháp nào sẽ sử dụng thực sự phụ thuộc vào trường hợp sử dụng của bạn. Ưu và nhược điểm của chúng sẽ trở nên rõ ràng ngay sau khi bạn hiểu cách chúng hoạt động, vì vậy hãy bắt đầu ngay với phương pháp đầu tiên
💡 Trong bài viết này, tôi cung cấp một số thông tin cơ bản giúp bạn hiểu cách thức và lý do các phương pháp này hoạt động. Nếu bạn muốn khắc phục nhanh, có TL;DR ở dưới cùng
Phương pháp 1. Vận chuyển trở lại
Nhanh chóng và đơn giản
Tóm lược
- Dòng in, nhưng kết thúc bằng ký tự xuống dòng thay vì ký tự xuống dòng. Điều này di chuyển con trỏ trở lại đầu dòng in
- In một dòng khác, nhưng vì con trỏ hiện đang ở đầu dòng trước, kết quả mới sẽ được in ở đầu dòng trước
Tiếp cận
Theo mặc định, câu lệnh
a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
2 của Python kết thúc mỗi chuỗi được truyền vào hàm bằng một ký tự xuống dòng, a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
3. Hành vi này có thể được ghi đè bằng tham số a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
4 của hàm, đây là cốt lõi của phương pháp nàyThay vì kết thúc đầu ra bằng một dòng mới, chúng tôi sử dụng dấu xuống dòng
Khi chúng ta kết thúc câu lệnh
a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
2 bằng dấu xuống dòng, về cơ bản, chúng ta sẽ di chuyển con trỏ trở lại đầu dòng được in, thay vì đến dòng tiếp theo. Sau đó, nếu chúng ta in một chuỗi khác, văn bản được in “trên cùng” của chuỗi trước đó. Trong Python, dấu xuống dòng được biểu thị bằng a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
6💡 Ban đầu, thuật ngữ “carriage return” dùng để chỉ một cơ chế hoặc đòn bẩy trên máy đánh chữ được vận hành sau khi gõ một dòng văn bản, giúp căn chỉnh phần tử loại của máy về phía bên trái của tờ giấy
Trường hợp ví dụ
Giả sử chúng ta có một chuỗi đơn giản mà chúng ta muốn in từng ký tự, cứ sau 0 lại có một ký tự. 5 giây
Trường hợp ví dụ [chưa ghi đè]Sử dụng câu lệnh
a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
2 mặc định, điều này trông giống như vậyTrường hợp ví dụ [chưa ghi đè]
Bây giờ hãy xem điều gì sẽ xảy ra nếu chúng ta kết thúc mỗi câu lệnh
a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
2 bằng dấu xuống dòng thay vào đóTất cả các ký tự được in trên cùng một dòng
Phương pháp 1 trong thực tế
Dễ dàng phải không? . Bởi vì về cơ bản, chúng tôi xuất từng câu lệnh
a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
2 liên tiếp trên đầu ra trước đó, nên việc in một dòng ngắn hơn dòng trước đó là không khả thi.Xem điều gì sẽ xảy ra nếu chúng ta in 'xong' ở cuối vòng lặp
Lưu ý phương pháp 1. in các dòng ngắn hơn
Chúng tôi có thể ngăn chặn điều này bằng cách xóa dòng trước đó trước khi chúng tôi in một chuỗi ngắn hơn
Trình tự ANSI trên dòng 6 chỉ ra rằng dòng có con trỏ sẽ bị xóa [lưu ý
a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
6 ở cuối vòng lặp for]. Bằng cách sử dụng biến a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
1 làm tham số a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
4, chúng tôi đảm bảo rằng không có ký tự xuống dòng bổ sung nào được inPhương pháp 1. ví dụ làm việc. Phương pháp 2. “Dọn dẹp”Hơi phức tạp hơn, nhưng đầu ra sạch hơn và linh hoạt hơn
Tóm lược
- Dòng in [mặc định kết thúc bằng một dòng mới]
- Ngay trước câu lệnh
2 tiếp theo. di chuyển con trỏ lên và xóa dòng. Hành động này có thể được lặp lại để hoàn tác nhiều dòng đã ina > b a = foo[c] a = bar[42] b = 2 b = foo[b] b = bar[42] foo bar foobar c = foo[v] c = bar[42]
- In dòng tiếp theo của bạn
Tiếp cận
Trong phương pháp này, chúng tôi không thay đổi tham số
a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
4 của câu lệnh a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
2 được sử dụng để hiển thị đầu ra của chúng tôi. Thay vào đó, chúng tôi thêm một câu lệnh a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
2 bổ sung để xóa dòng trước đó bằng hai mã thoát ANSI- Mã ANSI được gán cho
35 chỉ ra rằng con trỏ sẽ di chuyển lên một dònga > b a = foo[c] a = bar[42] b = 2 b = foo[b] b = bar[42] foo bar foobar c = foo[v] c = bar[42]
- Mã ANSI được gán cho
1 sẽ xóa dòng có con trỏ [cũng được sử dụng trong phương thức đầu tiên]a > b a = foo[c] a = bar[42] b = 2 b = foo[b] b = bar[42] foo bar foobar c = foo[v] c = bar[42]
Lưu ý rằng chúng tôi đã thay đổi tham số
a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
4 của câu lệnh a > b
a = foo[c]
a = bar[42]
b = 2
b = foo[b]
b = bar[42]
foo
bar
foobar
c = foo[v]
c = bar[42]
2 bổ sung để ngăn ký tự xuống dòng mặc định được inPhương pháp 2 trong thực tế
Về mặt chức năng, phương pháp này cung cấp hai ưu điểm so với phương pháp đầu tiên
- Bạn không phải lo lắng về độ dài của dòng tiếp theo
- Con trỏ không can thiệp trực quan vào các dòng in
Gọn gàng, phải không?
TL;DRChúng ta có cuộc sống bận rộn. tôi hiểu rồiNếu bạn học được điều gì đó mới từ bài viết này, vui lòng cân nhắc đăng ký kênh YouTube của tôi. Cảm ơn. 🙂
Bài viết này và video tương ứng là một phần trong chuỗi Python Snippets của tôi, nơi chúng tôi đề cập đến nhiều chủ đề khác nhau xung quanh lập trình Python ở định dạng có kích thước byte