Kết thúc trăn trở

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

The simplest example of using Python

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

>>>

>>> print()

You don’t pass any arguments, but you still need to put empty parentheses at the end, which tell Python to actually execute the function rather than just refer to it by name

This will produce an invisible newline character, which in turn will cause a blank line to appear on your screen. You can call

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

Newline CharacterShow/Hide

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

The word “character” is somewhat of a misnomer in this case, because a newline is often more than one character long. For example, the Windows operating system, as well as the HTTP protocol, represent newlines with a pair of characters. Sometimes you need to take those differences into account to design truly portable programs

To find out what constitutes a newline in your operating system, use Python’s built-in

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

This will immediately tell you that Windows and DOS represent the newline as a sequence of

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

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

>>>

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

On Unix, Linux, and recent versions of macOS, it’s a single

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

>>>

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

The classic Mac OS X, however, sticks to its own “think different” philosophy by choosing yet another representation

>>>

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

Notice how these characters appear in string literals. They use special syntax with a preceding backslash (

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

Most programming languages come with a predefined set of escape sequences for special characters such as these

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

  12. backslash

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

  13. backspace

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

  14. tab

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

  08. carriage return (CR)

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

  09. newline, also known as line feed (LF)

The last two are reminiscent of mechanical typewriters, which required two separate commands to insert a newline. The first command would move the carriage back to the beginning of the current line, while the second one would advance the roll to the next line

By comparing the corresponding ASCII character codes, you’ll see that putting a backslash in front of a character changes its meaning completely. However, not all characters allow for this–only the special ones

To compare ASCII character codes, you may want to use the built-in

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

>>>

>>> ord('r')
114
>>> ord('\r')
13

Keep in mind that, in order to form a correct escape sequence, there must be no space between the backslash character and a letter

As you just saw, calling

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

You can use Python’s string literals to visualize these two

'\n'  # Blank line
''    # Empty line

The first one is one character long, whereas the second one has no content

Note. To remove the newline character from a string in Python, use its

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

>>>

>>> 'A line of text.\n'.rstrip()
'A line of text.'

This strips any trailing whitespace from the right edge of the string of characters

In a more common scenario, you’d want to communicate some message to the end user. There are a few ways to achieve this

First, you may pass a string literal directly to

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

>>>

>>> print('Please wait while the program is loading...')

This will print the message verbatim onto the screen

String LiteralsShow/Hide

String literals in Python can be enclosed either in single quotes (

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

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

For example, you can’t use double quotes for the literal and also include double quotes inside of it, because that’s ambiguous for the Python interpreter

"My favorite book is "Python Tricks""  # Wrong!

What you want to do is enclose the text, which contains double quotes, within single quotes

'My favorite book is "Python Tricks"'

The same trick would work the other way around

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

Alternatively, you could use escape character sequences mentioned earlier, to make Python treat those internal double quotes literally as part of the string literal

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

Escaping is fine and dandy, but it can sometimes get in the way. Specifically, when you need your string to contain relatively many backslash characters in literal form

One classic example is a file path on Windows

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

Notice how each backslash character needs to be escaped with yet another backslash

This is even more prominent with regular expressions, which quickly get convoluted due to the heavy use of special characters

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

May mắn thay, bạn có thể tắt hoàn toàn thoát ký tự với sự trợ giúp của chuỗi ký tự thô. Đơn giản chỉ cần thêm một

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

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

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

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

Có một vài tiền tố nữa mang ý nghĩa đặc biệt cho chuỗi ký tự trong Python, nhưng bạn sẽ không tìm hiểu về chúng ở đây

Cuối cùng, bạn có thể xác định các chuỗi ký tự nhiều dòng bằng cách đặt chúng trong khoảng từ

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

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

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

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

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

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

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

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

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

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

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

>>>

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

Điều này sẽ xử lý các đoạn không liên kết cho bạn. Ngoài ra còn có một số chức năng hữu ích khác trong

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

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

>>>

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

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

>>>

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

Trên thực tế, có hàng chục cách để định dạng thư trong Python. Tôi thực sự khuyến khích bạn xem f-strings, được giới thiệu trong Python 3. 6, bởi vì chúng cung cấp cú pháp ngắn gọn nhất trong số chúng

>>>

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

Hơn nữa, f-strings sẽ giúp bạn tránh mắc một lỗi phổ biến, đó là quên gõ các toán hạng nối kiểu ép kiểu. Python là một ngôn ngữ được gõ mạnh, có nghĩa là nó sẽ không cho phép bạn làm điều này

>>>

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

Điều đó sai vì thêm số vào chuỗi không có nghĩa. Trước tiên, bạn cần chuyển đổi rõ ràng số thành chuỗi để nối chúng lại với nhau

>>>

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

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ề sự cố bằng cách hiển thị truy nguyên

Ghi chú.

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

Bạn có thể gọi nó trực tiếp trên bất kỳ đối tượng nào, ví dụ: một số

>>>

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

Các kiểu dữ liệu dựng sẵn có sẵn một biểu diễn chuỗi được xác định trước, nhưng ở phần sau của bài viết này, bạn sẽ tìm hiểu cách cung cấp một biểu diễn cho các lớp tùy chỉnh của mình

Như với bất kỳ chức năng nào, việc bạn truyền một ký tự, một biến hay một biểu thức không quan trọng. Tuy nhiên, không giống như nhiều chức năng khác,

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

Cho đến nay, bạn chỉ nhìn vào chuỗi, còn các kiểu dữ liệu khác thì sao?

>>>

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

Tuy nhiên, hãy coi chừng hằng số

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

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

>>>

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

Làm thế nào để

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

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

Ở phần sau của 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, chẳng hạn như các lớp của bạn

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

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

Cú pháp trong Python 2Hiển thị/Ẩn

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

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

Đó là bởi vì hồi đó

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

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

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

>>>

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

Dấu ngoặc 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

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

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

>>>

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

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

>>>

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

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

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

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

Tách nhiều đối số

Bạn thấy

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

Tuy nhiên, hóa ra hàm này có thể chấp nhận bất kỳ số lượng đối số vị trí nào, bao gồm không, một hoặc nhiều đối số. Điều đó rất hữu ích trong trường hợp phổ biến về định dạng thư, nơi bạn muốn kết hợp một số thành phần lại với nhau

Đối số vị tríHiển thị/Ẩn

Các đối số có thể được chuyển đến một chức năng theo một số cách. One way is by explicitly naming the arguments when you’re calling the function, like this

>>>

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

Since arguments can be uniquely identified by name, their order doesn’t matter. Swapping them out will still give the same result

>>>

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

Conversely, arguments passed without names are identified by their position. That’s why positional arguments need to follow strictly the order imposed by the function signature

>>>

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

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

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

Hãy xem ví dụ này

>>>

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

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

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

Lưu ý rằng nó cũng quan tâm đến việc truyền kiểu thích hợp bằng cách gọi ngầm

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

>>>

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

Ngoài việc chấp nhận một số lượng đối số vị trí khác nhau,

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

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

Bây giờ hãy tập trung vào

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

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

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

>>>

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

Nếu bạn muốn loại bỏ hoàn toàn dấu phân cách, thay vào đó, bạn phải chuyển một chuỗi trống (

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

>>>

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

Bạn có thể muốn

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

>>>

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

Một ví dụ hữu ích hơn về tham số

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

>>>

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

Hãy nhớ rằng dấu phân cách nằm giữa các phần tử chứ không phải xung quanh chúng, vì vậy bạn cần tính đến điều đó theo cách này hay cách khác

>>>

>>> ord('r')
114
>>> ord('\r')
13

Cụ thể, bạn có thể chèn một ký tự gạch chéo (

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

Ghi chú. Hãy cẩn thận về việc tham gia các phần tử của danh sách hoặc bộ dữ liệu

Thực hiện thủ công sẽ dẫn đến kết quả nổi tiếng

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

>>>

>>> ord('r')
114
>>> ord('\r')
13

Sẽ an toàn hơn nếu chỉ giải nén trình tự bằng toán tử dấu sao (

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

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

>>>

>>> ord('r')
114
>>> ord('\r')
13

Việc giải nén thực sự giống như gọi

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

Một ví dụ thú vị khác có thể là xuất dữ liệu sang định dạng giá trị được phân tách bằng dấu phẩy (CSV)

>>>

>>> ord('r')
114
>>> ord('\r')
13

Điều này sẽ không xử lý các trường hợp cạnh như thoát dấu phẩy một cách chính xác, nhưng đối với các trường hợp sử dụng đơn giản, nó nên làm. Dòng trên sẽ hiển thị trong cửa sổ đầu cuối của bạn. Để lưu nó vào một tệp, bạn phải chuyển hướng đầu ra. Ở phần sau của phần này, bạn sẽ thấy cách sử dụng

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

Cuối cùng, tham số

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

>>>

>>> ord('r')
114
>>> ord('\r')
13

Trong các phần phụ 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

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

Cú pháp trong Python 2Hiển thị/Ẩn

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

>>>

>>> ord('r')
114
>>> ord('\r')
13

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

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

>>>

>>> ord('r')
114
>>> ord('\r')
13

Hơn nữa, không có cách nào thay đổi dấu tách mặc định của các phần tử đã nối trong Python 2, vì vậy một cách giải quyết khác là sử dụng phép nội suy chuỗi như vậy

>>>

>>> ord('r')
114
>>> ord('\r')
13

Đó là cách định dạng chuỗi mặc định cho đến khi phương thức

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

Ngăn Ngắt Dòng

Đôi khi bạn không muốn kết thúc tin nhắn của mình bằng một dòng mới ở cuối để các cuộc gọi tiếp theo tới

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

>>> ord('r')
114
>>> ord('\r')
13

Nhiều ngôn ngữ lập trình hiển thị các hàm tương tự như

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

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

Dưới đây là một vài ví dụ về cú pháp trong các ngôn ngữ như vậy

LanguageExamplePerl

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

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

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

Ngược lại, hàm

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

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

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

Về mặt ngữ nghĩa, tham số

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

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

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

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

  32
• Nó có thể dài tùy ý
• Nó có giá trị mặc định là

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

  78
• Nếu bằng

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

  32, nó sẽ có tác dụng giống như giá trị mặc định
• Nếu bằng một chuỗi rỗng (

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

  53), nó sẽ chặn dòng mới

Bây giờ bạn đã hiểu điều gì đang xảy ra bí ẩn khi bạn gọi điện cho

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

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

Ghi chú. Bạn có thể thắc mắc tại sao tham số

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

Chà, bạn không phải lo lắng về việc biểu diễn dòng mới trên các hệ điều hành khác nhau khi in, vì

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

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

Đây hiện là cách di động nhất để in một ký tự dòng mới trong Python

>>>

>>> ord('r')
114
>>> ord('\r')
13

Ví dụ: nếu bạn cố gắng in mạnh một ký tự dòng mới dành riêng cho Windows trên máy Linux, thì kết quả đầu ra của bạn sẽ bị hỏng

>>>

'\n'  # Blank line
''    # Empty line

Mặt khác, khi bạn mở một tệp để đọc bằng

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

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

Để 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

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

'\n'  # Blank line
''    # Empty line

Mặc dù đây là hai lệnh gọi

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

'\n'  # Blank line
''    # Empty line

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

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

'\n'  # Blank line
''    # Empty line

Như với

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

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

'\n'  # Blank line
''    # Empty line

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

'\n'  # Blank line
''    # Empty line

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

'\n'  # Blank line
''    # Empty line

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

'\n'  # Blank line
''    # Empty line

Không có gì ngăn bạn sử dụng ký tự xuống dòng với một số phần đệm bổ sung xung quanh nó

'\n'  # Blank line
''    # Empty line

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

'\n'  # Blank line
''    # Empty line

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

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

Ghi chú. Vòng lặp qua các dòng trong tệp văn bản giữ nguyên các ký tự dòng mới của riêng chúng, kết hợp với hành vi mặc định của hàm

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

>>>

>>> 'A line of text.\n'.rstrip()
'A line of text.'

Có hai dòng mới sau mỗi dòng văn bản. Bạn muốn loại bỏ một trong số chúng, như được hiển thị trước đó trong bài viết này, trước khi in dòng

>>> 'A line of text.\n'.rstrip()
'A line of text.'

Ngoài ra, bạn có thể giữ dòng mới trong nội dung nhưng tự động loại bỏ dòng được thêm vào bởi

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

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

>>>

>>> 'A line of text.\n'.rstrip()
'A line of text.'

Bằng cách kết thúc một dòng bằng một chuỗi trống, bạn vô hiệu hóa hiệu quả một trong các dòng mới

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

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

Cú pháp trong Python 2Hiển thị/Ẩn

Ngăn ngắt dòng trong Python 2 yêu cầu bạn thêm dấu phẩy ở cuối vào biểu thức

>>> 'A line of text.\n'.rstrip()
'A line of text.'

Tuy nhiên, điều đó không lý tưởng vì nó cũng thêm một khoảng trống không mong muốn, điều này sẽ chuyển thành

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

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

>>> 'A line of text.\n'.rstrip()
'A line of text.'

Lưu ý rằng có một khoảng trống giữa các từ

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

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

>>> 'A line of text.\n'.rstrip()
'A line of text.'

Để có được kết quả như mong đợi, bạn cần sử dụng một trong những thủ thuật được giải thích sau, đó là nhập hàm

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

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

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

>>> 'A line of text.\n'.rstrip()
'A line of text.'

Điều này sẽ in đầu ra chính xác mà không cần thêm dung lượng

>>> 'A line of text.\n'.rstrip()
'A line of text.'

Trong khi sử dụng mô-đun

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

In ra một tập tin

Tin hay không tùy bạn,

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

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

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

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

   08. đầu vào tiêu chuẩn

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

   09. đầu ra tiêu chuẩn

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

   10. lỗi tiêu chuẩn

Luồng chuẩnHiển thị/Ẩn

Standard output is what you see in the terminal when you run various command-line programs including your own Python scripts

>>> 'A line of text.\n'.rstrip()
'A line of text.'

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

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

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

>>> 'A line of text.\n'.rstrip()
'A line of text.'

Đó gọi là chuyển hướng luồng

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

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

Note. To redirect

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

They’re arbitrary, albeit constant, numbers associated with standard streams. Below, you’ll find a summary of the file descriptors for a family of POSIX-compliant operating systems

StreamFile Descriptor

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

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

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

Knowing those descriptors allows you to redirect one or more streams at a time

CommandDescription

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

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

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

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

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

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

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

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

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

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

Note that

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

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

Some programs use different coloring to distinguish between messages printed to

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

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

While both

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

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

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

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

In Python, you can access all standard streams through the built-in

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

>>>

>>> print('Please wait while the program is loading...')

As you can see, these predefined values resemble file-like objects with

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

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

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

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

By default,

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

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

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

>>> print('Please wait while the program is loading...')

This will make your code immune to stream redirection at the operating system level, which might or might not be desired

For more information on working with files in Python, you can check out Reading and Writing Files in Python (Guide)

Note. Don’t try using

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

Just call the binary file’s

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

>>> print('Please wait while the program is loading...')

If you wanted to write raw bytes on the standard output, then this will fail too because

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

>>>

>>> print('Please wait while the program is loading...')

You must dig deeper to get a handle of the underlying byte stream instead

>>>

>>> print('Please wait while the program is loading...')

This prints an uppercase letter

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

Note that

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

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

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

>>> print('Please wait while the program is loading...')

Instead of a real file existing somewhere in your file system, you can provide a fake one, which would reside in your computer’s memory. You’ll use this technique later for mocking

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

>>>

>>> print('Please wait while the program is loading...')

If you got to this point, then you’re left with only one keyword argument in

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

Cú pháp trong Python 2Hiển thị/Ẩn

There’s a special syntax in Python 2 for replacing the default

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

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

>>> print('Please wait while the program is loading...')

Because strings and bytes are represented with the same

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

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

>>> print('Please wait while the program is loading...')

Although, there’s a problem with character encoding. Hàm

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

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

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

>>>

>>> print('Please wait while the program is loading...')

Notice how non-Latin characters must be escaped in both Unicode and string literals to avoid a syntax error. Take a look at this example

"My favorite book is "Python Tricks""  # Wrong!

Alternatively, you could specify source code encoding according to PEP 263 at the top of the file, but that wasn’t the best practice due to portability issues

"My favorite book is "Python Tricks""  # Wrong!

Your best bet is to encode the Unicode string just before printing it. You can do this manually

"My favorite book is "Python Tricks""  # Wrong!

However, a more convenient option is to use the built-in

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

"My favorite book is "Python Tricks""  # Wrong!

It’ll take care of making appropriate conversions when you need to read or write files

Buffering >>> import os >>> os.linesep '\r\n' 94 Calls

In the previous subsection, you learned that

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

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

Imagine you were writing a countdown timer, which should append the remaining time to the same line every second

"My favorite book is "Python Tricks""  # Wrong!

Your first attempt may look something like this

"My favorite book is "Python Tricks""  # Wrong!

As long as the

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

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

Unexpectedly, instead of counting down every second, the program idles wastefully for three seconds, and then suddenly prints the entire line at once

That’s because the operating system buffers subsequent writes to the standard output in this case. You need to know that there are three kinds of streams with respect to buffering

1. Unbuffered
2. Line-buffered
3. Block-buffered

Unbuffered 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

Buffering helps to reduce the number of expensive I/O calls. Think about sending messages over a high-latency network, for example. When you connect to a remote server to execute commands over the SSH protocol, each of your keystrokes may actually produce an individual data packet, which is orders of magnitude bigger than its payload. What an overhead. It would make sense to wait until at least a few characters are typed and then send them together. That’s where buffering steps in

On the other hand, buffering can sometimes have undesired effects as you just saw with the countdown example. To fix it, you can simply tell

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

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

"My favorite book is "Python Tricks""  # Wrong!

That’s all. Your countdown should work as expected now, but don’t take my word for it. Go ahead and test it to see the difference

Congratulations. At this point, you’ve seen examples of calling

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

Cú pháp trong Python 2Hiển thị/Ẩn

There isn’t an easy way to flush the stream in Python 2, because the

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

"My favorite book is "Python Tricks""  # Wrong!

Alternatively, you could disable buffering of the standard streams either by providing the

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

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

"My favorite book is "Python Tricks""  # Wrong!

Note that

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

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

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

>>>

"My favorite book is "Python Tricks""  # Wrong!

What you’re seeing here is a docstring of the

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

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

Printing Custom Data Types

Up until now, you only dealt with built-in data types such as strings and numbers, but you’ll often want to print your own abstract data types. Let’s have a look at different ways of defining them

For simple objects without any logic, whose purpose is to carry data, you’ll typically take advantage of

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

>>>

'My favorite book is "Python Tricks"'

Điều đó thật tuyệt miễn là giữ dữ liệu là đủ, nhưng để thêm các hành vi vào loại

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

'My favorite book is "Python Tricks"'

If you now create an instance of the

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

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

>>>

'My favorite book is "Python Tricks"'

It’s the default representation of objects, which comprises their address in memory, the corresponding class name and a module in which they were defined. You’ll fix that in a bit, but just for the record, as a quick workaround you could combine

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

'My favorite book is "Python Tricks"'

Your

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

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

Note. In Python 3, the

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

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

'My favorite book is "Python Tricks"'

This prevents the interpreter from raising

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

That’s better than a plain

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

It’s true that designing immutable data types is desirable, but in many cases, you’ll want them to allow for change, so you’re back with regular classes again

Note. Following other languages and frameworks, Python 3. 7 introduced data classes, which you can think of as mutable tuples. This way, you get the best of both worlds

>>>

'My favorite book is "Python Tricks"'

Cú pháp cho các chú thích biến, được yêu cầu để chỉ định các trường lớp với các loại tương ứng của chúng, đã được định nghĩa trong Python 3. 6

From earlier subsections, you already know that

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

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

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

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

>>>

'My favorite book is "Python Tricks"'

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

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

   93

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

   94

The first one is recommended to return a short, human-readable text, which includes information from the most relevant attributes. After all, you don’t want to expose sensitive data, such as user passwords, when printing objects

However, the other one should provide complete information about an object, to allow for restoring its state from a string. Ideally, it should return valid Python code, so that you can pass it directly to

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

>>>

'My favorite book is "Python Tricks"'

Notice the use of another built-in function,

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

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

Note. Even though

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

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

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

Consider this class with both magic methods, which return alternative string representations of the same object

'My favorite book is "Python Tricks"'

If you print a single object of the

>>> ord('r')
114
>>> ord('\r')
13

>>> ord('r')
114
>>> ord('\r')
13

>>> ord('r')
114
>>> ord('\r')
13

>>> ord('r')
114
>>> ord('\r')
13

>>>

'My favorite book is "Python Tricks"'

However, if you put the same

>>> ord('r')
114
>>> ord('\r')
13

>>>

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

That’s because sequences, such as lists and tuples, implement their

>>> ord('r')
114
>>> ord('\r')
13

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

Python gives you a lot of freedom when it comes to defining your own data types if none of the built-in ones meet your needs. Some of them, such as named tuples and data classes, offer string representations that look good without requiring any work on your part. Still, for the most flexibility, you’ll have to define a class and override its magic methods described above

Cú pháp trong Python 2Hiển thị/Ẩn

The semantics of

>>> ord('r')
114
>>> ord('\r')
13

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

>>> ord('r')
114
>>> ord('\r')
13

Here’s an example of the same

>>> ord('r')
114
>>> ord('\r')
13

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

As you can see, this implementation delegates some work to avoid duplication by calling the built-in

>>> ord('r')
114
>>> ord('\r')
13

Both

>>> ord('r')
114
>>> ord('\r')
13

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

>>> ord('r')
114
>>> ord('\r')
13

>>> ord('r')
114
>>> ord('\r')
13

>>> ord('r')
114
>>> ord('\r')
13

The

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

>>> ord('r')
114
>>> ord('\r')
13

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

>>>

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

However, if you ran the same code on a system with UTF-8 encoding, then you’d get the proper spelling of a popular Russian name

>>>

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

It’s recommended to convert strings to Unicode as early as possible, for example, when you’re reading data from a file, and use it consistently everywhere in your code. At the same time, you should encode Unicode back to the chosen character set right before presenting it to the user

It seems as if you have more control over string representation of objects in Python 2 because there’s no magic

>>> ord('r')
114
>>> ord('\r')
13

>>> ord('r')
114
>>> ord('\r')
13

>>>

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

Using the built-in

>>> ord('r')
114
>>> ord('\r')
13

>>> ord('r')
114
>>> ord('\r')
13

In là một chức năng trong Python 3

You’ve seen that

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

>>>

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

It’s always available in the global namespace so that you can call it directly, but you can also access it through a module from the standard library

>>>

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

This way, you can avoid name collisions with custom functions. Let’s say you wanted to redefine

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

>>> ord('r')
114
>>> ord('\r')
13

>>>

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

Now you have two separate printing functions just like in the Java programming language. You’ll define custom

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

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

On the other hand,

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

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

>>>

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

Such functions are, in fact, procedures or subroutines that you call to achieve some kind of side-effect, which ultimately is a change of a global state. In the case of

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

Because

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

Besides, functions are easier to 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

Another benefit of

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

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

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

Here, the

>>> ord('r')
114
>>> ord('\r')
13

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

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

Note. A dependency is any piece of code required by another bit of code

Dependency injection is a technique used in code design to make it more testable, reusable, and open for extension. You can achieve it by referring to dependencies indirectly through abstract interfaces and by providing them in a push rather than pull fashion

There’s a funny explanation of dependency injection circulating on the Internet

Dependency injection for five-year-olds

When you go and get things out of the refrigerator for yourself, you can cause problems. You might leave the door open, you might get something Mommy or Daddy doesn’t want you to have. You might even be looking for something we don’t even have or which has expired

What you should be doing is stating a need, “I need something to drink with lunch,” and then we will make sure you have something when you sit down to eat

— John Munsch, 28 October 2009. (Source)

Composition allows you to combine a few functions into a new one of the same kind. Let’s see this in action by specifying a custom

>>> ord('r')
114
>>> ord('\r')
13

>>>

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

This custom function uses partial functions to achieve the desired effect. It’s an advanced concept borrowed from the functional programming paradigm, so you don’t need to go too deep into that topic for now. However, if you’re interested in this topic, I recommend taking a look at the

>>> ord('r')
114
>>> ord('\r')
13

Unlike statements, functions are values. That means you can mix them with expressions, in particular, lambda expressions. Instead of defining a full-blown function to replace

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

>>>

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

However, because a lambda expression is defined in place, there’s no way of referring to it elsewhere in the code

Note. In Python, you can’t put statements, such as assignments, conditional statements, loops, and so on, in an anonymous lambda function. It has to be a single expression

Another kind of expression is a ternary conditional expression

>>>

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

Python has both conditional statements and . The latter is evaluated to a single value that can be assigned to a variable or passed to a function. In the example above, you’re interested in the side-effect rather than the value, which evaluates to

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

As you can see, functions allow for an elegant and extensible solution, which is consistent with the rest of the language. In the next subsection, you’ll discover how not having

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

>>> import os >>> os.linesep '\n' 02 Was a Statement in Python 2

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

That’s a syntax error in Python 2

Here are a few more examples of statements in Python

• assignment.

  >>> ord('r')
  114
  >>> ord('\r')
  13
  

  47
• conditional.

  >>> ord('r')
  114
  >>> ord('\r')
  13
  

  48
• vòng.

  >>> ord('r')
  114
  >>> ord('\r')
  13
  

  49
• assertion.

  >>> ord('r')
  114
  >>> ord('\r')
  13
  

  50

Note. Python 3. 8 brings a controversial walrus operator (

>>> ord('r')
114
>>> ord('\r')
13

Take a look at this example, which calls an expensive function once and then reuses the result for further computation

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

This is useful for simplifying the code without losing its efficiency. Typically, performant code tends to be more verbose

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

The controversy behind this new piece of syntax caused a lot of argument. An abundance of negative comments and heated debates eventually led Guido van Rossum to step down from the Benevolent Dictator For Life or BDFL position

Statements are usually comprised of reserved keywords such as

>>> ord('r')
114
>>> ord('\r')
13

>>> ord('r')
114
>>> ord('\r')
13

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

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

Ngoài ra, bạn không thể in từ các hàm ẩn danh vì các câu lệnh không được chấp nhận trong các biểu thức lambda

>>>

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

The syntax of the

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

>>>

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

At other times they change how the message is printed

>>>

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

String concatenation can raise a

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

>>>

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

Compare this with similar code in Python 3, which leverages sequence unpacking

>>>

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

Không có bất kỳ đối số từ khóa nào cho các tác vụ phổ biến như xóa bộ đệm hoặc chuyển hướng luồng. You need to remember the quirky syntax instead. Ngay cả hàm

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

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

>>>

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

Loại bỏ dòng mới ở cuối không hoạt động hoàn toàn đúng vì nó thêm một khoảng trống không mong muốn. You can’t compose multiple

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

The list of problems goes on and on. If you’re curious, you can jump back to the and look for more detailed explanations of the syntax in Python 2

However, you can mitigate some of those problems with a much simpler approach. It turns out the

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

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

Note. You may import future functions as well as baked-in language constructs such as the

>>> ord('r')
114
>>> ord('\r')
13

To find out exactly what features are available to you, inspect the module

>>>

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

You could also call

>>> ord('r')
114
>>> ord('\r')
13

To enable the

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

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

From now on the

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

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

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

Other than that, it doesn’t spare you from managing character encodings properly

Here’s an example of calling the

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

>>>

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

You now have an idea of how printing in Python evolved and, most importantly, understand why these backward-incompatible changes were necessary. Knowing this will surely help you become a better Python programmer

Pretty-Printing Nested Data Structures

Computer languages allow you to represent data as well as executable code in a structured way. Unlike Python, however, most languages give you a lot of freedom in using whitespace and formatting. This can be useful, for example in compression, but it sometimes leads to less readable code

Pretty-printing is about making a piece of data or code look more appealing to the human eye so that it can be understood more easily. This is done by indenting certain lines, inserting newlines, reordering elements, and so forth

Python comes with the

>>> ord('r')
114
>>> ord('\r')
13

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

Note. To toggle pretty printing in IPython, issue the following command

>>>

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

Đây là một ví dụ về Phép thuật trong IPython. There are a lot of built-in commands that start with a percent sign (

>>> ord('r')
114
>>> ord('\r')
13

If you don’t care about not having access to the original

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

>>> ord('r')
114
>>> ord('\r')
13

>>>

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

Personally, I like to have both functions at my fingertips, so I’d rather use something like

>>> ord('r')
114
>>> ord('\r')
13

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

At first glance, there’s hardly any difference between the two functions, and in some cases there’s virtually none

>>>

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

That’s because

>>> ord('r')
114
>>> ord('\r')
13

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

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

>>>

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

The function applies reasonable formatting to improve readability, but you can customize it even further with a couple of parameters. For example, you may limit a deeply nested hierarchy by showing an ellipsis below a given level

>>>

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

The ordinary

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

>>>

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

However,

>>> ord('r')
114
>>> ord('\r')
13

>>>

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

The last element in the list is the same object as the entire list

Note. Recursive or very large data sets can be dealt with using the

>>> ord('r')
114
>>> ord('\r')
13

>>>

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

This module supports most of the built-in types and is used by the Python debugger

>>> ord('r')
114
>>> ord('\r')
13

Dictionaries often represent JSON data, which is widely used on the Internet. To correctly serialize a dictionary into a valid JSON-formatted string, you can take advantage of the

>>> ord('r')
114
>>> ord('\r')
13

>>>

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

Notice, however, that you need to handle printing yourself, because it’s not something you’d typically want to do. Similarly, the

>>> ord('r')
114
>>> ord('\r')
13

>>> ord('r')
114
>>> ord('\r')
13

Surprisingly, the signature of

>>> ord('r')
114
>>> ord('\r')
13

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

Adding Colors With ANSI Escape Sequences

As personal computers got more sophisticated, they had better graphics and could display more colors. However, different vendors had their own idea about the API design for controlling it. That changed a few decades ago when people at the American National Standards Institute decided to unify it by defining ANSI escape codes

Most of today’s terminal emulators support this standard to some degree. Until recently, the Windows operating system was a notable exception. Therefore, if you want the best portability, use the

>>> ord('r')
114
>>> ord('\r')
13

To check if your terminal understands a subset of the ANSI escape sequences, for example, related to colors, you can try using the following command

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

My default terminal on Linux says it can display 256 distinct colors, while xterm gives me only 8. The command would return a negative number if colors were unsupported

ANSI escape sequences are like a markup language for the terminal. In HTML you work with tags, such as

>>> ord('r')
114
>>> ord('\r')
13

>>> ord('r')
114
>>> ord('\r')
13

As its name implies, a sequence must begin with the non-printable Esc character, whose ASCII value is 27, sometimes denoted as

>>> ord('r')
114
>>> ord('\r')
13

>>> ord('r')
114
>>> ord('\r')
13

>>>

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

Additionally, you can obtain it with the

>>> ord('r')
114
>>> ord('\r')
13

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

The most common ANSI escape sequences take the following form

ElementDescriptionExample Esc non-printable escape character

>>> ord('r')
114
>>> ord('\r')
13

>>> ord('r')
114
>>> ord('\r')
13

>>> ord('r')
114
>>> ord('\r')
13

>>> ord('r')
114
>>> ord('\r')
13

>>> ord('r')
114
>>> ord('\r')
13

>>> ord('r')
114
>>> ord('\r')
13

The numeric 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

>>> ord('r')
114
>>> ord('\r')
13

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

At the other end of the spectrum, you have compound code values. To set foreground and background with RGB channels, given that your terminal supports 24-bit depth, you could provide multiple numbers

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

It’s not just text color that you can set with the ANSI escape codes. You can, for example, clear and scroll the terminal window, change its background, move the cursor around, make the text blink or decorate it with an underline

In Python, you’d probably write a helper function to allow for wrapping arbitrary codes into a sequence

>>>

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

This would make the word

'\n'  # Blank line
''    # Empty line

However, there are higher-level abstractions over ANSI escape codes, such as the mentioned

>>> ord('r')
114
>>> ord('\r')
13

Building Console User Interfaces

Mặc dù không thể phủ nhận việc chơi với các mã thoát ANSI rất thú vị, nhưng trong thế giới thực, bạn muốn có nhiều khối xây dựng trừu tượng hơn để kết hợp giao diện người dùng. There are a few libraries that provide such a high level of control over the terminal, but

'\n'  # Blank line
''    # Empty line

Note. To use the

'\n'  # Blank line
''    # Empty line

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

That’s because

'\n'  # Blank line
''    # Empty line

Primarily, it allows you to think in terms of independent graphical widgets instead of a blob of text. Besides, you get a lot of freedom in expressing your inner artist, because it’s really like painting a blank canvas. The library hides the complexities of having to deal with different terminals. Other than that, it has great support for keyboard events, which might be useful for writing video games

How about making a retro snake game? Let’s create a Python snake simulator

First, you need to import the

'\n'  # Blank line
''    # Empty line

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

Note, the function must accept a reference to the screen object, also known as

'\n'  # Blank line
''    # Empty line

If you run this program now, you won’t see any effects, because it terminates immediately. However, you can add a small delay to have a sneak peek

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

This time the screen went completely blank for a second, but the cursor was still blinking. To hide it, just call one of the configuration functions defined in the module

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

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

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

The head of the snake is always the first element in the list, whereas the tail is the last one. The initial shape of the snake is horizontal, starting from the top-left corner of the screen and facing to the right. While its y-coordinate stays at zero, its x-coordinate decreases from head to tail

To draw the snake, you’ll start with the head and then follow with the remaining segments. Each segment carries

'\n'  # Blank line
''    # Empty line

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

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

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

You want to move the snake in one of four directions, which can be defined as vectors. Eventually, the direction will change in response to an arrow keystroke, so you may hook it up to the library’s key codes

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

Làm thế nào để một con rắn di chuyển? . Ở mỗi bậc hầu như các phân khúc đều được giữ nguyên ngoại trừ phần đầu và phần đuôi. Giả sử con rắn không phát triển, bạn có thể bỏ đuôi và chèn một cái đầu mới vào đầu danh sách

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

Để có tọa độ mới của đầu, bạn cần thêm vectơ chỉ phương vào đó. Tuy nhiên, việc thêm các bộ trong Python dẫn đến một bộ 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à sử dụng các hàm tích hợp sẵn

'\n'  # Blank line
''    # Empty line

'\n'  # Blank line
''    # Empty line

'\n'  # Blank line
''    # Empty line

Hướng sẽ thay đổi khi nhấn phím, vì vậy bạn cần gọi số

'\n'  # Blank line
''    # Empty line

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

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

'\n'  # Blank line
''    # Empty line

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

Bạn sắp hoàn thành, nhưng chỉ còn một việc cuối cùng. Nếu bây giờ bạn lặp đoạn mã này, con rắn sẽ có vẻ như đang lớn lên thay vì di chuyển. Đó là 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 lại

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

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

Đây chỉ là bề nổi của các khả năng mà mô-đun

'\n'  # Blank line
''    # Empty line

Sống hết mình với những hình ảnh động thú vị

Hoạt ảnh không chỉ có thể làm cho giao diện người dùng bắt mắt hơn 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 hay đã đến lúc kết thúc chương trình đó

Để tạo hiệu ứng động cho 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ể thực hiện việc này bằng một trong những công cụ đã đề cập trước đây, đó là mã thoát ANSI hoặc thư viện

'\n'  # Blank line
''    # Empty line

Nếu hoạt ảnh có thể bị giới hạn trong 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

• Vận chuyển trở lại.

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

  08
• xóa lùi.

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

  13

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

Hãy xem xét một vài ví dụ

Bạn sẽ 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 hành mà không biết chính xác còn bao nhiêu thời gian để hoàn thành

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

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

Vòng lặp lấy ký tự tiếp theo để in, sau đó di chuyển con trỏ đến đầu dòng và ghi đè lên bất kỳ ký tự nào trước đó mà không cần thêm dòng mới. Bạn không muốn có thêm khoảng trống giữa các đối số vị trí, vì vậy đối số dấu phân cách phải để trống. Ngoài ra, hãy lưu ý 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ó trong nghĩa đen

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

Trước tiên, bạn cần tính toán xem có bao nhiêu hashtag sẽ hiển thị và bao nhiêu khoảng trắng để chèn vào. Tiếp theo, bạn xóa dòng và xây dựng thanh từ đầu

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

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

Ghi chú. Có một thư viện

'\n'  # Blank line
''    # Empty line

Tạo âm thanh với >>> import os >>> os.linesep '\r\n' 94

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

Ngày nay, bạn vẫn có thể tận dụng chiếc 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 chiếc loa này. Trong trường hợp như vậy, bạn có thể bật mô phỏng chuông đầu cuối trong trình bao của mình để âm thanh cảnh báo hệ thống được phát thay thế

Hãy tiếp tục và gõ lệnh này để xem thiết bị đầu cuối của bạn có thể phát âm thanh không

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

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

'\n'  # Blank line
''    # Empty line

'\n'  # Blank line
''    # Empty line

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

Các quy tắc như sau

• Các chữ cái được mã hóa bằng một chuỗi các ký hiệu dấu chấm (·) và dấu gạch ngang (–)
• Dấu chấm là một đơn vị thời gian
• Dấu gạch ngang là ba đơn vị thời gian
• Các ký hiệu riêng lẻ trong một chữ cái được đặt cách nhau một đơn vị thời gian
• Ký hiệu của hai chữ cái liền kề cách nhau ba đơn vị thời gian
• Ký hiệu của hai từ liền kề cách nhau bảy đơn vị thời gian

Theo các quy tắc đó, bạn có thể “in” tín hiệu SOS vô thời hạn theo cách sau

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

Trong Python, bạn có thể triển khai nó chỉ trong mười dòng mã

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

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 sang mã Morse?

truy tìm

Còn được gọi là gỡ lỗi in hoặc gỡ lỗi thượng cổ, đây 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ó công dụng của nó

Ý tưởng là đi theo đường dẫn thực thi chương trình cho đến khi chương trình dừng đột ngột hoặc đưa ra kết quả không chính xác để xác định chính xác lệnh có 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

>>>

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

Như bạn có thể thấy, hàm không trả về giá trị mong muốn là

'\n'  # Blank line
''    # Empty line

Lỗi làm trònHiển thị/Ẩn

Trong trường hợp này, vấn đề nằm ở chỗ số dấu phẩy động được biểu diễn như thế nào trong bộ nhớ máy tính. Hãy nhớ rằng các số được lưu trữ ở dạng nhị phân. Giá trị thập phân của

'\n'  # Blank line
''    # Empty line

Để biết thêm thông tin về cách làm tròn số trong Python, bạn có thể xem Cách làm tròn số trong Python

Phương pháp này đơn giản, trực quan và sẽ hoạt động với hầu hết mọi ngôn ngữ lập trình hiện có. Chưa kể, đó 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 nắm vững các kỹ thuật nâng cao hơn, thì rất khó để quay lại, vì chúng cho phép bạn tìm lỗi nhanh hơn nhiều. Truy tìm là một quy trình thủ công tốn nhiều công sức, có thể để lọt 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ỏ tỉ mỉ tất cả các cuộc gọi

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

Bên cạnh đó, nó yêu cầu bạn thực hiện các thay đổi trong mã, điều này không phải lúc nào cũng có thể thực hiện được. Có thể bạn đang gỡ lỗi một ứng dụng đang chạy trong máy chủ web từ xa hoặc muốn chẩn đoán sự cố theo kiểu khám nghiệm tử thi. Đô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

Đó chính xác là nơi khai thác gỗ tỏa sáng

ghi nhật ký

Giả sử bạn đang điều hành một trang web thương mại điện tử trong một phú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 không thành công và nói rằng anh ta đã mất tiền. Anh ấy tuyên bố đã thử mua một số mặt hàng, nhưng cuối cùng, có một số lỗi khó hiểu khiến anh ấy không thể hoàn thành đơn hàng đó. 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 chân thành xin lỗi và hoàn tiền, nhưng cũng không muốn điều này lặp lại trong tương lai. Làm thế nào để bạn gỡ lỗi đó?

Bất cứ khi nào bạn thấy mình đang gỡ lỗi bản in, hãy cân nhắc biến nó thành thông báo tường trình vĩnh viễn. Điều này có thể hữu ích trong những 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ó những công cụ tinh vi để tổng hợp và tìm kiếm nhật ký, nhưng ở cấp độ cơ bản nhất, bạn có thể coi nhật ký là 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ó sẽ không chứa thông tin nhận dạng cá nhân, tuy nhiên, trong một số trường hợp, nó có thể được pháp luật quy định

Đây là bảng phân tích của một bản ghi nhật ký điển hình

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

Như bạn có thể thấy, nó có dạng cấu trúc. Ngoài một thông báo mô tả, có một số trường có thể tùy chỉnh, cung cấp ngữ cảnh của một sự kiện. Tại đây, bạn có ngày giờ chính xác, cấp nhật ký, tên nhật ký 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 lỗi, bạn không muốn xem tất cả các cảnh báo hoặc thông báo gỡ lỗi. Việc tắt hoặc bật thông báo ở các cấp nhật ký nhất định thông qua cấu hình là chuyện nhỏ mà không cần chạm vào mã

Với tính năng 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. Theo mặc định, tất cả các thông báo nhật ký đều chuyển đến luồng lỗi tiêu chuẩn, có thể hiển thị thuận tiện bằng các màu khác nhau. Tuy nhiên, bạn có thể chuyển hướng thông điệp tường trình 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, ghi nhật ký bị định cấu hình sai có thể dẫn đến hết dung lượng trên đĩa của máy chủ. Để ngăn chặn điều đó, bạn có thể thiết lập xoay vòng nhật ký, thao tác này sẽ giữ các tệp nhật ký trong một khoảng thời gian nhất định, chẳng hạn như một tuần hoặc khi chúng đạt đến một kích thước nhất định. Tuy nhiên, lưu trữ các nhật ký cũ hơn luôn là một cách thực hành tốt. Một số quy định buộc dữ liệu khách hàng phải được lưu giữ trong vòng 5 năm

So với các ngôn ngữ lập trình khác, đăng nhập Python đơn giản hơn, vì mô-đun

'\n'  # Blank line
''    # Empty line

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

Bạn có thể gọi các hàm được xác định ở cấp độ mô-đun, được nối với trình ghi nhật ký gốc, nhưng thực tế phổ biến hơn là lấy một trình ghi nhật ký chuyên dụng cho từng tệp nguồn của bạn

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

Ưu điểm của việc sử dụng trình ghi nhật ký tùy chỉnh là kiểm soát chi tiết hơn. Chúng thường được đặt tên theo mô-đun mà chúng được xác định thông qua biến

'\n'  # Blank line
''    # Empty line

Ghi chú. Có một mô-đun

'\n'  # Blank line
''    # Empty line

'\n'  # Blank line
''    # Empty line

Điều đó nói rằng, bạn có thể làm cho họ làm việc cùng nhau bằng cách gọi

'\n'  # Blank line
''    # Empty line

Một lý do cuối cùng để chuyển từ chức năng

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

gỡ lỗi

Sự thật là cả truy tìm và ghi nhật ký đều không 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 các thao tác sau

• Bước qua mã một cách tương tác
• Đặt điểm ngắt, bao gồm cả điểm dừng có điều kiện
• Các biến nội quan trong bộ nhớ
• Đánh giá các biểu thức tùy chỉnh trong thời gian chạy

Trình gỡ lỗi thô chạy trong thiết bị đầu cuối, không có gì ngạc nhiên khi được đặt tên là

'\n'  # Blank line
''    # Empty line

Tuy nhiên, nó không đi kèm với giao diện đồ họa nên việc sử dụng

'\n'  # Blank line
''    # Empty line

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

Nếu không, bạn có thể thiết lập một điểm ngắt trực tiếp trong mã, điểm dừng này sẽ tạm dừng việc thực thi tập lệnh của bạn và đưa bạn vào trình gỡ lỗi. Cách cũ để làm điều này cần hai bước

>>>

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

Thao tác này sẽ hiển thị lời nhắc tương tác, thoạt nhìn có vẻ đáng sợ. Tuy nhiên, bạn vẫn có thể nhập Python nguyên gốc vào 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, thực sự chỉ có một số lệnh dành riêng cho trình gỡ lỗi mà bạn muốn sử dụng để xem qua mã

Ghi chú. Theo thông lệ, bạn sẽ đặt hai hướng dẫn để khởi động trình gỡ lỗi trên một dòng. Điều này yêu cầu sử dụng dấu chấm phẩy, hiếm khi được tìm thấy trong các chương trình Python

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

Mặc dù chắc chắn không phải Pythonic, nhưng nó nổi bật như một lời nhắc xóa nó sau khi bạn hoàn tất việc gỡ lỗi

Kể từ Python 3. 7, bạn cũng có thể gọi hàm

'\n'  # Blank line
''    # Empty line

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

Hầu hết các phần có thể bạn 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ã. 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 nhiều IDE thay thế có trình gỡ lỗi, cả trả phí và miễn phí

Gỡ lỗi không phải là viên đạn bạc thành ngữ. Đôi khi ghi nhật ký hoặc theo dõi sẽ là một giải pháp tốt hơn. Ví dụ: các lỗi khó tái tạo, chẳng hạn như điều kiện chủng tộc, thường là do khớp nối thời gian. Khi bạn dừng tại một điểm dừng, việc tạm dừng nhỏ đó trong quá trình thực thi chương trình có thể che dấu sự cố. Nó giống như nguyên tắc Heisenberg. bạn không thể đo lường và quan sát lỗi cùng một lúc

Các phương pháp này không loại trừ lẫn nhau. Họ bổ sung cho nhau

Được xây dựng trong

Python đi kèm với một chức năng tích hợp sẵn để chấp nhận đầu vào từ người dùng, có thể đoán trước được gọi là

'\n'  # Blank line
''    # Empty line

>>>

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

Hàm luôn trả về một chuỗi, vì vậy bạn có thể cần phân tích cú pháp cho phù hợp

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

Tham số dấu nhắc là 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 hoạt động

>>>

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

Tuy nhiên, việc đưa ra lời kêu gọi hành động mang tính mô tả giúp trải nghiệm người dùng tốt hơn rất nhiều

Ghi chú. Để đọc từ đầu vào tiêu chuẩn trong Python 2, thay vào đó, bạn phải gọi

'\n'  # Blank line
''    # Empty line

'\n'  # Blank line
''    # Empty line

Trên thực tế, nó cũng lấy đầu vào từ luồng tiêu chuẩn, nhưng sau đó nó cố gắng đánh giá nó như thể đó là mã Python. Bởi vì đó là một lỗ hổng bảo mật tiềm ẩn, chức năng này đã bị xóa hoàn toàn khỏi Python 3, trong khi

'\n'  # Blank line
''    # Empty line

'\n'  # Blank line
''    # Empty line

Dưới đây là so sánh nhanh các chức năng có sẵn và chức năng của chúng

Python 2Python 3

'\n'  # Blank line
''    # Empty line

'\n'  # Blank line
''    # Empty line

'\n'  # Blank line
''    # Empty line

>>> 'A line of text.\n'.rstrip()
'A line of text.'

Như bạn có thể thấy, vẫn có thể mô phỏng hành vi cũ trong Python 3

Yêu cầu người dùng nhập mật khẩu bằng

'\n'  # Blank line
''    # Empty line

>>> 'A line of text.\n'.rstrip()
'A line of text.'

>>>

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

Mô-đun

>>> 'A line of text.\n'.rstrip()
'A line of text.'

>>>

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

Các hàm 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

bên thứ ba

Có các gói Python bên ngoài 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

• Đị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
• Một phong cách khai báo xác định bố cục
• Tự động hoàn thành tương tác
• hỗ trợ chuột
• Các vật dụng được xác định trước như danh sách kiểm tra hoặc menu
• Lịch sử có thể tìm kiếm của các lệnh đã nhập
• Đánh dấu cú pháp

Trình diễn các công cụ như vậy nằm ngoài phạm vi của bài viết này, nhưng bạn có thể muốn dùng thử chúng. Cá nhân tôi đã biết về một số trong số đó thông qua Python Bytes Podcast. Họ đây rồi

• >>> 'A line of text.\n'.rstrip()
  'A line of text.'
  

  07

• >>> 'A line of text.\n'.rstrip()
  'A line of text.'
  

  08

• >>> 'A line of text.\n'.rstrip()
  'A line of text.'
  

  09

• >>> 'A line of text.\n'.rstrip()
  'A line of text.'
  

  10

Tuy nhiên, điều đáng nói là một công cụ dòng lệnh có tên là

>>> 'A line of text.\n'.rstrip()
'A line of text.'

Giả sử bạn đã viết một giao diện dòng lệnh hiểu ba hướng dẫn, bao gồm một hướng dẫn để thêm số

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

Thoạt nhìn, nó giống như một lời nhắc điển hình khi bạn chạy nó

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

Nhưng ngay khi bạn mắc lỗi và muốn sửa nó, bạn sẽ thấy không có phím chức năng nào hoạt động như mong muốn. Ví dụ: nhấn vào mũi tên Trái sẽ dẫn đến điều này thay vì di chuyển con trỏ trở lại.

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

Bây giờ, bạn có thể gói cùng một tập lệnh bằng lệnh

>>> 'A line of text.\n'.rstrip()
'A line of text.'

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

Điều đó không tuyệt sao?