Hướng dẫn how to limit output in python - làm thế nào để giới hạn đầu ra trong python

Gọi

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

75

Ví dụ đơn giản nhất về việc sử dụng Python

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Bạn không vượt qua bất kỳ đối số nào, nhưng bạn vẫn cần đặt dấu ngoặc đơn ở cuối, điều này bảo Python thực sự thực hiện chức năng thay vì chỉ đề cập đến nó bằng tên.

Điều này sẽ tạo ra một ký tự mới vô hình, từ đó sẽ khiến một dòng trống xuất hiện trên màn hình của bạn. Bạn có thể gọi

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Một ký tự mới là một ký tự điều khiển đặc biệt được sử dụng để chỉ ra phần cuối của một dòng [EOL]. Nó thường không có một biểu diễn rõ ràng trên màn hình, nhưng một số trình chỉnh sửa văn bản có thể hiển thị các ký tự không thể in như vậy với ít đồ họa.newline character is a special control character used to indicate the end of a line [EOL]. It usually doesn’t have a visible representation on the screen, but some text editors can display such non-printable characters with little graphics.

Từ ngữ nhân vật có phần của một người hiểu sai trong trường hợp này, bởi vì một dòng mới thường dài hơn một ký tự. Ví dụ: hệ điều hành Windows, cũng như giao thức HTTP, đại diện cho Newlines với một cặp ký tự. Đôi khi bạn cần tính đến những khác biệt đó để thiết kế các chương trình thực sự di động.

Để tìm hiểu những gì tạo thành một dòng mới trong hệ điều hành của bạn, hãy sử dụng mô-đun

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Điều này sẽ ngay lập tức cho bạn biết rằng Windows và DOS đại diện cho Newline dưới dạng chuỗi

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

>>> import os
>>> os.linesep
'\r\n'

Trên Unix, Linux và các phiên bản gần đây của MacOS, nó có một ký tự

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Trên Unix, Linux và các phiên bản gần đây của MacOS, nó có một ký tự

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Trên Unix, Linux và các phiên bản gần đây của MacOS, nó có một ký tự

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Tuy nhiên, Mac OS X cổ điển gắn bó với triết lý của riêng mình về vấn đề khác nhau bằng cách chọn một đại diện khác:

• Lưu ý cách các ký tự này xuất hiện trong chuỗi chữ. Họ sử dụng cú pháp đặc biệt với dấu gạch chéo ngược trước [

  [[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]
  

  90] để biểu thị sự bắt đầu của chuỗi ký tự thoát. Các chuỗi như vậy cho phép thể hiện các ký tự điều khiển, nếu không thì vô hình trên màn hình. backslash
• Hầu hết các ngôn ngữ lập trình đều đi kèm với một tập hợp các chuỗi thoát được xác định trước cho các ký tự đặc biệt như sau: backspace

• [[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]
  

  91: Backslash tab

• [[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]
  

  92: Backspace carriage return [CR]

• [[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]
  

  93: Tab newline, also known as line feed [LF]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Hai phần cuối gợi nhớ đến các máy đánh chữ cơ học, yêu cầu hai lệnh riêng biệt để chèn một dòng mới. Lệnh đầu tiên sẽ di chuyển cỗ xe trở lại đầu dòng hiện tại, trong khi lệnh thứ hai sẽ tiến lên cuộn sang dòng tiếp theo.

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Hãy nhớ rằng, để tạo thành một chuỗi thoát chính xác, không được có khoảng trống giữa ký tự dấu gạch chéo ngược và một chữ cái!

Như bạn vừa thấy, gọi

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Bạn có thể sử dụng các chữ Python từ Chuỗi để trực quan hóa hai điều này:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Người đầu tiên là một nhân vật dài, trong khi người thứ hai không có nội dung.

Trong một kịch bản phổ biến hơn, bạn đã muốn truyền đạt một số thông báo cho người dùng cuối. Có một vài cách để đạt được điều này.

Đầu tiên, bạn có thể chuyển một chuỗi trực tiếp theo nghĩa đen đến

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Điều này sẽ in thông điệp nguyên văn lên màn hình.

Chuỗi chữ trong Python có thể được đặt trong các trích dẫn đơn [

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Ví dụ, bạn có thể sử dụng các trích dẫn kép cho chữ theo nghĩa đen và cũng bao gồm các trích dẫn kép bên trong nó, bởi vì đó là sự mơ hồ đối với người phiên dịch Python:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Những gì bạn muốn làm là kèm theo văn bản, trong đó có chứa hai trích dẫn, trong các trích dẫn đơn:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Thủ thuật tương tự sẽ hoạt động theo cách khác:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Ngoài ra, bạn có thể sử dụng các chuỗi ký tự Escape được đề cập trước đó, để làm cho Python đối xử với các trích dẫn kép nội bộ đó theo nghĩa đen như là một phần của chuỗi theo nghĩa đen:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Thoát khỏi là tốt và bảnh bao, nhưng đôi khi nó có thể cản trở. Cụ thể, khi bạn cần chuỗi của mình để chứa nhiều ký tự dấu gạch chéo ngược ở dạng nghĩa đen.

Một ví dụ cổ điển là đường dẫn tệp trên Windows:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Lưu ý cách mỗi nhân vật dấu gạch chéo ngược cần phải được thoát ra với một dấu gạch chéo ngược khác.

Điều này thậm chí còn nổi bật hơn với các biểu thức thông thường, nhanh chóng bị xáo trộn do sử dụng nặng các ký tự đặc biệt:

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

May mắn thay, bạn có thể tắt nhân vật thoát hoàn toàn với sự trợ giúp của các chữ theo chuỗi thô. Chỉ cần dành cho

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Điều đó tốt hơn nhiều, phải không?

Có một vài tiền tố khác mang lại ý nghĩa đặc biệt cho các chuỗi chữ trong Python, nhưng bạn đã giành chiến thắng vào chúng ở đây.

Cuối cùng, bạn có thể xác định các chữ số đa dòng bằng cách đặt chúng giữa

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Đây là một ví dụ:

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Để ngăn chặn một dòng mới ban đầu, chỉ cần đặt văn bản ngay sau khi mở

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Bạn cũng có thể sử dụng dấu gạch chéo ngược để loại bỏ dòng mới:

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Để loại bỏ thụt lề khỏi chuỗi nhiều dòng, bạn có thể tận dụng mô-đun

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

>>>

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Điều này sẽ chăm sóc các đoạn văn không ổn định cho bạn. Ngoài ra còn có một vài chức năng hữu ích khác trong

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Thứ hai, bạn có thể trích xuất tin nhắn đó vào biến của chính nó với một tên có ý nghĩa để tăng cường khả năng đọc và thúc đẩy tái sử dụng mã:

>>>

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Cuối cùng, bạn có thể vượt qua một biểu thức, như nối chuỗi, được đánh giá trước khi in kết quả:

>>>

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Trên thực tế, có một tá cách để định dạng tin nhắn trong Python. Tôi rất khuyến khích bạn xem xét các chuỗi F, được giới thiệu trong Python 3.6, bởi vì họ cung cấp cú pháp ngắn gọn nhất của tất cả:

>>>

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Hơn nữa, các chuỗi F sẽ ngăn bạn mắc một sai lầm phổ biến, đó là quên gõ các toán hạng được kết hợp. Python là một ngôn ngữ được đánh máy mạnh mẽ, điều đó có nghĩa là nó đã giành được cho phép bạn làm điều này:

>>>

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Điều đó sai vì thêm số vào chuỗi không có ý nghĩa. Bạn cần chuyển đổi rõ ràng số thành chuỗi trước, để kết hợp chúng với nhau:

>>>

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

Trừ khi bạn tự xử lý các lỗi như vậy, trình thông dịch Python sẽ cho bạn biết về một vấn đề bằng cách hiển thị một dấu vết.

Như với bất kỳ chức năng nào, nó không quan trọng cho dù bạn vượt qua một nghĩa đen, một biến hay một biểu thức. Tuy nhiên, không giống như nhiều chức năng khác,

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Cho đến nay, bạn chỉ nhìn vào chuỗi, nhưng làm thế nào về các loại dữ liệu khác? Hãy để thử các loại văn bản của các loại tích hợp khác nhau và xem những gì ra mắt:

>>>

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

Xem ra cho hằng số

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Làm thế nào để

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Sau đó trong hướng dẫn này, bạn sẽ học cách sử dụng cơ chế này để in các loại dữ liệu tùy chỉnh như các lớp của bạn.

Được rồi, bây giờ bạn có thể gọi

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Để đạt được kết quả tương tự trong việc tạo ngôn ngữ trước đó, bạn thường muốn bỏ dấu ngoặc đơn kèm theo văn bản:

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

Đó là vì

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Ví dụ, dấu ngoặc đơn bao quanh một biểu thức duy nhất hoặc một chữ theo nghĩa đen là tùy chọn. Cả hai hướng dẫn tạo ra cùng một kết quả trong Python 2:

>>>

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

Khung tròn thực sự là một phần của biểu thức chứ không phải là câu lệnh

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Mặt khác, đặt dấu ngoặc đơn xung quanh nhiều mục tạo thành một bộ phận:

>>>

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

Khung tròn thực sự là một phần của biểu thức chứ không phải là câu lệnh

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

Khung tròn thực sự là một phần của biểu thức chứ không phải là câu lệnh

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Mặt khác, đặt dấu ngoặc đơn xung quanh nhiều mục tạo thành một bộ phận:

Đây là một nguồn nhầm lẫn được biết đến. Trên thực tế, bạn cũng nhận được một bộ phận bằng cách nối một dấu phẩy kéo vào vật phẩm duy nhất được bao quanh bởi dấu ngoặc đơn:

Điểm mấu chốt là bạn không nên gọi

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Tách nhiều đối số

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Mặt khác, đặt dấu ngoặc đơn xung quanh nhiều mục tạo thành một bộ phận:

>>>

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

Khung tròn thực sự là một phần của biểu thức chứ không phải là câu lệnh

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

Khung tròn thực sự là một phần của biểu thức chứ không phải là câu lệnh

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Mặt khác, đặt dấu ngoặc đơn xung quanh nhiều mục tạo thành một bộ phận:

>>>

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

Khung tròn thực sự là một phần của biểu thức chứ không phải là câu lệnh

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Mặt khác, đặt dấu ngoặc đơn xung quanh nhiều mục tạo thành một bộ phận:

>>>

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Khung tròn thực sự là một phần của biểu thức chứ không phải là câu lệnh

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Mặt khác, đặt dấu ngoặc đơn xung quanh nhiều mục tạo thành một bộ phận:separator and is assigned a single space [

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Đây là một nguồn nhầm lẫn được biết đến. Trên thực tế, bạn cũng nhận được một bộ phận bằng cách nối một dấu phẩy kéo vào vật phẩm duy nhất được bao quanh bởi dấu ngoặc đơn:

>>>

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Khung tròn thực sự là một phần của biểu thức chứ không phải là câu lệnh

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Khung tròn thực sự là một phần của biểu thức chứ không phải là câu lệnh

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Mặt khác, đặt dấu ngoặc đơn xung quanh nhiều mục tạo thành một bộ phận:

>>>

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Khung tròn thực sự là một phần của biểu thức chứ không phải là câu lệnh

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Khung tròn thực sự là một phần của biểu thức chứ không phải là câu lệnh

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Mặt khác, đặt dấu ngoặc đơn xung quanh nhiều mục tạo thành một bộ phận:

>>>

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Khung tròn thực sự là một phần của biểu thức chứ không phải là câu lệnh

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Cuối cùng, tham số

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

>>>

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Trong các tiểu mục sắp tới, bạn sẽ khám phá các đối số từ khóa còn lại của hàm

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Để in nhiều yếu tố trong Python 2, bạn phải thả dấu ngoặc đơn xung quanh chúng, giống như trước đây:

>>>

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Trong các tiểu mục sắp tới, bạn sẽ khám phá các đối số từ khóa còn lại của hàm

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Để in nhiều yếu tố trong Python 2, bạn phải thả dấu ngoặc đơn xung quanh chúng, giống như trước đây:

>>>

[1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]

Trong các tiểu mục sắp tới, bạn sẽ khám phá các đối số từ khóa còn lại của hàm

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Để in nhiều yếu tố trong Python 2, bạn phải thả dấu ngoặc đơn xung quanh chúng, giống như trước đây:

Nếu bạn giữ chúng, mặt khác, bạn sẽ chuyển một phần tử tuple duy nhất cho câu lệnh

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Ngoài ra, không có cách nào để thay đổi bộ phân cách mặc định của các phần tử được nối trong Python 2, vì vậy một cách giải quyết là sử dụng phép nội suy chuỗi như vậy:

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

C

• r = reprlib.Repr[]
  r.maxlist = 4       # max elements displayed for lists
  r.maxstring = 10    # max characters displayed for strings
  
  obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']
  
  print[r.repr[obj]]
  

  43
• C ++

• r = reprlib.Repr[]
  r.maxlist = 4       # max elements displayed for lists
  r.maxstring = 10    # max characters displayed for strings
  
  obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']
  
  print[r.repr[obj]]
  

  44
• Ngược lại, chức năng Python từ

  [[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]
  

  75 luôn thêm

  [[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]
  

  88 mà không cần hỏi, bởi vì đó là những gì bạn muốn trong hầu hết các trường hợp. Để vô hiệu hóa nó, bạn có thể tận dụng một đối số từ khóa khác,

  r = reprlib.Repr[]
  r.maxlist = 4       # max elements displayed for lists
  r.maxstring = 10    # max characters displayed for strings
  
  obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']
  
  print[r.repr[obj]]
  

  47, điều này chỉ ra những gì sẽ kết thúc dòng.
• Về mặt ngữ nghĩa, tham số

  r = reprlib.Repr[]
  r.maxlist = 4       # max elements displayed for lists
  r.maxstring = 10    # max characters displayed for strings
  
  obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']
  
  print[r.repr[obj]]
  

  47 gần như giống hệt với

  r = reprlib.Repr[]
  r.maxlist = 4       # max elements displayed for lists
  r.maxstring = 10    # max characters displayed for strings
  
  obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']
  
  print[r.repr[obj]]
  

  27 mà bạn đã thấy trước đó:

Nó phải là một chuỗi hoặc

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Nó có thể là tùy ý dài.

[1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]

Nó có giá trị mặc định là

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

[1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]

Nếu bằng

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

[1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]

Nếu bằng một chuỗi trống [

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

[1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]

Bây giờ bạn đã hiểu những gì xảy ra dưới mui xe khi bạn gọi

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

[1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]

Để tắt dòng mới, bạn phải chỉ định một chuỗi trống thông qua đối số từ khóa

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

[1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]

Mặc dù đây là hai cuộc gọi

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]

Tuy nhiên, sau cuộc gọi thứ hai đến

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]

Như với

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

str_num = ""
print["Original string:",str_num]
print['%.6s' % str_num]
print['%.9s' % str_num]
print['%.10s' % str_num]

Ba hướng dẫn này sẽ xuất ra một dòng văn bản duy nhất:

Bạn có thể trộn hai đối số từ khóa:

Bạn không chỉ nhận được một dòng văn bản duy nhất mà tất cả các mục được phân tách bằng dấu phẩy:

Không có gì để ngăn bạn sử dụng nhân vật Newline với một số phần đệm thêm xung quanh nó:

str_num = ""
print["Original string:",str_num]
print['%.6s' % str_num]
print['%.9s' % str_num]
print['%.10s' % str_num]

Nó sẽ in ra đoạn văn bản sau:

Như bạn có thể thấy, đối số từ khóa

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

str_num = ""
print["Original string:",str_num]
print['%.6s' % str_num]
print['%.9s' % str_num]
print['%.10s' % str_num]

Bạn có thể làm quen với việc in ấn ở Python, nhưng vẫn còn rất nhiều thông tin hữu ích phía trước. Trong tiểu mục sắp tới, bạn sẽ học cách đánh chặn và chuyển hướng đầu ra chức năng

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Ngăn chặn một dòng phá vỡ trong Python 2 yêu cầu bạn nối một dấu phẩy kéo theo biểu thức:

In vào một tệp

Dù bạn có tin hay không,

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Ngoài ra, có ba luồng tiêu chuẩn được cung cấp bởi hệ điều hành:

1. r = reprlib.Repr[]
   r.maxlist = 4       # max elements displayed for lists
   r.maxstring = 10    # max characters displayed for strings
   
   obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']
   
   print[r.repr[obj]]
   

   73: Đầu vào tiêu chuẩn standard input

2. r = reprlib.Repr[]
   r.maxlist = 4       # max elements displayed for lists
   r.maxstring = 10    # max characters displayed for strings
   
   obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']
   
   print[r.repr[obj]]
   

   74: Đầu ra tiêu chuẩn standard output

3. r = reprlib.Repr[]
   r.maxlist = 4       # max elements displayed for lists
   r.maxstring = 10    # max characters displayed for strings
   
   obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']
   
   print[r.repr[obj]]
   

   75: Lỗi tiêu chuẩn standard error

Đầu ra tiêu chuẩn là những gì bạn thấy trong thiết bị đầu cuối khi bạn chạy các chương trình dòng lệnh khác nhau bao gồm các tập lệnh Python của riêng bạn: is what you see in the terminal when you run various command-line programs including your own Python scripts:

str_num = ""
print["Original string:",str_num]
print['%.6s' % str_num]
print['%.9s' % str_num]
print['%.10s' % str_num]

Trừ khi được hướng dẫn khác,

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

str_num = ""
print["Original string:",str_num]
print['%.6s' % str_num]
print['%.9s' % str_num]
print['%.10s' % str_num]

Rằng được gọi là chuyển hướng luồng.

Lỗi tiêu chuẩn tương tự như

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Một số chương trình sử dụng màu khác nhau để phân biệt giữa các thông báo được in thành

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Trong khi cả

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Trong Python, bạn có thể truy cập tất cả các luồng tiêu chuẩn thông qua mô-đun

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

>>>

str_num = ""
print["Original string:",str_num]
print['%.6s' % str_num]
print['%.9s' % str_num]
print['%.10s' % str_num]

Như bạn có thể thấy, các giá trị được xác định trước này giống với các đối tượng giống như tệp với các thuộc tính

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Theo mặc định,

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

str_num = ""
print["Original string:",str_num]
print['%.6s' % str_num]
print['%.9s' % str_num]
print['%.10s' % str_num]

Điều này sẽ làm cho mã của bạn miễn dịch với chuyển hướng truyền phát ở cấp hệ điều hành, điều này có thể hoặc không mong muốn.

Để biết thêm thông tin về việc làm việc với các tệp trong Python, bạn có thể kiểm tra đọc và ghi các tệp bằng Python [Hướng dẫn].

Lưu ý rằng

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

str_num = ""
print["Original string:",str_num]
print['%.6s' % str_num]
print['%.9s' % str_num]
print['%.10s' % str_num]

Thay vì một tệp thực hiện có ở đâu đó trong hệ thống tệp của bạn, bạn có thể cung cấp một tệp giả, sẽ nằm trong bộ nhớ máy tính của bạn. Bạn sẽ sử dụng kỹ thuật này sau này để chế giễu

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

str_num = ""
print["Original string:",str_num]
print['%.6s' % str_num]
print['%.9s' % str_num]
print['%.10s' % str_num]

Như bạn có thể thấy, các giá trị được xác định trước này giống với các đối tượng giống như tệp với các thuộc tính

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Theo mặc định,

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

str_num = ""
print["Original string:",str_num]
print['%.6s' % str_num]
print['%.9s' % str_num]
print['%.10s' % str_num]

Điều này sẽ làm cho mã của bạn miễn dịch với chuyển hướng truyền phát ở cấp hệ điều hành, điều này có thể hoặc không mong muốn.

Để biết thêm thông tin về việc làm việc với các tệp trong Python, bạn có thể kiểm tra đọc và ghi các tệp bằng Python [Hướng dẫn].

Lưu ý rằng

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

>>>

Original string: 
123456
123456789

Như bạn có thể thấy, các giá trị được xác định trước này giống với các đối tượng giống như tệp với các thuộc tính

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Original string: 
123456
123456789

Theo mặc định,

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Original string: 
123456
123456789

Điều này sẽ làm cho mã của bạn miễn dịch với chuyển hướng truyền phát ở cấp hệ điều hành, điều này có thể hoặc không mong muốn.

Original string: 
123456
123456789

Để biết thêm thông tin về việc làm việc với các tệp trong Python, bạn có thể kiểm tra đọc và ghi các tệp bằng Python [Hướng dẫn].

Original string: 
123456
123456789

Lưu ý rằng

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Thay vì một tệp thực hiện có ở đâu đó trong hệ thống tệp của bạn, bạn có thể cung cấp một tệp giả, sẽ nằm trong bộ nhớ máy tính của bạn. Bạn sẽ sử dụng kỹ thuật này sau này để chế giễu

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

75 trong các bài kiểm tra đơn vị:

Nếu bạn đến điểm này, thì bạn sẽ chỉ còn lại một đối số từ khóa trong

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Hãy tưởng tượng bạn đang viết một bộ đếm thời gian đếm ngược, sẽ nối thời gian còn lại vào cùng một dòng mỗi giây:

Nỗ lực đầu tiên của bạn có thể trông giống như thế này:

Original string: 
123456
123456789

Miễn là biến

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

Thật bất ngờ, thay vì đếm ngược mỗi giây, chương trình không hoạt động lãng phí trong ba giây, và sau đó đột nhiên in toàn bộ dòng cùng một lúc:

Điều đó bởi vì các bộ đệm hệ điều hành tiếp theo ghi vào đầu ra tiêu chuẩn trong trường hợp này. Bạn cần biết rằng có ba loại luồng liên quan đến bộ đệm:

1. Không bị ảnh hưởng
2. Line-buffered
3. Block-buffered

Không bị ảnh hưởng là tự giải thích, nghĩa là không có bộ đệm đang diễn ra và tất cả các văn bản đều có hiệu lực ngay lập tức. Một luồng đệm dòng chờ đợi trước khi bắn bất kỳ cuộc gọi I/O nào cho đến khi ngắt dòng xuất hiện ở đâu đó trong bộ đệm, trong khi đó, một buff được chặn chỉ cho phép bộ đệm lấp đầy lên một kích thước nhất định bất kể nội dung của nó. Đầu ra tiêu chuẩn là cả đệm và đệm khối, tùy thuộc vào sự kiện nào đến trước. is self-explanatory, that is, no buffering is taking place, and all writes have immediate effect. A line-buffered stream waits before firing any I/O calls until a line break appears somewhere in the buffer, whereas a block-buffered one simply allows the buffer to fill up to a certain size regardless of its content. Standard output is both line-buffered and block-buffered, depending on which event comes first.

Bộ đệm giúp giảm số lượng cuộc gọi I/O đắt tiền. Ví dụ, hãy suy nghĩ về việc gửi tin nhắn qua một mạng có độ trễ cao. Khi bạn kết nối với một máy chủ từ xa để thực thi các lệnh qua giao thức SSH, mỗi tổ hợp phím của bạn thực sự có thể tạo ra một gói dữ liệu riêng lẻ, các đơn đặt hàng có cường độ lớn hơn tải trọng của nó. Thật là một chi phí! Sẽ có ý nghĩa để đợi cho đến khi ít nhất một vài ký tự được gõ và sau đó gửi chúng lại với nhau. Đó là nơi mà bộ đệm bước vào.

Mặt khác, bộ đệm đôi khi có thể có các hiệu ứng không mong muốn như bạn vừa thấy với ví dụ đếm ngược. Để khắc phục nó, bạn chỉ có thể nói với

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

Original string: 
123456
123456789

Đó là tất cả. Việc đếm ngược của bạn sẽ hoạt động như mong đợi bây giờ, nhưng don lồng nhận lời của tôi cho nó. Đi trước và kiểm tra nó để thấy sự khác biệt.

Xin chúc mừng! Tại thời điểm này, bạn đã thấy các ví dụ về việc gọi

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Có một cách dễ dàng để xóa luồng trong Python 2, bởi vì câu lệnh

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Original string: 
123456
123456789

Ngoài ra, bạn có thể vô hiệu hóa bộ đệm của các luồng tiêu chuẩn bằng cách cung cấp cờ

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

Original string: 
123456
123456789

Lưu ý rằng

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

>>>

>>> m = {x: x ** 2 for x in range[5]}
>>> m
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Những gì bạn thấy ở đây là một tài liệu của hàm

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

In các loại dữ liệu tùy chỉnh

Cho đến bây giờ, bạn chỉ xử lý các loại dữ liệu tích hợp như chuỗi và số, nhưng bạn sẽ thường muốn in các loại dữ liệu trừu tượng của riêng mình. Hãy để một cái nhìn về các cách khác nhau để xác định chúng.

Đối với các đối tượng đơn giản mà không có bất kỳ logic nào, có mục đích mang dữ liệu, bạn thường sẽ tận dụng

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

>>>

>>> m = {x: x ** 2 for x in range[5]}
>>> m
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Những gì bạn thấy ở đây là một tài liệu của hàm

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

>>> m = {x: x ** 2 for x in range[5]}
>>> m
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

In các loại dữ liệu tùy chỉnh

>>>

>>> m = {x: x ** 2 for x in range[5]}
>>> m
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Những gì bạn thấy ở đây là một tài liệu của hàm

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

>>> m = {x: x ** 2 for x in range[5]}
>>> m
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

In các loại dữ liệu tùy chỉnh

Cho đến bây giờ, bạn chỉ xử lý các loại dữ liệu tích hợp như chuỗi và số, nhưng bạn sẽ thường muốn in các loại dữ liệu trừu tượng của riêng mình. Hãy để một cái nhìn về các cách khác nhau để xác định chúng.

Thật đúng là việc thiết kế các loại dữ liệu bất biến là mong muốn, nhưng trong nhiều trường hợp, bạn sẽ muốn chúng cho phép thay đổi, vì vậy bạn đã quay lại với các lớp học thông thường một lần nữa.

Từ các tiểu mục trước đó, bạn đã biết rằng

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

>>>

>>> m = {x: x ** 2 for x in range[5]}
>>> m
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

1. [[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]
   

   35

2. [[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]
   

   36

Cái đầu tiên được khuyến nghị trả lại một văn bản ngắn, có thể đọc được, bao gồm thông tin từ các thuộc tính có liên quan nhất. Rốt cuộc, bạn không muốn hiển thị dữ liệu nhạy cảm, chẳng hạn như mật khẩu người dùng, khi in các đối tượng.

Tuy nhiên, một cái khác nên cung cấp thông tin đầy đủ về một đối tượng, để cho phép khôi phục trạng thái của nó từ một chuỗi. Lý tưởng nhất, nó sẽ trả về mã Python hợp lệ, để bạn có thể chuyển trực tiếp đến

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

>>>

>>> m = {x: x ** 2 for x in range[5]}
>>> m
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Cái đầu tiên được khuyến nghị trả lại một văn bản ngắn, có thể đọc được, bao gồm thông tin từ các thuộc tính có liên quan nhất. Rốt cuộc, bạn không muốn hiển thị dữ liệu nhạy cảm, chẳng hạn như mật khẩu người dùng, khi in các đối tượng.

Tuy nhiên, một cái khác nên cung cấp thông tin đầy đủ về một đối tượng, để cho phép khôi phục trạng thái của nó từ một chuỗi. Lý tưởng nhất, nó sẽ trả về mã Python hợp lệ, để bạn có thể chuyển trực tiếp đến

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

Lưu ý rằng việc sử dụng một chức năng tích hợp khác,

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

>>> m = {x: x ** 2 for x in range[5]}
>>> m
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Python cung cấp cho bạn rất nhiều tự do khi xác định các loại dữ liệu của riêng bạn nếu không có loại nào tích hợp đáp ứng nhu cầu của bạn. Một số trong số chúng, chẳng hạn như các bộ dữ liệu và các lớp dữ liệu được đặt tên, cung cấp các biểu diễn chuỗi trông tốt mà không yêu cầu bất kỳ công việc nào từ phía bạn. Tuy nhiên, đối với sự linh hoạt nhất, bạn sẽ phải xác định một lớp và ghi đè các phương thức ma thuật của nó được mô tả ở trên.

Các ngữ nghĩa của

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

Ở đây, một ví dụ về cùng một lớp

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

>>>

>>> m = {x: x ** 2 for x in range[5]}
>>> m
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

>>>

>>> m = {x: x ** 2 for x in range[5]}
>>> m
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Cái đầu tiên được khuyến nghị trả lại một văn bản ngắn, có thể đọc được, bao gồm thông tin từ các thuộc tính có liên quan nhất. Rốt cuộc, bạn không muốn hiển thị dữ liệu nhạy cảm, chẳng hạn như mật khẩu người dùng, khi in các đối tượng.

>>>

>>> import os
>>> os.linesep
'\r\n'

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Lưu ý rằng việc sử dụng một chức năng tích hợp khác,

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

38, luôn cố gắng gọi

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

39 trong một đối tượng, nhưng lại trở lại biểu diễn mặc định nếu nó không tìm thấy phương thức đó.

Python cung cấp cho bạn rất nhiều tự do khi xác định các loại dữ liệu của riêng bạn nếu không có loại nào tích hợp đáp ứng nhu cầu của bạn. Một số trong số chúng, chẳng hạn như các bộ dữ liệu và các lớp dữ liệu được đặt tên, cung cấp các biểu diễn chuỗi trông tốt mà không yêu cầu bất kỳ công việc nào từ phía bạn. Tuy nhiên, đối với sự linh hoạt nhất, bạn sẽ phải xác định một lớp và ghi đè các phương thức ma thuật của nó được mô tả ở trên.

>>>

>>> import os
>>> os.linesep
'\r\n'

Các ngữ nghĩa của

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

>>>

>>> import os
>>> os.linesep
'\r\n'

Ở đây, một ví dụ về cùng một lớp

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

>>>

>>> import os
>>> os.linesep
'\r\n'

Bây giờ bạn có hai hàm in riêng biệt giống như trong ngôn ngữ lập trình Java. Bạn cũng sẽ xác định các chức năng

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Mặt khác,

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

>>>

>>> import os
>>> os.linesep
'\r\n'

Trên thực tế, các chức năng như vậy là các thủ tục hoặc chương trình con mà bạn gọi để đạt được một số loại tác dụng phụ, cuối cùng là một sự thay đổi của một trạng thái toàn cầu. Trong trường hợp của

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Bởi vì

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Bên cạnh đó, các chức năng dễ dàng hơn để mở rộng. Việc thêm một tính năng mới vào một chức năng cũng dễ dàng như việc thêm một đối số từ khóa khác, trong khi việc thay đổi ngôn ngữ để hỗ trợ tính năng mới đó thì cồng kềnh hơn nhiều. Hãy nghĩ về chuyển hướng luồng hoặc xả đệm, ví dụ.extend. Adding a new feature to a function is as easy as adding another keyword argument, whereas changing the language to support that new feature is much more cumbersome. Think of stream redirection or buffer flushing, for example.

Một lợi ích khác của

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>> import os
>>> os.linesep
'\r\n'

Ở đây, tham số

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Thành phần cho phép bạn kết hợp một vài chức năng thành một loại mới cùng loại. Hãy cùng xem điều này trong hành động bằng cách chỉ định hàm

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

>>>

>>> import os
>>> os.linesep
'\r\n'

Chức năng tùy chỉnh này sử dụng các chức năng một phần để đạt được hiệu ứng mong muốn. Nó có một khái niệm nâng cao mượn từ mô hình lập trình chức năng, vì vậy bây giờ bạn không cần phải đi sâu vào chủ đề đó. Tuy nhiên, nếu bạn quan tâm đến chủ đề này, tôi khuyên bạn nên xem mô -đun

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

Không giống như các câu lệnh, các hàm là giá trị. Điều đó có nghĩa là bạn có thể trộn chúng với các biểu thức, đặc biệt là các biểu thức lambda. Thay vì xác định chức năng toàn diện để thay thế

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

>>> import os
>>> os.linesep
'\r\n'

Tuy nhiên, vì một biểu thức Lambda được xác định tại chỗ, nên không có cách nào để đề cập đến nó ở nơi khác trong mã.

Một loại biểu thức khác là biểu thức điều kiện ternary:

>>>

>>> import os
>>> os.linesep
'\r\n'

Python có cả tuyên bố có điều kiện và biểu thức có điều kiện. Cái sau được đánh giá thành một giá trị duy nhất có thể được gán cho một biến hoặc được truyền đến một hàm. Trong ví dụ trên, bạn có thể quan tâm đến hiệu ứng phụ chứ không phải giá trị, đánh giá thành

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Như bạn có thể thấy, các chức năng cho phép một giải pháp thanh lịch và mở rộng, phù hợp với phần còn lại của ngôn ngữ. Trong tiểu mục tiếp theo, bạn sẽ khám phá ra cách không có

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

74 là một tuyên bố trong Python 2

Một tuyên bố là một hướng dẫn có thể gợi lên một tác dụng phụ khi được thực thi nhưng không bao giờ đánh giá đến một giá trị. Nói cách khác, bạn sẽ không thể in một câu lệnh hoặc gán nó cho một biến như sau:statement is an instruction that may evoke a side-effect when executed but never evaluates to a value. In other words, you wouldn’t be able to print a statement or assign it to a variable like this:

>>> import os
>>> os.linesep
'\r\n'

Đó là một lỗi cú pháp trong Python 2.

Dưới đây là một vài ví dụ nữa về các tuyên bố trong Python:

• Bài tập:

  [[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]
  

  79

  [[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]
  

  79
• Có điều kiện:

  [[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]
  

  80

  [[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]
  

  80
• Vòng lặp:

  [[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]
  

  81

  [[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]
  

  81
• Khẳng định:

  [[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]
  

  82:

  [[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]
  

  82

Các câu lệnh thường bao gồm các từ khóa dành riêng như

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Hơn nữa, bạn có thể in từ các chức năng ẩn danh, bởi vì các câu lệnh được chấp nhận trong các biểu thức Lambda:

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Cú pháp của tuyên bố

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Vào những lúc khác, họ thay đổi cách in thông báo:

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Sự kết hợp chuỗi có thể tăng

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

So sánh điều này với mã tương tự trong Python 3, tận dụng trình tự giải nén:

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Có bất kỳ đối số từ khóa nào cho các nhiệm vụ phổ biến như xả bộ đệm hoặc chuyển hướng luồng. Thay vào đó, bạn cần nhớ cú pháp kỳ quặc. Ngay cả chức năng

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Trailing Newline Remove không hoạt động hoàn toàn đúng, bởi vì nó thêm một không gian không mong muốn. Bạn có thể soạn thảo nhiều câu

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Danh sách các vấn đề tiếp tục. Nếu bạn tò mò, bạn có thể quay trở lại phần trước và tìm kiếm các giải thích chi tiết hơn về cú pháp trong Python 2.

Tuy nhiên, bạn có thể giảm thiểu một số vấn đề với cách tiếp cận đơn giản hơn nhiều. Hóa ra chức năng

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

Để kích hoạt chức năng

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Từ bây giờ tuyên bố

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

Ngoài ra, nó không dành cho bạn việc quản lý mã hóa nhân vật đúng cách.

Ở đây, một ví dụ về việc gọi hàm

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Bây giờ bạn có một ý tưởng về cách in trong Python phát triển và quan trọng nhất là hiểu tại sao những thay đổi không tương thích lạc hậu này là cần thiết. Biết điều này chắc chắn sẽ giúp bạn trở thành một lập trình viên Python tốt hơn.

Các cấu trúc dữ liệu lồng nhau đẹp mắt

Ngôn ngữ máy tính cho phép bạn biểu diễn dữ liệu cũng như mã thực thi theo cách có cấu trúc. Tuy nhiên, không giống như Python, hầu hết các ngôn ngữ đều cho bạn rất nhiều tự do trong việc sử dụng khoảng trắng và định dạng. Điều này có thể hữu ích, ví dụ như trong nén, nhưng đôi khi nó dẫn đến mã không dễ đọc.

In đẹp là về việc tạo ra một phần dữ liệu hoặc mã trông hấp dẫn hơn đối với mắt người để có thể hiểu dễ dàng hơn. Điều này được thực hiện bằng cách thụt các dòng nhất định, chèn các dòng mới, sắp xếp lại các yếu tố, v.v.

Python đi kèm với mô-đun

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Nếu bạn không quan tâm đến việc không có quyền truy cập vào chức năng

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Cá nhân, tôi muốn có cả hai chức năng trong tầm tay, vì vậy tôi đã sử dụng một cái gì đó như

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Thoạt nhìn, có hầu như không có sự khác biệt nào giữa hai chức năng và trong một số trường hợp, hầu như không có: không có gì:

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Điều đó bởi vì

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

r = reprlib.Repr[]
r.maxlist = 4       # max elements displayed for lists
r.maxstring = 10    # max characters displayed for strings

obj = [[1, 2, 3], list[range[10000]], 'looooooong string', 'a', 'b', 'c']

print[r.repr[obj]]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Chức năng áp dụng định dạng hợp lý để cải thiện khả năng đọc, nhưng bạn có thể tùy chỉnh nó hơn nữa với một vài tham số. Ví dụ: bạn có thể giới hạn một hệ thống phân cấp được lồng sâu bằng cách hiển thị dấu chấm lửng dưới một cấp độ nhất định:

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Tuy nhiên,

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Phần tử cuối cùng trong danh sách là cùng một đối tượng với toàn bộ danh sách.

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Từ điển thường đại diện cho dữ liệu JSON, được sử dụng rộng rãi trên Internet. Để nối tiếp chính xác một từ điển thành chuỗi định dạng JSON hợp lệ, bạn có thể tận dụng mô-đun

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Tuy nhiên, lưu ý rằng bạn cần phải tự mình in in, bởi vì nó không phải là thứ mà bạn thường muốn làm. Tương tự, mô -đun

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Đáng ngạc nhiên, chữ ký của

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Thêm màu sắc với trình tự thoát ANSI

Khi máy tính cá nhân trở nên tinh vi hơn, chúng có đồ họa tốt hơn và có thể hiển thị nhiều màu sắc hơn. Tuy nhiên, các nhà cung cấp khác nhau đã có ý tưởng riêng về thiết kế API để kiểm soát nó. Điều đó đã thay đổi một vài thập kỷ trước khi người dân tại Viện Tiêu chuẩn Quốc gia Hoa Kỳ quyết định thống nhất nó bằng cách xác định mã thoát ANSI.

Hầu hết các trình giả lập thiết bị đầu cuối ngày nay hỗ trợ tiêu chuẩn này ở một mức độ nào đó. Cho đến gần đây, hệ điều hành Windows là một ngoại lệ đáng chú ý. Do đó, nếu bạn muốn tính di động tốt nhất, hãy sử dụng thư viện

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Để kiểm tra xem thiết bị đầu cuối của bạn có hiểu một tập hợp con của chuỗi thoát ANSI không, ví dụ, liên quan đến màu sắc, bạn có thể thử sử dụng lệnh sau:

Thiết bị đầu cuối mặc định của tôi trên Linux cho biết nó có thể hiển thị 256 màu riêng biệt, trong khi Xterm chỉ cung cấp cho tôi 8. Lệnh sẽ trả về một số âm nếu màu sắc không được hỗ trợ.

Trình tự thoát ANSI giống như một ngôn ngữ đánh dấu cho thiết bị đầu cuối. Trong HTML, bạn làm việc với các thẻ, chẳng hạn như

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Đúng như tên gọi của nó, một chuỗi phải bắt đầu với ký tự ESC không thể in, có giá trị ASCII là 27, đôi khi được ký hiệu là

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Tuy nhiên, lưu ý rằng bạn cần phải tự mình in in, bởi vì nó không phải là thứ mà bạn thường muốn làm. Tương tự, mô -đun

[[1, 2, 3], [0, 1, 2, 3, ...], 'lo...ing', 'a', ...]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Đáng ngạc nhiên, chữ ký của

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Nhân vật thoát hiểm không thể innumeric code can be one or more numbers separated with a semicolon, while the character code is just one letter. Their specific meaning is defined by the ANSI standard. For example, to reset all formatting, you would type one of the following commands, which use the code zero and the letter

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Mở khung vuông

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Mã số

một hoặc nhiều số được phân tách bằng

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

25

Mã ký tự

Thư viết hoa hoặc chữ thường

Làm thế nào về việc làm một trò chơi rắn retro? Hãy để tạo ra một trình giả lập Snake Python:

Đầu tiên, bạn cần nhập mô -đun

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Lưu ý, hàm phải chấp nhận tham chiếu đến đối tượng màn hình, còn được gọi là

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Nếu bạn chạy chương trình này ngay bây giờ, bạn đã giành được bất kỳ hiệu ứng nào, vì nó chấm dứt ngay lập tức. Tuy nhiên, bạn có thể thêm một độ trễ nhỏ để có một cái nhìn lén:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Lần này, màn hình hoàn toàn trống rỗng trong một giây, nhưng con trỏ vẫn nhấp nháy. Để ẩn nó, chỉ cần gọi một trong các hàm cấu hình được xác định trong mô -đun:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Hãy để xác định con rắn là danh sách các điểm trong tọa độ màn hình:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Đầu của con rắn luôn là yếu tố đầu tiên trong danh sách, trong khi đuôi là phần cuối cùng. Hình dạng ban đầu của con rắn nằm ngang, bắt đầu từ góc trên cùng bên trái của màn hình và hướng sang phải. Trong khi tọa độ y của nó ở lại bằng 0, tọa độ X của nó giảm từ đầu đến đuôi.

Để vẽ con rắn, bạn sẽ bắt đầu với cái đầu và sau đó làm theo các đoạn còn lại. Mỗi phân đoạn mang theo tọa độ

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Một lần nữa, nếu bạn chạy mã này ngay bây giờ, nó đã giành được hiển thị bất cứ thứ gì, bởi vì bạn phải làm mới rõ ràng màn hình sau đó:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Bạn muốn di chuyển con rắn theo một trong bốn hướng, có thể được định nghĩa là vectơ. Cuối cùng, hướng sẽ thay đổi để đáp ứng với một phím kẽ mũi tên, do đó bạn có thể kết nối nó với các mã khóa của thư viện:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Làm thế nào để một con rắn di chuyển? Nó chỉ ra rằng chỉ có đầu của nó thực sự di chuyển đến một vị trí mới, trong khi tất cả các phân khúc khác thay đổi về phía nó. Trong mỗi bước, hầu hết tất cả các phân đoạn vẫn giữ nguyên, ngoại trừ đầu và đuôi. Giả sử con rắn đang phát triển, bạn có thể tháo đuôi và chèn một đầu mới ở đầu danh sách:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Để có được các tọa độ mới của đầu, bạn cần thêm vectơ hướng vào nó. Tuy nhiên, việc thêm các bộ dữ liệu trong Python dẫn đến một tuple lớn hơn thay vì tổng đại số của các thành phần vectơ tương ứng. Một cách để khắc phục điều này là bằng cách sử dụng các hàm

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Hướng sẽ thay đổi trên một phím phím, vì vậy bạn cần gọi

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Tuy nhiên, theo mặc định,

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Bạn gần như đã hoàn thành, nhưng ở đó, chỉ còn một điều cuối cùng. Nếu bây giờ bạn lặp lại mã này, con rắn sẽ dường như đang phát triển thay vì di chuyển. Điều đó bởi vì bạn phải xóa màn hình một cách rõ ràng trước mỗi lần lặp.

Cuối cùng, đây là tất cả những gì bạn cần để chơi trò chơi rắn trong Python:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Điều này chỉ đơn thuần là làm trầy xước bề mặt của các khả năng mà mô -đun

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Sống nó với hình ảnh động tuyệt vời

Hoạt hình không chỉ có thể làm cho giao diện người dùng trở nên hấp dẫn hơn đối với mắt mà còn cải thiện trải nghiệm người dùng tổng thể. Ví dụ, khi bạn cung cấp phản hồi sớm cho người dùng, họ sẽ biết liệu chương trình của bạn có còn hoạt động hay không, nếu thời gian để giết nó.

Để làm động văn bản trong thiết bị đầu cuối, bạn phải có thể tự do di chuyển con trỏ xung quanh. Bạn có thể làm điều này với một trong các công cụ được đề cập trước đây, đó là mã thoát ANSI hoặc thư viện

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Nếu hoạt hình có thể bị hạn chế với một dòng văn bản, thì bạn có thể quan tâm đến hai chuỗi ký tự thoát đặc biệt:

• Trở về vận chuyển:

  [[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]
  

  87

  [[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]
  

  87
• Backspace:

  [[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]
  

  92

  [[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]
  

  92

Cái đầu tiên di chuyển con trỏ sang đầu dòng, trong khi cái thứ hai di chuyển nó chỉ một ký tự sang trái. Cả hai đều làm việc theo cách không phá hủy mà không ghi đè văn bản mà đã được viết.

Hãy cùng xem một vài ví dụ.

Bạn thường muốn hiển thị một số loại bánh xe quay để chỉ ra một công việc đang tiến triển mà không biết chính xác thời gian còn lại để hoàn thành:spinning wheel to indicate a work in progress without knowing exactly how much time’s left to finish:

Nhiều công cụ dòng lệnh sử dụng thủ thuật này trong khi tải xuống dữ liệu qua mạng. Bạn có thể tạo một hình ảnh động chuyển động dừng thực sự đơn giản từ một chuỗi các nhân vật sẽ đạp xe theo kiểu vòng tròn:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Vòng lặp có được ký tự tiếp theo để in, sau đó di chuyển con trỏ sang đầu dòng và ghi đè lên bất cứ thứ gì trước đây mà không cần thêm một dòng mới. Bạn không muốn có thêm không gian giữa các đối số vị trí, vì vậy đối số phân tách phải trống. Ngoài ra, hãy chú ý việc sử dụng các chuỗi thô của Python, do các ký tự dấu gạch chéo ngược có mặt trong nghĩa đen.

Khi bạn biết tỷ lệ phần trăm hoàn thành thời gian hoặc nhiệm vụ còn lại, thì bạn có thể hiển thị một thanh tiến trình hoạt hình:

Đầu tiên, bạn cần tính toán số lượng hashtag để hiển thị và số lượng không gian trống cần chèn. Tiếp theo, bạn xóa dòng và xây dựng thanh từ đầu:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Như trước đây, mỗi yêu cầu để cập nhật lặp lại toàn bộ dòng.

Tạo ra âm thanh với

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

75

Nếu bạn đủ tuổi để nhớ máy tính có loa PC, thì bạn cũng phải nhớ âm thanh tiếng bíp đặc biệt của chúng, thường được sử dụng để chỉ ra các vấn đề về phần cứng. Họ hầu như không thể tạo ra bất kỳ tiếng ồn nào hơn thế, nhưng các trò chơi video có vẻ tốt hơn rất nhiều với nó.

Hôm nay bạn vẫn có thể tận dụng loa nhỏ này, nhưng rất có thể máy tính xách tay của bạn đã không đi kèm với một. Trong trường hợp như vậy, bạn có thể kích hoạt mô phỏng chuông đầu cuối trong vỏ của mình, để phát ra âm thanh cảnh báo hệ thống được phát.terminal bell emulation in your shell, so that a system warning sound is played instead.

Đi trước và nhập lệnh này để xem liệu thiết bị đầu cuối của bạn có thể phát âm thanh không:

Điều này thường sẽ in văn bản, nhưng cờ

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Tương tự, bạn có thể in nhân vật này bằng Python. Có lẽ trong một vòng lặp để tạo thành một số loại giai điệu. Mặc dù nó chỉ có một ghi chú duy nhất, bạn vẫn có thể thay đổi chiều dài tạm dừng giữa các trường hợp liên tiếp. Đó có vẻ như là một món đồ chơi hoàn hảo cho phát lại mã Morse!

Các quy tắc như sau:

• Các chữ cái được mã hóa với một chuỗi các ký hiệu DOT [·] và Dash [ -].dot [·] and dash [–] symbols.
• Một dấu chấm là một đơn vị thời gian.dot is one unit of time.
• Một dấu gạch ngang là ba đơn vị thời gian.dash is three units of time.
• Các biểu tượng riêng lẻ trong một chữ cái cách nhau một đơn vị thời gian.symbols in a letter are spaced one unit of time apart.
• Biểu tượng của hai chữ cái liền kề được đặt cách nhau ba đơn vị thời gian.letters are spaced three units of time apart.
• Biểu tượng của hai từ liền kề được đặt cách nhau bảy đơn vị thời gian.words are spaced seven units of time apart.

Theo các quy tắc đó, bạn có thể là một tín hiệu SOS một tín hiệu vô thời hạn theo cách sau:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Trong Python, bạn có thể thực hiện nó chỉ trong mười dòng mã:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Có lẽ bạn thậm chí có thể tiến thêm một bước và tạo một công cụ dòng lệnh để dịch văn bản thành mã Morse? Dù bằng cách nào, tôi hy vọng bạn có thể vui vẻ với điều này!

Truy tìm

Còn được gọi là gỡ lỗi in hoặc gỡ lỗi Caveman, nó là hình thức gỡ lỗi cơ bản nhất. Mặc dù hơi lỗi thời, nhưng nó vẫn mạnh mẽ và có việc sử dụng.print debugging or caveman debugging, it’s the most basic form of debugging. While a little bit old-fashioned, it’s still powerful and has its uses.

Ý tưởng là đi theo con đường thực hiện chương trình cho đến khi nó dừng đột ngột hoặc đưa ra kết quả không chính xác, để xác định hướng dẫn chính xác với một vấn đề. Bạn làm điều đó bằng cách chèn các câu lệnh in với các từ nổi bật ở những nơi được lựa chọn cẩn thận.

Hãy xem ví dụ này, biểu hiện lỗi làm tròn:

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Như bạn có thể thấy, hàm này không trả về giá trị dự kiến ​​của

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Trong trường hợp này, vấn đề nằm ở cách các số điểm nổi được thể hiện trong bộ nhớ máy tính. Hãy nhớ rằng các con số được lưu trữ ở dạng nhị phân. Giá trị thập phân của

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Để biết thêm thông tin về các số làm tròn trong Python, bạn có thể kiểm tra cách làm tròn số trong Python.

Phương pháp này đơn giản và trực quan và sẽ hoạt động trong hầu hết mọi ngôn ngữ lập trình ngoài kia. Chưa kể, nó là một bài tập tuyệt vời trong quá trình học tập.

Mặt khác, một khi bạn thành thạo các kỹ thuật nâng cao hơn, nó khó có thể quay lại, bởi vì chúng cho phép bạn tìm lỗi nhanh hơn nhiều. Truy tìm là một quá trình thủ công tốn nhiều công sức, có thể cho phép nhiều lỗi hơn nữa. Chu kỳ xây dựng và triển khai cần có thời gian. Sau đó, bạn cần nhớ loại bỏ một cách tỉ mỉ tất cả các cuộc gọi

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Bên cạnh đó, nó đòi hỏi bạn phải thực hiện các thay đổi trong mã, điều này luôn luôn có thể. Có thể bạn đang gỡ lỗi một ứng dụng đang chạy trong một máy chủ web từ xa hoặc muốn chẩn đoán vấn đề theo kiểu sau khi chết. Đôi khi bạn chỉ đơn giản là không có quyền truy cập vào đầu ra tiêu chuẩn.post-mortem fashion. Sometimes you simply don’t have access to the standard output.

Đó chính xác là nơi ghi nhật ký tỏa sáng.

Đăng nhập

Hãy để giả vờ trong một phút rằng bạn đang điều hành một trang web thương mại điện tử. Một ngày nọ, một khách hàng tức giận gọi điện thoại phàn nàn về một giao dịch thất bại và nói rằng anh ta đã mất tiền. Anh ta tuyên bố đã thử mua một vài mặt hàng, nhưng cuối cùng, có một số lỗi khó hiểu đã ngăn anh ta hoàn thành thứ tự đó. Tuy nhiên, khi anh ta kiểm tra tài khoản ngân hàng của mình, tiền đã biến mất.

Bạn xin lỗi chân thành và hoàn lại tiền, nhưng cũng không muốn điều này xảy ra một lần nữa trong tương lai. Làm thế nào để bạn gỡ lỗi điều đó? Nếu chỉ có bạn có một số dấu vết của những gì đã xảy ra, lý tưởng nhất là dưới dạng một danh sách thời gian của các sự kiện với bối cảnh của họ.

Bất cứ khi nào bạn thấy mình đang thực hiện gỡ lỗi in, hãy xem xét biến nó thành các tin nhắn nhật ký vĩnh viễn. Điều này có thể giúp trong các tình huống như thế này, khi bạn cần phân tích một vấn đề sau khi nó xảy ra, trong một môi trường mà bạn không có quyền truy cập.

Có các công cụ tinh vi để tập hợp và tìm kiếm nhật ký, nhưng ở cấp độ cơ bản nhất, bạn có thể nghĩ về nhật ký dưới dạng tệp văn bản. Mỗi dòng truyền tải thông tin chi tiết về một sự kiện trong hệ thống của bạn. Thông thường, nó đã thắng được chứa thông tin nhận dạng cá nhân, mặc dù, trong một số trường hợp, nó có thể được ủy quyền theo luật.

Ở đây, một sự cố của một bản ghi nhật ký điển hình:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Như bạn có thể thấy, nó có một hình thức có cấu trúc. Ngoài một thông điệp mô tả, có một vài trường có thể tùy chỉnh, cung cấp bối cảnh của một sự kiện. Ở đây, bạn có ngày và thời gian chính xác, mức nhật ký, tên logger và tên luồng.

Các cấp độ nhật ký cho phép bạn lọc tin nhắn nhanh chóng để giảm tiếng ồn. Ví dụ, nếu bạn đang tìm kiếm một lỗi, bạn không muốn xem tất cả các cảnh báo hoặc tin nhắn gỡ lỗi. Nó tầm thường để vô hiệu hóa hoặc bật tin nhắn ở một số mức nhật ký nhất định thông qua cấu hình mà không cần chạm vào mã.

Với việc ghi nhật ký, bạn có thể giữ các thông báo gỡ lỗi của mình tách biệt với đầu ra tiêu chuẩn. Tất cả các thông báo nhật ký đi đến luồng lỗi tiêu chuẩn theo mặc định, có thể thuận tiện hiển thị với các màu khác nhau. Tuy nhiên, bạn có thể chuyển hướng tin nhắn nhật ký sang các tệp riêng biệt, ngay cả đối với các mô -đun riêng lẻ!

Khá phổ biến, việc ghi nhật ký bị cấu hình sai có thể dẫn đến việc hết dung lượng trên đĩa máy chủ. Để ngăn chặn điều đó, bạn có thể thiết lập vòng quay nhật ký, sẽ giữ các tệp nhật ký trong một thời lượng được chỉ định, chẳng hạn như một tuần hoặc khi chúng đạt kích thước nhất định. Tuy nhiên, nó luôn luôn là một thực hành tốt để lưu trữ các bản ghi cũ hơn. Một số quy định thực thi rằng dữ liệu khách hàng được lưu giữ trong năm năm!log rotation, which will keep the log files for a specified duration, such as one week, or once they hit a certain size. Nevertheless, it’s always a good practice to archive older logs. Some regulations enforce that customer data be kept for as long as five years!

So với các ngôn ngữ lập trình khác, việc đăng nhập vào Python đơn giản hơn, bởi vì mô -đun

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Bạn có thể gọi các chức năng được xác định ở cấp mô -đun, được nối với bộ ghi gốc, nhưng nhiều thông thường hơn là có được một bộ ghi chuyên dụng cho mỗi tệp nguồn của bạn:root logger, but more the common practice is to obtain a dedicated logger for each of your source files:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Ưu điểm của việc sử dụng logger tùy chỉnh là kiểm soát hạt mịn hơn. Họ thường được đặt tên theo mô -đun mà chúng được xác định thông qua biến

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Một lý do cuối cùng để chuyển từ hàm

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Gỡ lỗi

Sự thật là không theo dõi cũng như ghi nhật ký có thể được coi là gỡ lỗi thực sự. Để thực hiện gỡ lỗi thực tế, bạn cần một công cụ gỡ lỗi, cho phép bạn thực hiện như sau:

• Bước qua mã tương tác.
• Đặt các điểm dừng, bao gồm các điểm dừng có điều kiện.
• Các biến nội tâm trong bộ nhớ.
• Đánh giá các biểu thức tùy chỉnh trong thời gian chạy.

Một trình gỡ lỗi thô thiển chạy trong thiết bị đầu cuối, không có tên là

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

Tuy nhiên, nó không đi kèm với một giao diện đồ họa, vì vậy sử dụng

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Nếu không, bạn có thể thiết lập một điểm dừng trực tiếp trong mã, điều này sẽ tạm dừng việc thực thi tập lệnh của bạn và thả bạn vào trình gỡ lỗi. Cách cũ để làm điều này đòi hỏi hai bước:

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Điều này cho thấy một lời nhắc tương tác, có thể trông đáng sợ lúc đầu. Tuy nhiên, bạn vẫn có thể gõ Python bản địa tại thời điểm này để kiểm tra hoặc sửa đổi trạng thái của các biến cục bộ. Ngoài ra, còn có một số ít các lệnh dành riêng cho trình gỡ lỗi mà bạn muốn sử dụng để bước qua mã.

Vì Python 3.7, bạn cũng có thể gọi hàm

lst = [1, 2, 3]
lst.append[lst]  # oh my!

r = reprlib.Repr[]
r.maxlevel = 5   # max recursion depth

print[r.repr[lst]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Bạn có thể sẽ sử dụng trình gỡ lỗi trực quan được tích hợp với trình chỉnh sửa mã cho hầu hết các phần. Pycharm có một trình gỡ lỗi tuyệt vời, tự hào có hiệu suất cao, nhưng bạn sẽ tìm thấy rất nhiều IDE thay thế với các trình gỡ lỗi, cả được trả tiền và miễn phí.

Gỡ lỗi là một viên đạn bạc tục ngữ. Đôi khi ghi nhật ký hoặc truy tìm sẽ là một giải pháp tốt hơn. Ví dụ, các khiếm khuyết khó sinh sản, chẳng hạn như điều kiện chủng tộc, thường là kết quả của việc ghép thời gian. Khi bạn dừng lại ở điểm dừng, việc tạm dừng nhỏ đó trong việc thực hiện chương trình có thể che giấu vấn đề. Nó giống như nguyên tắc Heisenberg: bạn có thể đo lường và quan sát một lỗi cùng một lúc.

Những phương pháp này không phải là loại trừ lẫn nhau. Họ bổ sung cho nhau.

Built-In

Python đi kèm với một chức năng tích hợp để chấp nhận đầu vào từ người dùng, được dự đoán là

[1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Đó là một lý do khác tại sao bạn có thể không muốn sử dụng chức năng

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Các đối tác in Python

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Đó là một lý do khác tại sao bạn có thể không muốn sử dụng chức năng

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Các đối tác in Python

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Đó là một lý do khác tại sao bạn có thể không muốn sử dụng chức năng

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

>>>

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Đó là một lý do khác tại sao bạn có thể không muốn sử dụng chức năng

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Third-Party

Các đối tác in Python

• Đến bây giờ, bạn biết rất nhiều điều cần biết về

  [[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]
  

  75! Tuy nhiên, chủ đề này sẽ hoàn thành mà không nói về các đối tác của nó một chút. Trong khi

  [[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]
  

  75 là về đầu ra, có các chức năng và thư viện cho đầu vào.
• Python đi kèm với một chức năng tích hợp để chấp nhận đầu vào từ người dùng, được dự đoán là

  [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]
  

  13. Nó chấp nhận dữ liệu từ luồng đầu vào tiêu chuẩn, thường là bàn phím:
• Chức năng luôn trả về một chuỗi, vì vậy bạn có thể cần phải phân tích nó phù hợp:
• Tham số nhắc nhở hoàn toàn tùy chọn, vì vậy sẽ không có gì hiển thị nếu bạn bỏ qua nó, nhưng chức năng vẫn sẽ hoạt động:
• Tuy nhiên, việc ném vào một cuộc gọi hành động mô tả làm cho trải nghiệm người dùng tốt hơn rất nhiều.
• Yêu cầu người dùng về mật khẩu với

  [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]
  

  13 là một ý tưởng tồi vì nó sẽ hiển thị trong bản rõ khi họ gõ nó. Trong trường hợp này, bạn nên sử dụng chức năng

  [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]
  

  15 thay thế, mặt nạ gõ các ký tự. Hàm này được xác định trong một mô -đun dưới cùng tên, cũng có sẵn trong thư viện tiêu chuẩn:
• Mô -đun

  [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]
  

  16 có một chức năng khác để lấy tên người dùng từ một biến môi trường:
• Các chức năng tích hợp trong các chức năng tích hợp của Python để xử lý đầu vào tiêu chuẩn khá hạn chế. Đồng thời, có rất nhiều gói của bên thứ ba, cung cấp các công cụ tinh vi hơn nhiều.

Có các gói Python bên ngoài ngoài kia cho phép xây dựng các giao diện đồ họa phức tạp đặc biệt để thu thập dữ liệu từ người dùng. Một số tính năng của họ bao gồm:

• [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]
  

  17

• [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]
  

  18

• [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]
  

  19

• [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]
  

  20

Định dạng và kiểu dáng nâng cao

Tự động phân tích cú pháp, xác thực và vệ sinh dữ liệu người dùng

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Một phong cách khai báo xác định bố cục

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Tương tác tự động hoàn thànhLeft arrow, for example, results in this instead of moving the cursor back:

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Bây giờ, bạn có thể bọc cùng một tập lệnh với lệnh

[1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]

[[1, 2, 3], [0, 1, 2, 3, 4, 5, ...]]

Có phải là tuyệt vời không?