Cách in mà không cần sử dụng in trong python

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. chuyển hướng

• >>> 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

Để so sánh các mã ký tự ASCII, bạn có thể muốn sử dụng hàm

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

>>>

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

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 cách 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

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

Bạn có thể sử dụng chuỗi ký tự của Python để hình dung hai

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

Cái đầu tiên dài một ký tự, trong khi cái thứ hai không có nội dung

Ghi chú. Để xóa ký tự xuống dòng khỏi một chuỗi trong Python, hãy sử dụng phương thức

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

>>>

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

Điều này loại bỏ mọi khoảng trắng ở cuối từ cạnh phải của chuỗi ký tự

Trong một tình huống phổ biến hơn, bạn muốn truyền đạt một số thông điệp tới người dùng cuối. Có một số cách để đạt được điều này

Đầu tiên, bạn có thể chuyển trực tiếp một chuỗi ký tự tới

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

>>>

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

Điều này sẽ in nguyên văn tin nhắn lên màn hình

Chuỗi ký tựHiển thị/Ẩn

Chuỗi ký tự trong Python có thể được đặt trong dấu ngoặc đơn (

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

Ví dụ: bạn không thể sử dụng dấu ngoặc kép cho nghĩa đen và cũng bao gồm dấu ngoặc kép bên trong nó, vì điều đó không rõ ràng đối với trình thông dịch Python

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

Điều bạn muốn làm là đặt văn bản chứa dấu ngoặc kép trong dấu ngoặc đơn

'My favorite book is "Python Tricks"'

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

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

Ngoài ra, bạn có thể sử dụng các chuỗi ký tự thoát đã đề cập trước đó, để làm cho Python coi các dấu ngoặc kép bên trong đó theo nghĩa đen là một phần của chuỗi ký tự

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

Chạy trốn 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 tương đối nhiều ký tự gạch chéo ngược ở dạng chữ

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

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

Lưu ý cách mỗi ký tự dấu gạch chéo ngược cần được thoát bằng 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 trở nên phức tạp do sử dụng nhiều ký tự đặc biệt

>>> 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 một dòng mới ban đầu, 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'

Lastly, you could pass an expression, like string concatenation, to be evaluated before printing the result

>>>

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

In fact, there are a dozen ways to format messages in Python. Tôi thực sự khuyến khích bạn xem f-strings, được giới thiệu trong Python 3. 6, because they offer the most concise syntax of them all

>>>

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

That’s wrong because adding numbers to strings doesn’t make sense. You need to explicitly convert the number to string first, in order to join them together

>>>

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

Unless you handle such errors yourself, the Python interpreter will let you know about a problem by showing a traceback

Note.

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

You can call it directly on any object, for example, a number

>>>

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

Built-in data types have a predefined string representation out of the box, but later in this article, you’ll find out how to provide one for your custom classes

As with any function, it doesn’t matter whether you pass a literal, a variable, or an expression. Unlike many other functions, however,

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

So far, you only looked at the string, but how about other data types? Let’s try literals of different built-in types and see what comes out

>>>

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

Watch out for the

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

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

>>>

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

How does

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

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

Later in this tutorial, you’ll learn how to use this mechanism for printing custom data types such as your classes

Okay, you’re now able to call

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

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

To achieve the same result in the previous language generation, you’d normally want to drop the parentheses enclosing the text

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

That’s because

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

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

For example, parentheses enclosing a single expression or a literal are optional. Both instructions produce the same result in Python 2

>>>

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

Round brackets are actually part of the expression rather than the

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

On the other hand, putting parentheses around multiple items forms a

>>>

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

This is a known source of confusion. In fact, you’d also get a tuple by appending a trailing comma to the only item surrounded by parentheses

>>>

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

The bottom line is that you shouldn’t call

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

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

Separating Multiple Arguments

You saw

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

However, it turns out that this function can accept any number of positional arguments, including zero, one, or more arguments. That’s very handy in a common case of message formatting, where you’d want to join a few elements together

Positional ArgumentsShow/Hide

Arguments can be passed to a function in one of several ways. 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'

Let’s have a look at this example

>>>

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

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

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

Notice that it also took care of proper type casting by implicitly calling

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

>>>

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

Apart from accepting a variable number of positional arguments,

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

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

Let’s focus on

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

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

It has to be either a string or

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

>>>

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

If you wanted to suppress the separator completely, you’d have to pass an empty string (

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

>>>

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

You may want

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

>>>

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

A more useful example of the

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

>>>

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

Remember that the separator comes between the elements, not around them, so you need to account for that in one way or another

>>>

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

Specifically, you can insert a slash character (

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

Note. Be careful about joining elements of a list or tuple

Doing it manually will result in a well-known

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

>>>

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

It’s safer to just unpack the sequence with the star operator (

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

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

>>>

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

Unpacking is effectively the same as calling

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

One more interesting example could be exporting data to a comma-separated values (CSV) format

>>>

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

This wouldn’t handle edge cases such as escaping commas correctly, but for simple use cases, it should do. The line above would show up in your terminal window. In order to save it to a file, you’d have to redirect the output. Later in this section, you’ll see how to use

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

Finally, the

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

>>>

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

In the upcoming subsections, you’ll explore the remaining keyword arguments of the

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

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

To print multiple elements in Python 2, you must drop the parentheses around them, just like before

>>>

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

If you kept them, on the other hand, you’d be passing a single tuple element to the

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

>>>

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

Moreover, there’s no way of altering the default separator of joined elements in Python 2, so one workaround is to use string interpolation like so

>>>

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

That was the default way of formatting strings until the

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

Preventing Line Breaks

Sometimes you don’t want to end your message with a trailing newline so that subsequent calls to

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

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

Many programming languages expose functions similar to

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

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

Here are a few examples of syntax in such languages

LanguageExamplePerl

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

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

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

In contrast, Python’s

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

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

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

In terms of semantics, the

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

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

• It must be a string or

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

  32
• It can be arbitrarily long
• It has a default value of

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

  78
• If equal to

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

  32, it’ll have the same effect as the default value
• If equal to an empty string (

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

  53), it’ll suppress the newline

Now you understand what’s happening under the hood when you’re calling

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

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

Note. You may be wondering why the

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

Well, you don’t have to worry about newline representation across different operating systems when printing, because

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

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

This is currently the most portable way of printing a newline character in Python

>>>

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

If you were to try to forcefully print a Windows-specific newline character on a Linux machine, for example, you’d end up with broken output

>>>

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

On the flip side, when you open a file for reading with

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

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

To disable the newline, you must specify an empty string through the

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

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

Even though these are two separate

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

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

However, after the second call to

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

These three instructions will output a single line of text

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

You can mix the two keyword arguments

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

Not only do you get a single line of text, but all items are separated with a comma

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

There’s nothing to stop you from using the newline character with some extra padding around it

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

It would print out the following piece of text

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

As you can see, the

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

Note. Looping over lines in a text file preserves their own newline characters, which combined with the

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

>>>

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

There are two newlines after each line of text. You want to strip one of the them, as shown earlier in this article, before printing the line

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

Alternatively, you can keep the newline in the content but suppress the one appended by

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

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

>>>

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

By ending a line with an empty string, you effectively disable one of the newlines

You’re getting more acquainted with printing in Python, but there’s still a lot of useful information ahead. In the upcoming subsection, you’ll learn how to intercept and redirect the

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

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

Preventing a line break in Python 2 requires that you append a trailing comma to the expression

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

However, that’s not ideal because it also adds an unwanted space, which would translate to

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

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

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

Notice there’s a space between the words

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

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

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

In order to get the expected result, you’d need to use one of the tricks explained later, which is either importing the

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

While using the

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

Printing to a File

Believe it or not,

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

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

In addition to this, there are three standard streams provided by the operating system

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

   08. standard input

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

   09. standard output

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

   10. standard error

Standard StreamsShow/Hide

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

Unless otherwise instructed,

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

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

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

That’s called stream redirection

The standard error is similar to

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

>>> 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!

Đặt cược tốt nhất của bạn là mã hóa chuỗi Unicode ngay trước khi in nó. 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!

Lưu ý rằng

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

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

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. Chúng ta hãy xem xét các cách khác nhau để định nghĩa chúng

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

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

The syntax for variable annotations, which is required to specify class fields with their corresponding types, was defined in 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

Print Is a Function in 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. Bạn cũng sẽ định nghĩa các hàm

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

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

Mặt khác,

>>> 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 . Cái sau được đánh giá thành một giá trị có thể được gán cho một biến hoặc được truyền cho một hàm. In the example above, you’re interested in the side-effect rather than the value, which evaluates to

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

Như bạn có thể thấy, các hàm cho phép một giải pháp tao nhã và có thể 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 việc không có

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

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

Một câu lệnh là một hướng dẫn có thể gây ra tác dụng phụ khi được thực thi nhưng không bao giờ đánh giá thành một giá trị. 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

Dưới đây là một vài ví dụ khác về câu lệnh trong Python

• assignment.

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

  47
• conditional.

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

  48
• loop.

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

  49
• quả quyết.

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

  50

Ghi chú. Trăn 3. 8 mang đến một toán tử hải mã gây tranh cãi (

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

Hãy xem ví dụ này, gọi một hàm đắt tiền một lần và sau đó sử dụng lại kết quả để tính toán thêm

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

Điều này rất hữu ích để đơn giản hóa mã mà không làm giảm hiệu quả của nó. Thông thường, mã biểu diễn có xu hướng dài dòng hơn

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

Tranh cãi đằng sau đoạn cú pháp mới này đã gây ra nhiều tranh luận. Vô số bình luận tiêu cực và những cuộc tranh luận sôi nổi cuối cùng đã khiến Guido van Rossum phải từ chức Nhà độc tài nhân từ vì sự sống hay BDFL

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

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

Cú pháp của câu lệnh

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

>>>

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

Vào những thời điểm khác, họ thay đổi cách in tin nhắn

>>>

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

Nối chuỗi có thể tăng

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

>>>

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

So sánh mã này với mã tương tự trong Python 3, mã này thúc đẩy giải nén trình tự

>>>

>>> 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. Thay vào đó, bạn cần nhớ cú pháp kỳ quặc. 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. Bạn không thể soạn nhiều câu lệnh

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

Danh sách các vấn đề cứ lặp đi lặp lại. Nếu tò mò, bạn có thể quay lại 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 đề đó bằng cách tiếp cận đơn giản hơn nhiều. Hóa ra hàm

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

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

Ghi chú. Bạn có thể nhập các hàm trong tương lai cũng như các cấu trúc ngôn ngữ có sẵn, chẳng hạn như câu lệnh

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

Để tìm hiểu chính xác những tính năng nào có sẵn cho bạn, hãy kiểm tra mô-đun

>>>

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

Bạn cũng có thể gọi

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

Để bật hàm

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

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

Từ giờ trở đi, câu lệnh

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

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

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

Ngoài ra, nó không giúp bạn quản lý mã hóa ký tự đúng cách

Đây là một ví dụ về cách gọi hàm

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

>>>

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

Bây giờ bạn đã có ý tưởng về cách in bằng 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 ngược này lại 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 giỏi hơn

Cấu trúc dữ liệu lồng nhau in đẹp

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 phép bạn tự do sử dụng khoảng trắng và định dạng. Điều này có thể hữu ích, chẳng hạn như trong quá trình nén, nhưng đôi khi nó dẫn đến mã khó đọc hơn

In đẹp là làm cho một đoạ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 nó dễ dàng hơn. Điều này được thực hiện bằng cách thụt lề một số dòng nhất định, chèn dòng mới, sắp xếp lại các phần tử, v.v.

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

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

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

Ghi chú. Để chuyển chế độ in đẹp trong IPython, hãy ra lệnh sau

>>>

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

Đây là một ví dụ về Phép thuật trong IPython. Có rất nhiều lệnh tích hợp bắt đầu bằng dấu phần trăm (

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

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

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

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

>>>

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

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

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

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

Thoạt nhìn, hầu như không có bất kỳ 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ó

>>>

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

Đó là bởi vì

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

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

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

>>>

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

Hàm á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 cấu trúc phân cấp được lồng sâu bằng cách hiển thị dấu chấm lửng bên dưới một mức nhất định

>>>

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

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

>>>

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

Tuy nhiên,

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

>>>

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

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

Ghi chú. Các tập dữ liệu đệ quy hoặc rất lớn cũng có thể được xử lý bằng cách sử dụng mô-đun

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

>>>

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

Mô-đun này hỗ trợ hầu hết các loại tích hợp sẵn và được trình gỡ lỗi Python sử dụng

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

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

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

>>>

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

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

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

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

Ngạc nhiên thay, chữ ký của

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

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

Thêm màu với chuỗi thoát ANSI

Khi máy tính cá nhân trở nên phức tạp 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 cách đây vài thập kỷ khi những ngườ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 đều 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

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

Để 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 hay không, chẳng hạn như liên quan đến màu sắc, bạn có thể thử sử dụng lệnh sau

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

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ỉ cho tôi 8. Lệnh sẽ trả về số âm nếu màu không được hỗ trợ

Chuỗi 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ư

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

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

Như tên gọi của nó, một chuỗi phải bắt đầu bằng ký tự Esc không in được, có giá trị ASCII là 27, đôi khi được ký hiệu là

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

>>>

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

Ngoài ra, bạn có thể lấy nó bằng chuỗi thoát

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

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

Các chuỗi thoát ANSI phổ biến nhất có dạng sau

ElementDescriptionExample Esc ký tự thoát không in được_______44_______94

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

Mã số có thể là một hoặc nhiều số được phân tách bằng dấu chấm phẩy, trong khi mã ký tự chỉ là một chữ cái. Ý nghĩa cụ thể của chúng được xác định theo tiêu chuẩn ANSI. Ví dụ: để đặt lại tất cả định dạng, bạn sẽ nhập một trong các lệnh sau, sử dụng mã số 0 và chữ cái

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

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

Ở đầu kia của quang phổ, bạn có các giá trị mã phức hợp. Để đặt nền trước và nền sau với các kênh RGB, với điều kiện là thiết bị đầu cuối của bạn hỗ trợ độ sâu 24 bit, bạn có thể cung cấp nhiều số

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

Bạn không chỉ có thể đặt màu văn bản bằng mã thoát ANSI. Ví dụ: bạn có thể xóa và cuộn cửa sổ đầu cuối, thay đổi nền của nó, di chuyển con trỏ xung quanh, làm cho văn bản nhấp nháy hoặc trang trí bằng gạch dưới

Trong Python, bạn có thể viết một hàm trợ giúp để cho phép gói các mã tùy ý thành một chuỗi

>>>

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

Điều này sẽ làm cho từ

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

Tuy nhiên, có những khái niệm trừu tượng cấp cao hơn đối với mã thoát ANSI, chẳng hạn như thư viện

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

Xây dựng giao diện người dùng bảng điều khiển

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. Có một số thư viện cung cấp mức độ kiểm soát cao như vậy đối với thiết bị đầu cuối, nhưng

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

Ghi chú. Để sử dụng thư viện

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

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

Đó là bởi vì

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

Về cơ bản, nó cho phép bạn suy nghĩ về các tiện ích đồ họa độc lập thay vì một khối văn bản. Bên cạnh đó, bạn có rất nhiều tự do trong việc thể hiện nghệ sĩ bên trong của mình, bởi vì nó thực sự giống như vẽ một bức tranh trống. Thư viện che giấu sự phức tạp của việc phải xử lý các thiết bị đầu cuối khác nhau. Ngoài ra, nó còn hỗ trợ tuyệt vời cho các sự kiện bàn phím, có thể hữu ích khi viết trò chơi điện tử

Làm thế nào về việc làm một trò chơi rắn cổ điển?

Trước tiên, bạn cần nhập mô-đun

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

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

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à

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

Nếu bạn chạy chương trình này ngay bây giờ, bạn sẽ không thấy bất kỳ hiệu ứng nào, vì nó sẽ kết thúc ngay lập tức. Tuy nhiên, bạn có thể thêm một độ trễ nhỏ để xem trước

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

Lần này, màn hình hoàn toàn trố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 chức năng cấu hình được xác định trong mô-đun

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

Đầu rắn luôn là phần tử đầu tiên trong danh sách, trong khi đuôi là phần tử 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 bên phải. Trong khi tọa độ y của nó vẫn ở mức 0, thì tọa độ x của nó giảm dần từ đầu đến đuôi

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

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

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 lần nhấn phím mũi tên, vì vậy bạn có thể kết nối nó với các mã khóa của thư viện

>>> 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ề ngoà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

Một trình gỡ lỗi thô chạy trong thiết bị đầu cuối, có tên không ngạc nhiê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 đã gõ
• Đá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ể bọc 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?