Cách in tên bằng Python

Đang gọi >>> import os >>> os.linesep '\r\n' 94

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

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

>>>

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

Bạn không chuyển bất kỳ đối số nào, nhưng bạn vẫn cần đặt dấu ngoặc đơn trống ở cuối, dấu ngoặc đơn này yêu cầu Python thực sự thực thi hàm thay vì chỉ gọi nó theo tên

Thao tác này sẽ tạo ra một ký tự xuống dòng ẩn, do đó sẽ khiến một dòng trống xuất hiện trên màn hình của bạn. Bạn có thể gọi

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

Ký tự xuống dòngHiển thị/Ẩn

Ký tự xuống dòng là một ký tự điều khiển đặc biệt được sử dụng để biểu thị kết thúc một dòng (EOL). Nó thường không có biểu diễn hiển thị trên màn hình, nhưng một số trình soạn thảo văn bản có thể hiển thị các ký tự không in được như vậy với ít đồ họa

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

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

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

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

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

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

>>>

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

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

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

>>>

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

Tuy nhiên, Mac OS X cổ điển vẫn bám sát triết lý “nghĩ khác” của riêng nó bằng cách chọn một đại diện khác

>>>

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

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

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

Hầu hết các ngôn ngữ lập trình đều đi kèm với một tập hợp các chuỗi thoát được xác định trước cho các ký tự đặc biệt, chẳng hạn như các ký tự này

• >>> 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. dòng mới, còn được gọi là nguồn cấp dữ liệu dòng (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'

>>>

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

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

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

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 chuỗi trong Python, hãy sử dụng phương thức

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

>>>

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

Đ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

Trước 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'

>>>

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

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

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

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

Đ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

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

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

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

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'

Fortunately, you can turn off character escaping entirely with the help of raw-string literals. Simply prepend an

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

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

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

That’s much better, isn’t it?

There are a few more prefixes that give special meaning to string literals in Python, but you won’t get into them here

Lastly, you can define multi-line string literals by enclosing them between

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

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

Here’s an example

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

To prevent an initial newline, simply put the text right after the opening

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

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

You can also use a backslash to get rid of the newline

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

To remove indentation from a multi-line string, you might take advantage of the built-in

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

>>>

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

This will take care of unindenting paragraphs for you. There are also a few other useful functions in

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

Secondly, you could extract that message into its own variable with a meaningful name to enhance readability and promote code reuse

>>>

>>> 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. I highly encourage you to take a look at f-strings, introduced in Python 3. 6, because they offer the most concise syntax of them all

>>>

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

Moreover, f-strings will prevent you from making a common mistake, which is forgetting to type cast concatenated operands. Python is a strongly typed language, which means it won’t allow you to do this

>>>

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

Syntax in Python 2Show/Hide

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 tuple

>>>

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

Đây là một nguồn nhầm lẫn đã biết. 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\n'

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

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

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

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

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

Let’s have a look at this example

>>>

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

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

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

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

You may want

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

>>>

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

A more useful example of the

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

>>>

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

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

>>>

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

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'

>>>

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

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

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

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

>>>

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

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

>>>

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

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

Finally, the

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

>>>

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

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

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

Syntax in Python 2Show/Hide

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

>>>

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

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

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

>>>

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

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

>>>

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

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

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

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

Ngôn ngữVí dụPerl

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

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

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

Ngược lại, hàm ________ 094 của Python luôn thêm ________ 809 mà không cần hỏi, vì đó là điều bạn muốn trong hầu hết các trường hợp. Để vô hiệu hóa nó, bạn có thể tận dụng một đối số từ khóa khác,

>>> 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 (______853), 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

>>>

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

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

>>>

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

Mặt khác, khi bạn mở 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'

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

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

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

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

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

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

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

Như với

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

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

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

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

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

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

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

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

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

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ó

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

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

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

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'

>>>

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

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

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

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

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

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

>>>

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

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'

Syntax in Python 2Show/Hide

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

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

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'

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

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

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

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

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

Để 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\n'

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

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

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

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

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

In ra một tập tin

Dù bạn có tin hay không thì tùy,

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

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

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

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

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

   010. lỗi tiêu chuẩn

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

Đầu ra tiêu chuẩn là những gì bạn nhìn thấy trong thiết bị đầu cuối khi chạy các chương trình dòng lệnh khác nhau bao gồm các tập lệnh Python của riêng bạn

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

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

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

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

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

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

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

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

Ghi chú. Để chuyển hướng

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

Chúng là các số tùy ý, mặc dù không đổi, được liên kết với các luồng tiêu chuẩn. Dưới đây, bạn sẽ tìm thấy bản tóm tắt các bộ mô tả tệp cho một họ hệ điều hành tuân thủ POSIX

StreamFile Descriptor

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

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

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

Biết những bộ mô tả đó cho phép bạn chuyển hướng một hoặc nhiều luồng cùng một lúc

LệnhMô tả

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

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

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

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

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

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

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

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

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

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

Lưu ý rằng ________ 2028 giống như ________ 2029

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

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

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

Trong khi cả

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

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

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

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

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

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

>>>

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

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

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

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

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

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

Theo mặc định,

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

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

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

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

Điều này sẽ làm cho mã của bạn không bị chuyển hướng luồng ở cấp hệ điều hành, điều này có thể hoặc không mong muốn

Để biết thêm thông tin về cách làm việc với tệp trong Python, bạn có thể xem Đọc và ghi tệp bằng Python (Hướng dẫn)

Ghi chú. Đừng thử sử dụng

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

Chỉ cần gọi trực tiếp tệp nhị phân là

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

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

Nếu bạn muốn ghi các byte thô trên đầu ra tiêu chuẩn, thì điều này cũng sẽ thất bại vì

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

>>>

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

Thay vào đó, bạn phải đào sâu hơn để xử lý luồng byte bên dưới

>>>

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

Điều này in một chữ cái viết hoa

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

Lưu ý rằng

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

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

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

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

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

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

>>>

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

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

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

Syntax in Python 2Show/Hide

Có một cú pháp đặc biệt trong Python 2 để thay thế

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

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

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

Bởi vì các chuỗi và byte được biểu diễn bằng cùng một loại

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

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

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

Mặc dù, có một vấn đề với mã hóa ký tự. Hàm

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

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

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

>>>

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

Lưu ý cách các ký tự không phải là tiếng Latinh phải được thoát bằng cả Unicode và chuỗi ký tự để tránh lỗi cú pháp. Hãy xem ví dụ này

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

Ngoài ra, bạn có thể chỉ định mã hóa mã nguồn theo PEP 263 ở đầu tệp, nhưng đó không phải là cách tốt nhất do các vấn đề về tính di động

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

Đặt cược tốt nhất của bạn là mã hóa chuỗi Unicode ngay trước khi in nó. Bạn có thể làm điều này bằng tay

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

Tuy nhiên, một tùy chọn thuận tiện hơn là sử dụng mô-đun

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

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

Nó sẽ đảm nhiệm việc thực hiện các chuyển đổi phù hợp khi bạn cần đọc hoặc ghi tệp

Đệm cuộc gọi >>> import os >>> os.linesep '\r\n' 94

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

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

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

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

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

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

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

Miễn là biến

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

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

Thật bất ngờ, thay vì đếm ngược từng giây, chương trình lại nhàn rỗi một cách lãng phí trong ba giây, rồi đột ngột in toàn bộ dòng cùng một lúc

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

1. Không có bộ đệm
2. đệm dòng
3. đệm khối

Không có bộ đệm thì rõ ràng, nghĩa là không có bộ đệm nào diễn ra và tất cả các thao tác ghi đều có hiệu lực ngay lập tức. Luồng có bộ đệm dòng chờ trước khi thực hiện bất kỳ lệnh gọi I/O nào cho đến khi ngắt dòng xuất hiện ở đâu đó trong bộ đệm, trong khi luồng có bộ đệm khối chỉ đơn giản cho phép bộ đệm lấp đầy đến một kích thước nhất định bất kể nội dung của nó là gì. Đầu ra tiêu chuẩn có cả bộ đệm dòng và bộ đệm khối, tùy thuộc vào sự kiện nào đến trước

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

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

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

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

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

Đó là tất cả. Bộ đếm ngược của bạn sẽ hoạt động như mong đợi ngay bây giờ, nhưng đừng tin lời tôi. Hãy tiếp tục và kiểm tra nó để thấy sự khác biệt

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

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

Syntax in Python 2Show/Hide

Không có cách nào dễ dàng để xóa luồng trong Python 2, vì bản thân câu lệnh

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

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

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

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

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

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

Lưu ý rằng

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

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

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

>>>

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

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

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

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

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

Cho đến bây giờ, bạn chỉ xử lý các kiểu dữ liệu dựng sẵn như chuỗi và số, nhưng bạn sẽ thường muốn in các kiểu dữ liệu trừu tượng của riêng mình. 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 lợi thế của

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

>>>

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

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

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

Nếu bây giờ bạn tạo một thể hiện của lớp

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

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

>>>

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

Đó là biểu diễn mặc định của các đối tượng, bao gồm địa chỉ của chúng trong bộ nhớ, tên lớp tương ứng và mô-đun trong đó chúng được định nghĩa. Bạn sẽ khắc phục điều đó trong giây lát, nhưng chỉ để ghi lại, như một giải pháp thay thế nhanh chóng, bạn có thể kết hợp

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

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

Lớp ________ 2078 của bạn vừa trở thành một loại ________ 2077 chuyên biệt với hai thuộc tính mà bạn có thể tùy chỉnh

Ghi chú. Trong Python 3, câu lệnh

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

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

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

Điều này ngăn trình thông dịch nâng cao

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

Điều đó tốt hơn một

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

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

Ghi chú. Theo sau các ngôn ngữ và khuôn khổ khác, Python 3. 7 lớp dữ liệu được giới thiệu, mà bạn có thể coi là các bộ dữ liệu có thể thay đổi. Bằng cách này, bạn sẽ có được điều tốt nhất của cả hai thế giới

>>>

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

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

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

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

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

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

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

>>>

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

Ngược lại,

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

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

   093

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

   094

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

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

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

>>>

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

Lưu ý việc sử dụng một hàm dựng sẵn khác,

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

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

Ghi chú. Mặc dù bản thân

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

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

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

Xem xét lớp này với cả hai phương thức ma thuật, trả về các biểu diễn chuỗi thay thế của cùng một đối tượng

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

Nếu bạn in một đối tượng của lớp

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

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

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

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

>>>

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

Tuy nhiên, nếu bạn đặt cùng một biến

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

>>>

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

Đó là bởi vì các trình tự, chẳng hạn như danh sách và bộ dữ liệu, triển khai phương thức

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

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

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

Syntax in Python 2Show/Hide

Ngữ nghĩa của

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

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

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

Đây là một ví dụ về cùng một lớp

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

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

Như bạn có thể thấy, việc triển khai này ủy thác một số công việc để tránh trùng lặp bằng cách tự gọi hàm

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

Cả hai phương thức

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

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

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

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

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

Câu lệnh

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

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

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

>>>

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

Tuy nhiên, nếu bạn chạy cùng một mã trên hệ thống có mã hóa UTF-8, thì bạn sẽ nhận được cách viết đúng của một tên tiếng Nga phổ biến

>>>

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

Bạn nên chuyển đổi chuỗi thành Unicode càng sớm càng tốt, chẳng hạn như khi bạn đang đọc dữ liệu từ một tệp và sử dụng chuỗi đó một cách nhất quán ở mọi nơi trong mã của bạn. Đồng thời, bạn nên mã hóa Unicode trở lại bộ ký tự đã chọn ngay trước khi trình bày cho người dùng

Có vẻ như bạn có nhiều quyền kiểm soát hơn đối với biểu diễn chuỗi của các đối tượng trong Python 2 vì không còn phương thức

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

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

>>>

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

Sử dụng hàm

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

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

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

Bạn đã thấy rằng

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

>>>

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

Nó luôn có sẵn trong không gian tên chung để bạn có thể gọi nó trực tiếp, nhưng bạn cũng có thể truy cập nó thông qua một mô-đun từ thư viện chuẩn

>>>

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

Bằng cách này, bạn có thể tránh xung đột tên với các chức năng tùy chỉnh. Giả sử bạn muốn xác định lại

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

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

>>>

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

Bây giờ bạn có hai chức năng in riêng biệt giống như trong ngôn ngữ lập trình Java. 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'

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

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

Vì

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

Bên cạnh đó, các chức năng dễ dàng mở rộng hơn. Việc thêm một tính năng mới vào một chức năng cũng dễ dàng như thêm một đối số từ khóa khác, trong khi việc thay đổi ngôn ngữ để hỗ trợ tính năng mới đó thì cồng kềnh hơn nhiều. Ví dụ, hãy nghĩ về chuyển hướng luồng hoặc xóa bộ đệm

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

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

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

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

Ở đây, tham số

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

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

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

Ghi chú. Phần phụ thuộc là bất kỳ đoạn mã nào được yêu cầu bởi một đoạn mã khác

Dependency injection là một kỹ thuật được sử dụng trong thiết kế mã để làm cho nó dễ kiểm tra hơn, có thể tái sử dụng và mở rộng hơn. Bạn có thể đạt được điều đó bằng cách đề cập gián tiếp đến các phụ thuộc thông qua các giao diện trừu tượng và bằng cách cung cấp chúng theo kiểu đẩy chứ không phải kiểu kéo

Có một lời giải thích hài hước về việc tiêm phụ thuộc lan truyền trên Internet

tiêm phụ thuộc cho trẻ năm tuổi

Khi bạn đi lấy đồ trong tủ lạnh cho mình, bạn có thể gây rắc rối. Bạn có thể để cửa mở, bạn có thể nhận được thứ gì đó mà bố hoặc mẹ không muốn bạn có. Bạn thậm chí có thể đang tìm kiếm thứ gì đó mà chúng tôi thậm chí không có hoặc đã hết hạn

Điều bạn nên làm là nêu rõ nhu cầu, “Tôi cần uống gì đó trong bữa trưa,” và sau đó chúng tôi sẽ đảm bảo bạn có thứ gì đó khi ngồi ăn

— John Munsch, ngày 28 tháng 10 năm 2009. (Nguồn)

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

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

>>>

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

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

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

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

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

>>>

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

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

Ghi chú. Trong Python, bạn không thể đặt các câu lệnh, chẳng hạn như phép gán, câu điều kiện, vòng lặp, v.v., trong một hàm lambda ẩn danh. Nó phải là một biểu thức duy nhất

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

>>>

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

Python có cả câu lệnh điều kiện và biểu thức điều kiện. 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. Trong ví dụ trên, bạn quan tâm đến tác dụng phụ hơn là giá trị, đánh giá là

>>> 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ó hàm

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

>>> import os >>> os.linesep '\n' 02 Là một Tuyên bố trong 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ị. Nói cách khác, bạn sẽ không thể in một câu lệnh hoặc gán nó cho một biến như thế này

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

Đó là lỗi cú pháp trong Python 2

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

• phân công.

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

  847
• có điều kiện.

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

  848
• vòng.

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

  849
• quả quyết.

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

  850

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

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

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 cãi. 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 tuyên bố thường bao gồm các từ khóa dành riêng như

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

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

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

>>> 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 phần trước và tìm kiếm các giải thích chi tiết hơn về cú pháp trong Python 2

Tuy nhiên, bạn có thể giảm thiểu một số vấn đề đó 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

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

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

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

Để kích hoạt hàm

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

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

Từ giờ câu lệnh

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

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

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

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. This can be useful, for example in compression, but it sometimes leads to less readable code

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

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

>>> 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. There are a lot of built-in commands that start with a percent sign (

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

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

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

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

>>>

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

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

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

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

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

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

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

>>>

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

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

>>>

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

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

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

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

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

>>>

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

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

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

Surprisingly, the signature of

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

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

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

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

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

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

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

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

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

>>>

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

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

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

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

The most common ANSI escape sequences take the following form

ElementDescriptionExample Esc non-printable escape character

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

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

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

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

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

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

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

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

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

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

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

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

Building Console User Interfaces

While playing with ANSI escape codes is undeniably a ton of fun, in the real world you’d rather have more abstract building blocks to put together a user interface. There are a few libraries that provide such a high level of control over the terminal, but

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

Note. To use the

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

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

That’s because

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

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

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

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

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

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 phân đoạn mang tọa độ

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

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

Again, if you run this code now, it won’t display anything, because you must explicitly refresh the screen afterward

>>> 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. Assuming the snake isn’t growing, you can remove the tail and insert a new head at the beginning of the list

>>> 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. One way to fix this is by using the built-in

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

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

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

The direction will change on a keystroke, so you need to call

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

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

By default, however,

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

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

You’re almost done, but there’s just one last thing left. If you now loop this code, the snake will appear to be growing instead of moving. That’s because you have to erase the screen explicitly before each iteration

Finally, this is all you need to play the snake game in Python

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

This is merely scratching the surface of the possibilities that the

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

Living It Up With Cool Animations

Not only can animations make the user interface more appealing to the eye, but they also improve the overall user experience. When you provide early feedback to the user, for example, they’ll know if your program’s still working or if it’s time to kill it

To animate text in the terminal, you have to be able to freely move the cursor around. You can do this with one of the tools mentioned previously, that is ANSI escape codes or the

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

If the animation can be constrained to a single line of text, then you might be interested in two special escape character sequences

• Carriage return.

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

  08
• Backspace.

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

  13

The first one moves the cursor to the beginning of the line, whereas the second one moves it only one character to the left. They both work in a non-destructive way without overwriting text that’s already been written

Let’s take a look at a few examples

You’ll often want to display some kind of a spinning wheel to indicate a work in progress without knowing exactly how much time’s left to finish

Many command line tools use this trick while downloading data over the network. You can make a really simple stop motion animation from a sequence of characters that will cycle in a round-robin fashion

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

The loop gets the next character to print, then moves the cursor to the beginning of the line, and overwrites whatever there was before without adding a newline. You don’t want extra space between positional arguments, so separator argument must be blank. Also, notice the use of Python’s raw strings due to backslash characters present in the literal

When you know the remaining time or task completion percentage, then you’re able to show an animated progress bar

First, you need to calculate how many hashtags to display and how many blank spaces to insert. Next, you erase the line and build the bar from scratch

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

As before, each request for update repaints the entire line

Note. There’s a feature-rich

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

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ờ

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

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

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 hiện 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à

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

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

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

Để 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. If you’re looking for an error, you don’t want to see all the warnings or debug messages, for example. It’s trivial to disable or enable messages at certain log levels through the configuration, without even touching the code

With logging, you can keep your debug messages separate from the standard output. All the log messages go to the standard error stream by default, which can conveniently show up in different colors. However, you can redirect log messages to separate files, even for individual modules

Quite commonly, misconfigured logging can lead to running out of space on the server’s disk. To prevent that, you may set up log rotation, which will keep the log files for a specified duration, such as one week, or once they hit a certain size. Nevertheless, it’s always a good practice to archive older logs. Some regulations enforce that customer data be kept for as long as five years

Compared to other programming languages, logging in Python is simpler, because the

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

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

You can call functions defined at the module level, which are hooked to the root logger, but more the common practice is to obtain a dedicated logger for each of your source files

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

The advantage of using custom loggers is more fine-grain control. They’re usually named after the module they were defined in through the

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

Note. There’s a somewhat related

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

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

Điều đó nói rằng, bạn có thể làm cho chúng hoạt động cùng nhau bằng cách gọi

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

One last reason to switch from the

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

Debugging

The truth is that neither tracing nor logging can be considered real debugging. Để 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, có tên không ngạc nhiên là

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

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

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

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

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

>>> 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 để chấp nhận đầu vào từ người dùng, được gọi là

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

>>>

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

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

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

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

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

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

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

Trăn 2 Trăn 3

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

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

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

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

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

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

>>>

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

Mô-đun

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

>>>

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

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

  207

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

  208

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

  209

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

  210

Tuy nhiên, điều đáng nói là một công cụ dòng lệnh có tên là

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

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

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

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

Điều đó không tuyệt sao?