If you’re like most Python users, including me, then you probably started your Python journey by learning about
>>> import os
>>> os.linesep
'\r\n'
94. It helped you write your very own >>> import os
>>> os.linesep
'\r\n'
95 one-liner. You can use it to display formatted messages onto the screen and perhaps find some bugs. But if you think that’s all there is to know about Python’s >>> import os
>>> os.linesep
'\r\n'
94 function, then you’re missing out on a lotKeep reading to take full advantage of this seemingly boring and unappreciated little function. Hướng dẫn này sẽ giúp bạn bắt kịp tốc độ sử dụng Python
>>> import os
>>> os.linesep
'\r\n'
94 một cách hiệu quả. However, prepare for a deep dive as you go through the sections. You may be surprised how much >>> import os
>>> os.linesep
'\r\n'
94 has to offerBy the end of this tutorial, you’ll know how to
- Avoid common mistakes with Python’s
94>>> import os >>> os.linesep '\r\n'
- Deal with newlines, character encodings, and buffering
- Write text to files
- Mock
94 in unit tests>>> import os >>> os.linesep '\r\n'
- Build advanced user interfaces in the terminal
If you’re a complete beginner, then you’ll benefit most from reading the first part of this tutorial, which illustrates the essentials of printing in Python. Otherwise, feel free to skip that part and jump around as you see fit
Note.
>>> import os
>>> os.linesep
'\r\n'
94 was a major addition to Python 3, in which it replaced the old >>> import os
>>> os.linesep
'\n'
02 statement available in Python 2There were a number of good reasons for that, as you’ll see shortly. Although this tutorial focuses on Python 3, it does show the old way of printing in Python for reference
Free Bonus. Click here to get our free Python Cheat Sheet that shows you the basics of Python 3, like working with data types, dictionaries, lists, and Python functions
Printing in a Nutshell
Let’s jump in by looking at a few real-life examples of printing in Python. By the end of this section, you’ll know every possible way of calling
>>> import os
>>> os.linesep
'\r\n'
94. Or, in programmer lingo, you’d say you’ll be familiar with the function signatureRemove adsCalling >>> import os
>>> os.linesep
'\r\n'
94
>>> import os
>>> os.linesep
'\r\n'
The simplest example of using Python
>>> import os
>>> os.linesep
'\r\n'
94 requires just a few keystrokes>>>
>>> import os
>>> os.linesep
'\r\n'
2You 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'
94 multiple times like this to add vertical space. It’s just as if you were hitting Enter on your keyboard in a word processor. 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'
07 moduleThis will immediately tell you that Windows and DOS represent the newline as a sequence of
>>> import os
>>> os.linesep
'\n'
08 followed by >>> import os
>>> os.linesep
'\n'
09>>>
>>> import os
>>> os.linesep
'\r\n'
On Unix, Linux, and recent versions of macOS, it’s a single
>>> import os
>>> os.linesep
'\n'
09 character>>>
>>> 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\n'
0Lưu ý cách các ký tự này xuất hiện trong chuỗi ký tự. They use special syntax with a preceding backslash [
>>> import os
>>> os.linesep
'\n'
11] to denote the start of an escape character sequence. Such sequences allow for representing control characters, which would be otherwise invisible on screenMost programming languages come with a predefined set of escape sequences for special characters such as these
12. backslash>>> import os >>> os.linesep '\n'
13. backspace>>> import os >>> os.linesep '\n'
14. tab>>> import os >>> os.linesep '\n'
08. carriage return [CR]>>> import os >>> os.linesep '\n'
09. newline, also known as line feed [LF]>>> import os >>> os.linesep '\n'
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'
17 function>>>
>>> import os
>>> os.linesep
'\r\n'
8Keep 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'
94 without arguments results in a blank line, which is a line comprised solely of the newline character. Don’t confuse this with an empty line, which doesn’t contain any characters at all, not even the newlineYou can use Python’s string literals to visualize these two
>>> import os
>>> os.linesep
'\r\n'
0The first one is one character long, whereas the second one has no content
Note. To remove the newline character from a string in Python, use its
>>> import os
>>> os.linesep
'\n'
19 method, like this>>>
>>> import os
>>> os.linesep
'\r\n'
2This strips any trailing whitespace from the right edge of the string of characters
In a more common scenario, you’d want to communicate some message to the end user. 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'
94>>>
>>> import os
>>> os.linesep
'\r\n'
4Đ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'
21] hoặc dấu ngoặc kép [>>> import os
>>> os.linesep
'\n'
22]. Theo hướng dẫn phong cách PEP 8 chính thức, bạn chỉ nên chọn một và tiếp tục sử dụng nó một cách nhất quán. Không có sự khác biệt, trừ khi bạn cần lồng cái này vào cái khácVí 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'
7Đ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'
8Thủ thuật tương tự sẽ hoạt động theo cách khác
>>> import os
>>> os.linesep
'\r\n'
0Ngoà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'
1Chạy trốn là tốt và bảnh bao, nhưng đôi khi nó có thể cản trở. Specifically, when you need your string to contain relatively many backslash characters in literal form
One classic example is a file path on Windows
>>> import os
>>> os.linesep
'\r\n'
2Notice how each backslash character needs to be escaped with yet another backslash
This is even more prominent with regular expressions, which quickly get convoluted due to the heavy use of special characters
>>> import os
>>> os.linesep
'\r\n'
3Fortunately, you can turn off character escaping entirely with the help of raw-string literals. Simply prepend an
>>> import os
>>> os.linesep
'\n'
23 or >>> import os
>>> os.linesep
'\n'
24 before the opening quote, and now you end up with this>>> import os
>>> os.linesep
'\r\n'
4That’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'
25 or >>> import os
>>> os.linesep
'\n'
26, which are often used as docstringsHere’s an example
>>> import os
>>> os.linesep
'\r\n'
5To prevent an initial newline, simply put the text right after the opening
>>> import os
>>> os.linesep
'\n'
26>>> import os
>>> os.linesep
'\r\n'
6You can also use a backslash to get rid of the newline
>>> import os
>>> os.linesep
'\r\n'
7To remove indentation from a multi-line string, you might take advantage of the built-in
>>> import os
>>> os.linesep
'\n'
28 module>>>
>>> import os
>>> os.linesep
'\r\n'
8This will take care of unindenting paragraphs for you. There are also a few other useful functions in
>>> import os
>>> os.linesep
'\n'
28 for text alignment you’d find in a word processorSecondly, 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'
9Lastly, you could pass an expression, like string concatenation, to be evaluated before printing the result
>>>
>>> import os
>>> os.linesep
'\n'
0In 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'
1Moreover, 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'
2That’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'
3Unless 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'
30 is a global built-in function that converts an object into its string representationYou can call it directly on any object, for example, a number
>>>
>>> import os
>>> os.linesep
'\n'
4Built-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'
94 will accept anything regardless of its typeSo 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'
5Watch out for the
>>> import os
>>> os.linesep
'\n'
32 constant, though. Despite being used to indicate an absence of a value, it will show up as >>> import os
>>> os.linesep
'\n'
33 rather than an empty string>>>
>>> import os
>>> os.linesep
'\n'
6How does
>>> import os
>>> os.linesep
'\r\n'
94 know how to work with all these different types? Well, the short answer is that it doesn’t. It implicitly calls >>> import os
>>> os.linesep
'\n'
30 behind the scenes to type cast any object into a string. Afterward, it treats strings in a uniform wayLater 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'
94 with a single argument or without any arguments. You know how to print fixed or formatted messages onto the screen. The next subsection will expand on message formatting a little bitSyntax in Python 2Show/Hide
Để đạt được kết quả tương tự trong thế hệ ngôn ngữ trước, bạn thường muốn bỏ dấu ngoặc đơn kèm theo văn bản
>>> import os
>>> os.linesep
'\n'
7Đó là bởi vì hồi đó
>>> import os
>>> os.linesep
'\n'
02 không phải là một chức năng, như bạn sẽ thấy trong phần tiếp theo. Tuy nhiên, lưu ý rằng trong một số trường hợp, dấu ngoặc đơn trong Python là thừa. Sẽ không hại gì nếu bao gồm chúng vì chúng sẽ bị bỏ qua. Điều đó có nghĩa là bạn nên sử dụng câu lệnh >>> import os
>>> os.linesep
'\n'
02 như thể nó là một hàm? Ví dụ: dấu ngoặc đơn bao quanh một biểu thức hoặc một chữ là tùy chọn. Cả hai hướng dẫn đều tạo ra cùng một kết quả trong Python 2
>>>
>>> import os
>>> os.linesep
'\n'
8Dấu ngoặc tròn thực sự là một phần của biểu thức chứ không phải là câu lệnh
>>> import os
>>> os.linesep
'\n'
02. Nếu biểu thức của bạn tình cờ chỉ chứa một mục, thì có vẻ như bạn hoàn toàn không bao gồm dấu ngoặcMặt khác, đặt dấu ngoặc đơn xung quanh nhiều mục sẽ tạo thành một bộ
>>>
>>> import os
>>> os.linesep
'\n'
9Đây là một nguồn nhầm lẫn đã biết. Trên thực tế, bạn cũng sẽ nhận được một bộ bằng cách thêm dấu phẩy ở cuối vào mục duy nhất được bao quanh bởi dấu ngoặc đơn
>>>
>>> import os
>>> os.linesep
'\r\n'
00Điểm mấu chốt là bạn không nên gọi
>>> import os
>>> os.linesep
'\n'
02 bằng dấu ngoặc trong Python 2. Mặc dù, để hoàn toàn chính xác, bạn có thể giải quyết vấn đề này với sự trợ giúp của nhập khẩu >>> import os
>>> os.linesep
'\n'
41, bạn sẽ đọc thêm về điều này trong phần có liên quanRemove adsTách nhiều đối số
Bạn đã thấy
>>> import os
>>> os.linesep
'\r\n'
94 được gọi mà không có bất kỳ đối số nào để tạo ra một dòng trống và sau đó được gọi với một đối số duy nhất để hiển thị một thông báo cố định hoặc được định dạngTuy nhiên, hóa ra hàm này có thể chấp nhận bất kỳ số lượng đối số vị trí nào, bao gồm không, một hoặc nhiều đối số. Điều đó rất hữu ích trong trường hợp phổ biến về định dạng thư, nơi bạn muốn kết hợp một số thành phần lại với nhau
Đối số vị tríHiển thị/Ẩn
Các đối số có thể được chuyển đến một chức năng theo một số cách. Một cách là đặt tên rõ ràng cho các đối số khi bạn gọi hàm, như thế này
>>>
>>> import os
>>> os.linesep
'\r\n'
01Vì các đối số có thể được xác định duy nhất theo tên nên thứ tự của chúng không thành vấn đề. Trao đổi chúng ra vẫn sẽ cho kết quả tương tự
>>>
>>> import os
>>> os.linesep
'\r\n'
02Ngược lại, các đối số được truyền không có tên được xác định theo vị trí của chúng. Đó là lý do tại sao các đối số vị trí cần tuân thủ nghiêm ngặt thứ tự do chữ ký hàm đặt ra
>>>
>>> import os
>>> os.linesep
'\r\n'
03>>> import os
>>> os.linesep
'\r\n'
94 cho phép số lượng đối số vị trí tùy ý nhờ tham số >>> import os
>>> os.linesep
'\n'
44Hãy xem ví dụ này
>>>
>>> import os
>>> os.linesep
'\r\n'
04>>> import os
>>> os.linesep
'\r\n'
94 nối tất cả bốn đối số được truyền cho nó và nó chèn một khoảng trắng giữa chúng để bạn không nhận được một thông báo bị nén như >>> import os
>>> os.linesep
'\n'
46Lưu ý rằng nó cũng đảm nhiệm việc truyền kiểu thích hợp bằng cách gọi ngầm
>>> import os
>>> os.linesep
'\n'
30 trên mỗi đối số trước khi nối chúng lại với nhau. Nếu bạn nhớ lại từ tiểu mục trước, một phép nối ngây thơ có thể dễ dàng dẫn đến lỗi do các loại không tương thích>>>
>>> import os
>>> os.linesep
'\r\n'
05Ngoài việc chấp nhận một số lượng đối số vị trí khác nhau,
>>> import os
>>> os.linesep
'\r\n'
94 định nghĩa bốn đối số có tên hoặc từ khóa, là tùy chọn vì tất cả chúng đều có giá trị mặc định. Bạn có thể xem tài liệu ngắn gọn của họ bằng cách gọi >>> import os
>>> os.linesep
'\n'
49 từ trình thông dịch tương tácBây giờ hãy tập trung vào
>>> import os
>>> os.linesep
'\n'
50. Nó là viết tắt của dấu phân cách và được gán một khoảng trắng [>>> import os
>>> os.linesep
'\n'
51] theo mặc định. Nó xác định giá trị để nối các phần tử vớiNó phải là một chuỗi hoặc
>>> import os
>>> os.linesep
'\n'
32, nhưng cái sau có tác dụng tương tự như khoảng trắng mặc định>>>
>>> import os
>>> os.linesep
'\r\n'
06Nếu bạn muốn loại bỏ hoàn toàn dấu phân cách, thay vào đó, bạn phải chuyển một chuỗi trống [
>>> import os
>>> os.linesep
'\n'
53]>>>
>>> import os
>>> os.linesep
'\r\n'
07Bạn có thể muốn
>>> import os
>>> os.linesep
'\r\n'
94 tham gia các đối số của nó dưới dạng các dòng riêng biệt. Trong trường hợp đó, chỉ cần chuyển ký tự dòng mới đã thoát được mô tả trước đó>>>
>>> import os
>>> os.linesep
'\r\n'
08Một ví dụ hữu ích hơn về tham số
>>> import os
>>> os.linesep
'\n'
50 sẽ in một cái gì đó như đường dẫn tệp>>>
>>> import os
>>> os.linesep
'\r\n'
09Hãy nhớ rằng dấu phân cách nằm giữa các phần tử chứ không phải xung quanh chúng, vì vậy bạn cần tính đến điều đó theo cách này hay cách khác
>>>
>>> import os
>>> os.linesep
'\r\n'
80Cụ thể, bạn có thể chèn một ký tự gạch chéo [
>>> import os
>>> os.linesep
'\n'
56] vào đối số vị trí đầu tiên hoặc sử dụng một chuỗi trống làm đối số đầu tiên để thực thi dấu gạch chéo đầuGhi chú. Hãy cẩn thận về việc tham gia các phần tử của danh sách hoặc bộ dữ liệu
Thực hiện thủ công sẽ dẫn đến một
>>> import os
>>> os.linesep
'\n'
57 nổi tiếng nếu ít nhất một trong các phần tử không phải là một chuỗi>>>
>>> import os
>>> os.linesep
'\r\n'
81Sẽ an toàn hơn nếu chỉ giải nén trình tự bằng toán tử sao [
>>> import os
>>> os.linesep
'\n'
58] và để >>> import os
>>> os.linesep
'\r\n'
94 xử lý việc truyền kiểu>>>
>>> import os
>>> os.linesep
'\r\n'
82Giải nén thực sự giống như gọi
>>> import os
>>> os.linesep
'\r\n'
94 với các phần tử riêng lẻ của danh sáchMột ví dụ thú vị khác có thể là xuất dữ liệu sang định dạng giá trị được phân tách bằng dấu phẩy [CSV]
>>>
>>> import os
>>> os.linesep
'\r\n'
83Điều này sẽ không xử lý các trường hợp cạnh như thoát dấu phẩy một cách chính xác, nhưng đối với các trường hợp sử dụng đơn giản, nó nên làm. Dòng trên sẽ hiển thị trong cửa sổ đầu cuối của bạn. Để lưu nó vào một tệp, bạn phải chuyển hướng đầu ra. Ở phần sau của phần này, bạn sẽ thấy cách sử dụng
>>> import os
>>> os.linesep
'\r\n'
94 để viết văn bản vào tệp trực tiếp từ PythonCuối cùng, tham số
>>> import os
>>> os.linesep
'\n'
50 không chỉ giới hạn ở một ký tự. Bạn có thể nối các phần tử với các chuỗi có độ dài bất kỳ>>>
>>> import os
>>> os.linesep
'\r\n'
84Trong các phần phụ sắp tới, bạn sẽ khám phá các đối số từ khóa còn lại của hàm
>>> import os
>>> os.linesep
'\r\n'
94Syntax in Python 2Show/Hide
Để in nhiều phần tử trong Python 2, bạn phải bỏ dấu ngoặc đơn xung quanh chúng, giống như trước đây
>>>
>>> import os
>>> os.linesep
'\r\n'
85Mặt khác, nếu bạn giữ chúng, bạn sẽ chuyển một phần tử bộ dữ liệu duy nhất cho câu lệnh
>>> import os
>>> os.linesep
'\n'
02>>>
>>> import os
>>> os.linesep
'\r\n'
86Hơn nữa, không có cách nào thay đổi dấu tách mặc định của các phần tử đã nối trong Python 2, vì vậy một cách giải quyết khác là sử dụng phép nội suy chuỗi như vậy
>>>
>>> import os
>>> os.linesep
'\r\n'
87Đó là cách định dạng chuỗi mặc định cho đến khi phương thức
>>> import os
>>> os.linesep
'\n'
65 được nhập từ Python 3Remove adsNgă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'
94 sẽ tiếp tục trên cùng một dòng. Các ví dụ cổ điển bao gồm cập nhật tiến trình của một hoạt động dài hạn hoặc nhắc người dùng nhập liệu. Trong trường hợp sau, bạn muốn người dùng nhập câu trả lời trên cùng một dòng>>> import os
>>> os.linesep
'\r\n'
88Nhiề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'
94 thông qua các thư viện tiêu chuẩn của chúng, nhưng chúng cho phép bạn quyết định có thêm một dòng mới hay không. Ví dụ: trong Java và C#, bạn có hai hàm riêng biệt, trong khi các ngôn ngữ khác yêu cầu bạn phải thêm rõ ràng >>> import os
>>> os.linesep
'\n'
09 vào cuối chuỗi ký tự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'
69C>>> import os
>>> os.linesep
'\n'
70C++>>> import os
>>> os.linesep
'\n'
71Ngược lại, hàm
>>> import os
>>> os.linesep
'\r\n'
94 của Python luôn thêm >>> import os
>>> os.linesep
'\n'
09 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'
74, cho biết nội dung kết thúc dòng bằngVề mặt ngữ nghĩa, tham số
>>> import os
>>> os.linesep
'\n'
74 gần giống với tham số >>> import os
>>> os.linesep
'\n'
50 mà bạn đã thấy trước đó- Nó phải là một chuỗi hoặc
32>>> import os >>> os.linesep '\n'
- Nó có thể dài tùy ý
- Nó có giá trị mặc định là
78>>> import os >>> os.linesep '\n'
- Nếu bằng
32, nó sẽ có tác dụng giống như giá trị mặc định>>> import os >>> os.linesep '\n'
- 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'
94 mà không cần tranh luận. Vì bạn không cung cấp bất kỳ đối số vị trí nào cho hàm nên không có gì được nối và do đó, dấu phân cách mặc định hoàn toàn không được sử dụng. Tuy nhiên, giá trị mặc định của >>> import os
>>> os.linesep
'\n'
74 vẫn được áp dụng và một dòng trống xuất hiệnGhi chú. Bạn có thể thắc mắc tại sao tham số
>>> import os
>>> os.linesep
'\n'
74 có giá trị mặc định cố định thay vì bất kỳ giá trị nào có ý nghĩa trên hệ điều hành của bạnChà, bạn không phải lo lắng về 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'
94 sẽ tự động xử lý việc chuyển đổi. Chỉ cần nhớ luôn sử dụng chuỗi thoát >>> import os
>>> os.linesep
'\n'
09 trong chuỗi ký tựĐâ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'
89Ví 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'
00On the flip side, when you open a file for reading with
>>> import os
>>> os.linesep
'\n'
86, you don’t need to care about newline representation either. Hàm này sẽ dịch bất kỳ dòng mới nào dành riêng cho hệ thống mà nó gặp thành một >>> import os
>>> os.linesep
'\n'
78 chung. Đồng thời, bạn có quyền kiểm soát cách xử lý các dòng mới ở cả đầu vào và đầu ra nếu bạn thực sự cần điều đóĐể 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'
74>>> import os
>>> os.linesep
'\r\n'
01Mặc dù đây là hai cuộc gọi
>>> import os
>>> os.linesep
'\r\n'
94 riêng biệt, có thể thực hiện cách nhau một thời gian dài, cuối cùng bạn sẽ chỉ thấy một dòng. Đầu tiên, nó sẽ trông như thế này>>> import os
>>> os.linesep
'\r\n'
02Tuy nhiên, sau cuộc gọi thứ hai đến
>>> import os
>>> os.linesep
'\r\n'
94, dòng tương tự sẽ xuất hiện trên màn hình như>>> import os
>>> os.linesep
'\r\n'
03Như với
>>> import os
>>> os.linesep
'\n'
50, bạn có thể sử dụng >>> import os
>>> os.linesep
'\n'
74 để nối các phần riêng lẻ thành một khối văn bản lớn bằng dấu tách tùy chỉnh. Tuy nhiên, thay vì nối nhiều đối số, nó sẽ nối văn bản từ mỗi lệnh gọi hàm vào cùng một dòng>>> import os
>>> os.linesep
'\r\n'
04These three instructions will output a single line of text
>>> import os
>>> os.linesep
'\r\n'
05Bạn có thể trộn hai đối số từ khóa
>>> import os
>>> os.linesep
'\r\n'
06Bạ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'
07Khô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'
08Nó sẽ in ra đoạn văn bản sau
>>> import os
>>> os.linesep
'\r\n'
09Như bạn có thể thấy, đối số từ khóa
>>> import os
>>> os.linesep
'\n'
74 sẽ chấp nhận các chuỗi tùy ý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'
94 sẽ dẫn đến một ký tự dòng mới dư thừa>>>
>>> import os
>>> os.linesep
'\r\n'
20There are two newlines after each line of text. 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'
21Ngoà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'
94. Bạn sẽ sử dụng đối số từ khóa >>> import os
>>> os.linesep
'\n'
74 để làm điều đó>>>
>>> import os
>>> os.linesep
'\r\n'
22Bằ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'
94Syntax 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'
23Tuy 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'
98 thay vì >>> import os
>>> os.linesep
'\n'
99 trong Python 3. Bạn có thể kiểm tra điều này với đoạn mã sau>>> import os
>>> os.linesep
'\r\n'
24Notice there’s a space between the words
>>> import os
>>> os.linesep
'\r\n'
000 and >>> import os
>>> os.linesep
'\r\n'
001>>> import os
>>> os.linesep
'\r\n'
25Để 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'
94 từ >>> import os
>>> os.linesep
'\n'
41 hoặc quay trở lại mô-đun >>> import os
>>> os.linesep
'\r\n'
004>>> import os
>>> os.linesep
'\r\n'
26Đ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'
27Trong khi sử dụng mô-đun
>>> import os
>>> os.linesep
'\r\n'
004 cho phép bạn kiểm soát những gì được in ra đầu ra tiêu chuẩn, mã sẽ trở nên lộn xộn hơn một chútRemove adsIn ra một tập tin
Dù bạn có tin hay không thì tùy,
>>> import os
>>> os.linesep
'\r\n'
94 không biết cách chuyển tin nhắn thành văn bản trên màn hình của bạn và nói thẳng ra là không cần. Đó là công việc dành cho các lớp mã cấp thấp hơn, hiểu các byte và biết cách đẩy chúng xung quanh>>> import os
>>> os.linesep
'\r\n'
94 là một sự trừu tượng hóa trên các lớp này, cung cấp một giao diện thuận tiện chỉ ủy thác việc in thực tế cho một đối tượng giống như luồng hoặc tệp. Luồng có thể là bất kỳ tệp nào trên đĩa của bạn, ổ cắm mạng hoặc có thể là bộ đệm trong bộ nhớNgoài ra, có ba luồng tiêu chuẩn được cung cấp bởi hệ điều hành
008. đầu vào tiêu chuẩn>>> import os >>> os.linesep '\r\n'
009. đầu ra tiêu chuẩn>>> import os >>> os.linesep '\r\n'
010. lỗi tiêu chuẩn>>> import os >>> os.linesep '\r\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'
28Trừ khi có hướng dẫn khác,
>>> import os
>>> os.linesep
'\r\n'
94 sẽ mặc định ghi vào đầu ra tiêu chuẩn. Tuy nhiên, bạn có thể yêu cầu hệ điều hành của mình tạm thời hoán đổi >>> import os
>>> os.linesep
'\r\n'
009 cho một luồng tệp, để mọi đầu ra kết thúc trong tệp đó thay vì màn hình>>> import os
>>> os.linesep
'\r\n'
29Đó 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'
009 ở chỗ nó cũng hiển thị trên màn hình. Tuy nhiên, đó là một luồng riêng biệt, với mục đích là ghi lại các thông báo lỗi để chẩn đoán. Bằng cách chuyển hướng một hoặc cả hai, bạn có thể giữ mọi thứ sạch sẽGhi chú. Để chuyển hướng
>>> import os
>>> os.linesep
'\r\n'
010, bạn cần biết về bộ mô tả tệp, còn được gọi là trình xử lý tệpChú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. Bên dưới, 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'
0080>>> import os
>>> os.linesep
'\r\n'
0091>>> import os
>>> os.linesep
'\r\n'
0102Biế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'
018Chuyển hướng >>> import os
>>> os.linesep
'\r\n'
009>>> import os
>>> os.linesep
'\r\n'
020Chuyển hướng >>> import os
>>> os.linesep
'\r\n'
010>>> import os
>>> os.linesep
'\r\n'
022Chuyển hướng >>> import os
>>> os.linesep
'\r\n'
009 và >>> import os
>>> os.linesep
'\r\n'
010 sang các tệp riêng biệt>>> import os
>>> os.linesep
'\r\n'
025Chuyển hướng >>> import os
>>> os.linesep
'\r\n'
009 và >>> import os
>>> os.linesep
'\r\n'
010 sang cùng một tệpLư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'
009 và >>> import os
>>> os.linesep
'\r\n'
010Trong khi cả
>>> import os
>>> os.linesep
'\r\n'
009 và >>> import os
>>> os.linesep
'\r\n'
010 đều ở chế độ chỉ ghi, thì >>> import os
>>> os.linesep
'\r\n'
008 là chế độ chỉ đọc. Bạn có thể coi đầu vào tiêu chuẩn là bàn phím của mình, nhưng cũng giống như hai bàn phím kia, bạn có thể hoán đổi >>> import os
>>> os.linesep
'\r\n'
008 để lấy một tệp để đọc dữ liệu từ đó.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'
004 được tích hợp sẵn>>>
>>> import os
>>> os.linesep
'\r\n'
40Như 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'
037 và >>> import os
>>> os.linesep
'\r\n'
038 cũng như các phương thức >>> import os
>>> os.linesep
'\r\n'
039 và >>> import os
>>> os.linesep
'\r\n'
040 cùng nhiều phương thức khácTheo mặc định,
>>> import os
>>> os.linesep
'\r\n'
94 bị ràng buộc với >>> import os
>>> os.linesep
'\r\n'
042 thông qua đối số >>> import os
>>> os.linesep
'\r\n'
043 của nó, nhưng bạn có thể thay đổi điều đó. Sử dụng đối số từ khóa đó để chỉ ra một tệp được mở ở chế độ ghi hoặc nối thêm, để thư đi thẳng đến tệp đó>>> import os
>>> os.linesep
'\r\n'
41Đ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
For more information on working with files in Python, you can check out Reading and Writing Files in Python [Guide]
Ghi chú. Đừng thử sử dụng
>>> import os
>>> os.linesep
'\r\n'
94 để ghi dữ liệu nhị phân vì nó chỉ phù hợp với văn bảnChỉ cần gọi trực tiếp tệp nhị phân là
>>> import os
>>> os.linesep
'\r\n'
040>>> import os
>>> os.linesep
'\r\n'
42Nế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'
042 là một luồng ký tự>>>
>>> import os
>>> os.linesep
'\r\n'
43Thay 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'
44Điều này in một chữ cái viết hoa
>>> import os
>>> os.linesep
'\r\n'
047 và một ký tự xuống dòng, tương ứng với các giá trị thập phân là 65 và 10 trong ASCII. Tuy nhiên, chúng được mã hóa bằng cách sử dụng ký hiệu thập lục phân theo byte chữLưu ý rằng
>>> import os
>>> os.linesep
'\r\n'
94 không có quyền kiểm soát mã hóa ký tự. Luồng có trách nhiệm mã hóa chính xác các chuỗi Unicode đã nhận thành byte. Trong hầu hết các trường hợp, bạn sẽ không tự đặt mã hóa vì UTF-8 mặc định là những gì bạn muốn. Nếu bạn thực sự cần, có lẽ đối với các hệ thống cũ, bạn có thể sử dụng đối số >>> import os
>>> os.linesep
'\r\n'
038 của >>> import os
>>> os.linesep
'\n'
86>>> import os
>>> os.linesep
'\r\n'
45Thay 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'
94 trong các bài kiểm tra đơn vị>>>
>>> import os
>>> os.linesep
'\r\n'
46Nế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'
94, mà bạn sẽ thấy trong tiểu mục tiếp theo. Nó có lẽ ít được sử dụng nhất trong số chúng. Tuy nhiên, có những lúc nó thực sự cần thiếtSyntax in Python 2Show/Hide
Có một cú pháp đặc biệt trong Python 2 để thay thế
>>> import os
>>> os.linesep
'\r\n'
042 mặc định bằng một tệp tùy chỉnh trong câu lệnh >>> import os
>>> os.linesep
'\n'
02>>> import os
>>> os.linesep
'\r\n'
47Bở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'
055 trong Python 2, nên câu lệnh >>> import os
>>> os.linesep
'\n'
02 có thể xử lý tốt dữ liệu nhị phân>>> import os
>>> os.linesep
'\r\n'
48Mặc dù, có một vấn đề với mã hóa ký tự. Hàm
>>> import os
>>> os.linesep
'\n'
86 trong Python 2 thiếu tham số >>> import os
>>> os.linesep
'\r\n'
038, điều này thường dẫn đến sự cố đáng sợ >>> import os
>>> os.linesep
'\r\n'
059>>>
>>> import os
>>> os.linesep
'\r\n'
49Lư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'
70Ngoà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'
71Đặ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'
72Tuy 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'
060 tích hợp sẵn>>> import os
>>> os.linesep
'\r\n'
73Nó 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
Remove adsĐệm cuộc gọi >>> import os
>>> os.linesep
'\r\n'
94
>>> import os
>>> os.linesep
'\r\n'
Trong tiểu mục trước, bạn đã biết rằng
>>> import os
>>> os.linesep
'\r\n'
94 ủy quyền in cho một đối tượng giống như tệp, chẳng hạn như >>> import os
>>> os.linesep
'\r\n'
042. Tuy nhiên, một số luồng đệm một số hoạt động I/O nhất định để nâng cao hiệu suất, điều này có thể cản trở. Hãy xem xét một ví dụ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'
74Nỗ 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'
75Miễn là biến
>>> import os
>>> os.linesep
'\r\n'
064 lớn hơn 0, mã sẽ tiếp tục nối thêm văn bản mà không có dòng mới ở cuối và sau đó chuyển sang chế độ ngủ trong một giây. Cuối cùng, khi đếm ngược kết thúc, nó sẽ in >>> import os
>>> os.linesep
'\r\n'
065 và kết thúc dòngThậ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
- Không có bộ đệm
- đệm dòng
- đệ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'
94 xóa mạnh luồng mà không cần chờ ký tự xuống dòng trong bộ đệm bằng cách sử dụng cờ >>> import os
>>> os.linesep
'\r\n'
067 của nó>>> import os
>>> os.linesep
'\r\n'
76Đó 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'
94 bao gồm tất cả các tham số của nó. Bạn biết mục đích của chúng và khi nào nên sử dụng chúng. Tuy nhiên, việc hiểu chữ ký chỉ là bước đầu. Trong các phần sắp tới, bạn sẽ thấy tại saoSyntax 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'
02 không cho phép thực hiện điều đó. Bạn cần xử lý lớp cấp thấp hơn của nó, đây là đầu ra tiêu chuẩn và gọi nó trực tiếp>>> import os
>>> os.linesep
'\r\n'
77Ngoà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'
070 cho trình thông dịch Python hoặc bằng cách thiết lập biến môi trường >>> import os
>>> os.linesep
'\r\n'
071>>> import os
>>> os.linesep
'\r\n'
78Lưu ý rằng
>>> import os
>>> os.linesep
'\r\n'
94 đã được nhập vào Python 2 và được cung cấp thông qua mô-đun >>> import os
>>> os.linesep
'\n'
41. Thật không may, nó không đi kèm với tham số >>> import os
>>> os.linesep
'\r\n'
067>>>
>>> import os
>>> os.linesep
'\r\n'
79Nhữ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'
94. Bạn có thể hiển thị các chuỗi tài liệu của các đối tượng khác nhau trong Python bằng cách sử dụng hàm >>> import os
>>> os.linesep
'\r\n'
076 tích hợpIn 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. Let’s have a look at different ways of defining them
Đố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'
077, có sẵn trong thư viện tiêu chuẩn. Named tuples have a neat textual representation out of the box>>>
>>> import os
>>> os.linesep
'\r\n'
80That’s great as long as holding data is enough, but in order to add behaviors to the
>>> import os
>>> os.linesep
'\r\n'
078 type, you’ll eventually need to define a class. Hãy xem ví dụ này>>> import os
>>> os.linesep
'\r\n'
81If you now create an instance of the
>>> import os
>>> os.linesep
'\r\n'
078 class and try to print it, you’ll get this bizarre output, which is quite different from the equivalent >>> import os
>>> os.linesep
'\r\n'
077>>>
>>> import os
>>> os.linesep
'\r\n'
82Đó 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'
077 và một lớp tùy chỉnh thông qua kế thừa>>> import os
>>> os.linesep
'\r\n'
83Lớ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ú. In Python 3, the
>>> import os
>>> os.linesep
'\r\n'
084 statement can be replaced with the ellipsis [>>> import os
>>> os.linesep
'\r\n'
085] literal to indicate a placeholder>>> import os
>>> os.linesep
'\r\n'
84Điều này ngăn trình thông dịch nâng cao
>>> import os
>>> os.linesep
'\r\n'
086 do thiếu khối mã thụt lềĐiều đó tốt hơn một
>>> import os
>>> os.linesep
'\r\n'
077 đơn giản, bởi vì bạn không chỉ được in miễn phí mà còn có thể thêm các phương thức và thuộc tính tùy chỉnh vào lớp. Tuy nhiên, nó giải quyết một vấn đề trong khi giới thiệu một vấn đề khác. Hãy nhớ rằng các bộ dữ liệu, bao gồm cả các bộ dữ liệu được đặt tên, là bất biến trong Python, vì vậy chúng không thể thay đổi giá trị của chúng sau khi được tạoĐú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'
85Cú 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'
94 gọi ngầm hàm >>> import os
>>> os.linesep
'\n'
30 tích hợp để chuyển đổi các đối số vị trí của nó thành các chuỗi. Thật vậy, gọi >>> import os
>>> os.linesep
'\n'
30 theo cách thủ công đối với một thể hiện của lớp >>> import os
>>> os.linesep
'\r\n'
078 thông thường mang lại kết quả tương tự như in nó>>>
>>> import os
>>> os.linesep
'\r\n'
86Ngược lại,
>>> import os
>>> os.linesep
'\n'
30 tìm kiếm một trong hai phương thức ma thuật trong nội dung lớp mà bạn thường triển khai. Nếu nó không tìm thấy, thì nó sẽ quay trở lại biểu diễn mặc định xấu xí. Những phương pháp kỳ diệu đó, theo thứ tự tìm kiếm
093>>> import os >>> os.linesep '\r\n'
094>>> import os >>> os.linesep '\r\n'
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. Ideally, it should return valid Python code, so that you can pass it directly to
>>> import os
>>> os.linesep
'\r\n'
095>>>
>>> import os
>>> os.linesep
'\r\n'
87Lưu ý việc sử dụng một hàm dựng sẵn khác,
>>> import os
>>> os.linesep
'\r\n'
096, luôn cố gắng gọi >>> import os
>>> os.linesep
'\r\n'
097 trong một đối tượng, nhưng sẽ quay lại biểu diễn mặc định nếu nó không tìm thấy phương thức đóGhi chú. Mặc dù bản thân
>>> import os
>>> os.linesep
'\r\n'
94 sử dụng >>> import os
>>> os.linesep
'\n'
30 để truyền kiểu, nhưng một số kiểu dữ liệu phức hợp ủy quyền lệnh gọi tới >>> import os
>>> os.linesep
'\r\n'
096 cho các thành viên của chúng. Điều này xảy ra với danh sách và bộ dữ liệu, ví dụ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'
88If you print a single object of the
>>> import os
>>> os.linesep
'\r\n'
801 class, then you won’t see the password, because >>> import os
>>> os.linesep
'\r\n'
802 will call >>> import os
>>> os.linesep
'\r\n'
803, which eventually will invoke >>> import os
>>> os.linesep
'\r\n'
804>>>
>>> import os
>>> os.linesep
'\r\n'
89Tuy nhiên, nếu bạn đặt cùng một biến
>>> import os
>>> os.linesep
'\r\n'
805 trong danh sách bằng cách đặt nó trong dấu ngoặc vuông, thì mật khẩu sẽ hiển thị rõ ràng>>>
>>> import os
>>> os.linesep
'\r\n'
00Đó 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'
806 của chúng để tất cả các phần tử của chúng được chuyển đổi lần đầu tiên bằng >>> import os
>>> os.linesep
'\r\n'
096Python 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. Some of them, such as named tuples and data classes, offer string representations that look good without requiring any work on your part. 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'
806 và >>> import os
>>> os.linesep
'\r\n'
097 không thay đổi kể từ Python 2, nhưng bạn phải nhớ rằng các chuỗi không có gì khác hơn là các mảng byte được tôn vinh vào thời điểm đó. Để chuyển đổi các đối tượng của bạn thành Unicode thích hợp, là một loại dữ liệu riêng biệt, bạn phải cung cấp một phương pháp kỳ diệu khác. >>> import os
>>> os.linesep
'\r\n'
810Đây là một ví dụ về cùng một lớp
>>> import os
>>> os.linesep
'\r\n'
801 trong Python 2>>> import os
>>> os.linesep
'\r\n'
01Như 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'
812 tích hợp sẵnCả hai phương thức
>>> import os
>>> os.linesep
'\r\n'
806 và >>> import os
>>> os.linesep
'\r\n'
097 đều phải trả về chuỗi, vì vậy chúng mã hóa các ký tự Unicode thành các biểu diễn byte cụ thể được gọi là bộ ký tự. UTF-8 là mã hóa phổ biến nhất và an toàn nhất, trong khi >>> import os
>>> os.linesep
'\r\n'
815 là hằng số đặc biệt để biểu thị các ký tự vui nhộn, chẳng hạn như >>> import os
>>> os.linesep
'\r\n'
816, dưới dạng các chuỗi thoát trong ASCII đơn giản, chẳng hạn như >>> import os
>>> os.linesep
'\r\n'
817Câu lệnh
>>> import os
>>> os.linesep
'\n'
02 đang tìm kiếm phương thức >>> import os
>>> os.linesep
'\r\n'
806 ma thuật trong lớp, vì vậy bộ ký tự được chọn phải tương ứng với bộ ký tự được sử dụng bởi thiết bị đầu cuối. Ví dụ: mã hóa mặc định trong DOS và Windows là CP 852 chứ không phải UTF-8, vì vậy việc chạy mã này có thể dẫn đến kết quả đầu ra >>> import os
>>> os.linesep
'\r\n'
059 hoặc thậm chí bị cắt xén>>>
>>> import os
>>> os.linesep
'\r\n'
02Tuy 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'
03Bạn nên chuyển đổi các 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 nó 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'
810 thần kỳ nào trong Python 3 nữa. Bạn có thể tự hỏi liệu có thể chuyển đổi một đối tượng thành biểu diễn chuỗi byte của nó thay vì chuỗi Unicode trong Python 3 không. Có thể, với một phương pháp đặc biệt >>> import os
>>> os.linesep
'\r\n'
822 thực hiện điều đó>>>
>>> import os
>>> os.linesep
'\r\n'
04Sử dụng hàm
>>> import os
>>> os.linesep
'\r\n'
823 tích hợp trên một phiên bản ủy quyền cuộc gọi đến phương thức >>> import os
>>> os.linesep
'\r\n'
824 của nó được xác định trong lớp tương ứngRemove adsUnderstanding Python >>> import os
>>> os.linesep
'\r\n'
94
>>> import os
>>> os.linesep
'\r\n'
Bạn biết cách sử dụng
>>> import os
>>> os.linesep
'\r\n'
94 khá tốt vào thời điểm này, nhưng biết nó là gì sẽ cho phép bạn sử dụng nó hiệu quả và có ý thức hơn. Sau khi đọc phần này, bạn sẽ hiểu cách in bằng Python đã được cải thiện như thế nào trong những năm quaIn là một chức năng trong Python 3
Bạn đã thấy rằng
>>> import os
>>> os.linesep
'\r\n'
94 là một hàm trong Python 3. Cụ thể hơn, đó là chức năng tích hợp sẵn, nghĩa là bạn không cần phải nhập nó từ bất cứ đâu>>>
>>> import os
>>> os.linesep
'\r\n'
05Nó 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'
06This way, you can avoid name collisions with custom functions. Giả sử bạn muốn xác định lại
>>> import os
>>> os.linesep
'\r\n'
94 để nó không thêm một dòng mới ở cuối. Đồng thời, bạn muốn đổi tên chức năng ban đầu thành một cái gì đó như >>> import os
>>> os.linesep
'\r\n'
829>>>
>>> import os
>>> os.linesep
'\r\n'
07Bâ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. Sau này, bạn cũng sẽ định nghĩa các hàm
>>> import os
>>> os.linesep
'\r\n'
94 tùy chỉnh trong phần mô phỏng. Ngoài ra, lưu ý rằng bạn sẽ không thể ghi đè lên >>> import os
>>> os.linesep
'\r\n'
94 ngay từ đầu nếu đó không phải là một chức năngMặt khác,
>>> import os
>>> os.linesep
'\r\n'
94 không phải là một hàm theo nghĩa toán học, bởi vì nó không trả về bất kỳ giá trị có ý nghĩa nào ngoài giá trị ẩn >>> import os
>>> os.linesep
'\n'
32>>>
>>> import os
>>> os.linesep
'\r\n'
08Trê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'
94, tác dụng phụ đó là hiển thị một thông báo trên đầu ra tiêu chuẩn hoặc ghi vào một tệpVì
>>> import os
>>> os.linesep
'\r\n'
94 là một hàm nên nó có chữ ký được xác định rõ ràng với các thuộc tính đã biết. Bạn có thể nhanh chóng tìm thấy tài liệu của nó bằng cách sử dụng trình chỉnh sửa mà bạn chọn mà không cần phải nhớ một số cú pháp kỳ lạ để thực hiện một tác vụ nhất địnhBê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'
94 là một chức năng là khả năng kết hợp. Các hàm được gọi là đối tượng hạng nhất hoặc công dân hạng nhất trong Python, đây là một cách thú vị để nói rằng chúng là các giá trị giống như chuỗi hoặc số. Bằng cách này, bạn có thể gán một hàm cho một biến, chuyển nó sang một hàm khác hoặc thậm chí trả về một hàm từ một hàm khác. >>> import os
>>> os.linesep
'\r\n'
94 không có gì khác biệt về vấn đề này. Chẳng hạn, bạn có thể tận dụng nó để tiêm phụ thuộc>>> import os
>>> os.linesep
'\r\n'
09Ở đây, tham số
>>> import os
>>> os.linesep
'\r\n'
838 cho phép bạn thêm chức năng gọi lại, mặc định là >>> import os
>>> os.linesep
'\r\n'
94 nhưng có thể là bất kỳ chức năng nào có thể gọi được. In this example, printing is completely disabled by substituting >>> import os
>>> os.linesep
'\r\n'
94 with a dummy function that does nothingGhi 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]
Composition allows you to combine a few functions into a new one of the same kind. 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'
841 tùy chỉnh in ra luồng lỗi tiêu chuẩn và thêm tiền tố vào tất cả các thông báo với một mức nhật ký nhất định>>>
>>> import os
>>> os.linesep
'\r\n'
10Chứ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'
842Khô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'
94 bằng, bạn có thể tạo một biểu thức lambda ẩn danh để gọi nó>>>
>>> import os
>>> os.linesep
'\r\n'
11Tuy 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'
12Python 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'
32, vì vậy bạn chỉ cần bỏ qua 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'
94 gây ra nhiều vấn đề đau đầu như thế nàoRemove ads>>> import os
>>> os.linesep
'\n'
02 Là một Tuyên bố trong Python 2
>>> import os
>>> os.linesep
'\n'
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'
13Đó 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.
847>>> import os >>> os.linesep '\r\n'
- có điều kiện.
848>>> import os >>> os.linesep '\r\n'
- loop.
849>>> import os >>> os.linesep '\r\n'
- assertion.
850>>> import os >>> os.linesep '\r\n'
Note. Python 3. 8 brings a controversial walrus operator [
>>> import os
>>> os.linesep
'\r\n'
851], which is an assignment expression. With it, you can evaluate an expression and assign the result to a variable at the same time, even within another expressionTake a look at this example, which calls an expensive function once and then reuses the result for further computation
>>> import os
>>> os.linesep
'\r\n'
14This is useful for simplifying the code without losing its efficiency. Typically, performant code tends to be more verbose
>>> import os
>>> os.linesep
'\r\n'
15The controversy behind this new piece of syntax caused a lot of argument. An abundance of negative comments and heated debates eventually led Guido van Rossum to step down from the Benevolent Dictator For Life or BDFL position
Statements are usually comprised of reserved keywords such as
>>> import os
>>> os.linesep
'\r\n'
848, >>> import os
>>> os.linesep
'\r\n'
853, or >>> import os
>>> os.linesep
'\n'
02 that have fixed meaning in the language. You can’t use them to name your variables or other symbols. That’s why redefining or mocking the >>> import os
>>> os.linesep
'\n'
02 statement isn’t possible in Python 2. You’re stuck with what you getFurthermore, you can’t print from anonymous functions, because statements aren’t accepted in lambda expressions
>>>
>>> import os
>>> os.linesep
'\r\n'
16The syntax of the
>>> import os
>>> os.linesep
'\n'
02 statement is ambiguous. Sometimes you can add parentheses around the message, and they’re completely optional>>>
>>> import os
>>> os.linesep
'\r\n'
17At other times they change how the message is printed
>>>
>>> import os
>>> os.linesep
'\r\n'
18String concatenation can raise a
>>> import os
>>> os.linesep
'\n'
57 due to incompatible types, which you have to handle manually, for example>>>
>>> import os
>>> os.linesep
'\r\n'
19Compare this with similar code in Python 3, which leverages sequence unpacking
>>>
>>> import os
>>> os.linesep
'\r\n'
20There aren’t any keyword arguments for common tasks such as flushing the buffer or stream redirection. You need to remember the quirky syntax instead. Even the built-in
>>> import os
>>> os.linesep
'\r\n'
076 function isn’t that helpful with regards to the >>> import os
>>> os.linesep
'\n'
02 statement>>>
>>> import os
>>> os.linesep
'\r\n'
21Trailing newline removal doesn’t work quite right, because it adds an unwanted space. You can’t compose multiple
>>> import os
>>> os.linesep
'\n'
02 statements together, and, on top of that, you have to be extra diligent about character encodingThe list of problems goes on and on. If you’re curious, you can jump back to the previous section and look for more detailed explanations of the syntax in Python 2
However, you can mitigate some of those problems with a much simpler approach. It turns out the
>>> import os
>>> os.linesep
'\r\n'
94 function was backported to ease the migration to Python 3. You can import it from a special >>> import os
>>> os.linesep
'\n'
41 module, which exposes a selection of language features released in later Python versionsNote. You may import future functions as well as baked-in language constructs such as the
>>> import os
>>> os.linesep
'\r\n'
863 statementTo find out exactly what features are available to you, inspect the module
>>>
>>> import os
>>> os.linesep
'\r\n'
22You could also call
>>> import os
>>> os.linesep
'\r\n'
864, but that would show a lot of uninteresting internal details of the moduleTo enable the
>>> import os
>>> os.linesep
'\r\n'
94 function in Python 2, you need to add this import statement at the beginning of your source code>>> import os
>>> os.linesep
'\r\n'
23From now on the
>>> import os
>>> os.linesep
'\n'
02 statement is no longer available, but you have the >>> import os
>>> os.linesep
'\r\n'
94 function at your disposal. Note that it isn’t the same function like the one in Python 3, because it’s missing the >>> import os
>>> os.linesep
'\r\n'
067 keyword argument, but the rest of the arguments are the sameOther than that, it doesn’t spare you from managing character encodings properly
Here’s an example of calling the
>>> import os
>>> os.linesep
'\r\n'
94 function in Python 2>>>
>>> import os
>>> os.linesep
'\r\n'
24You now have an idea of how printing in Python evolved and, most importantly, understand why these backward-incompatible changes were necessary. Knowing this will surely help you become a better Python programmer
Remove adsPrinting With Style
If you thought that printing was only about lighting pixels up on the screen, then technically you’d be right. However, there are ways to make it look cool. In this section, you’ll find out how to format complex data structures, add colors and other decorations, build interfaces, use animation, and even play sounds with text
Pretty-Printing Nested Data Structures
Computer languages allow you to represent data as well as executable code in a structured way. Unlike Python, however, most languages give you a lot of freedom in using whitespace and formatting. This can be useful, for example in compression, but it sometimes leads to less readable code
Pretty-printing is about making a piece of data or code look more appealing to the human eye so that it can be understood more easily. This is done by indenting certain lines, inserting newlines, reordering elements, and so forth
Python comes with the
>>> import os
>>> os.linesep
'\r\n'
870 module in its standard library, which will help you in pretty-printing large data structures that don’t fit on a single line. Because it prints in a more human-friendly way, many popular REPL tools, including JupyterLab and IPython, use it by default in place of the regular >>> import os
>>> os.linesep
'\r\n'
94 functionNote. To toggle pretty printing in IPython, issue the following command
>>>
>>> import os
>>> os.linesep
'\r\n'
25This is an example of Magic in IPython. There are a lot of built-in commands that start with a percent sign [
>>> import os
>>> os.linesep
'\r\n'
872], but you can find more on PyPI, or even create your ownIf you don’t care about not having access to the original
>>> import os
>>> os.linesep
'\r\n'
94 function, then you can replace it with >>> import os
>>> os.linesep
'\r\n'
874 in your code using import renaming>>>
>>> import os
>>> os.linesep
'\r\n'
26Personally, I like to have both functions at my fingertips, so I’d rather use something like
>>> import os
>>> os.linesep
'\r\n'
875 as a short alias>>> import os
>>> os.linesep
'\r\n'
27At 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'
28That’s because
>>> import os
>>> os.linesep
'\r\n'
874 calls >>> import os
>>> os.linesep
'\r\n'
096 instead of the usual >>> import os
>>> os.linesep
'\n'
30 for type casting, so that you may evaluate its output as Python code if you want to. The differences become apparent as you start feeding it more complex data structures>>>
>>> import os
>>> os.linesep
'\r\n'
29The 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'
30The ordinary
>>> import os
>>> os.linesep
'\r\n'
94 also uses ellipses but for displaying recursive data structures, which form a cycle, to avoid stack overflow error>>>
>>> import os
>>> os.linesep
'\r\n'
31However,
>>> import os
>>> os.linesep
'\r\n'
874 is more explicit about it by including the unique identity of a self-referencing object>>>
>>> import os
>>> os.linesep
'\r\n'
32The 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'
881 module as well>>>
>>> import os
>>> os.linesep
'\r\n'
33This module supports most of the built-in types and is used by the Python debugger
>>> import os
>>> os.linesep
'\r\n'
874 automatically sorts dictionary keys for you before printing, which allows for consistent comparison. When you’re comparing strings, you often don’t care about a particular order of serialized attributes. Anyways, it’s always best to compare actual dictionaries before serializationDictionaries 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'
883 module. It too has pretty-printing capabilities>>>
>>> import os
>>> os.linesep
'\r\n'
34Tuy 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
>>> import os
>>> os.linesep
'\r\n'
870 có thêm một hàm >>> import os
>>> os.linesep
'\r\n'
885 trả về một chuỗi, trong trường hợp bạn phải làm gì đó ngoài việc in nóSurprisingly, the signature of
>>> import os
>>> os.linesep
'\r\n'
874 is nothing like the >>> import os
>>> os.linesep
'\r\n'
94 function’s one. Bạn thậm chí không thể chuyển nhiều hơn một đối số vị trí, điều này cho thấy mức độ tập trung của nó vào việc in cấu trúc dữ liệuRemove adsThê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 đó. Until recently, the Windows operating system was a notable exception. Do đó, nếu bạn muốn tính di động tốt nhất, hãy sử dụng thư viện
>>> import os
>>> os.linesep
'\r\n'
888 trong Python. It translates ANSI codes to their appropriate counterparts in Windows while keeping them intact in other operating systemsĐể 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'
35Thiế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. The command would return a negative number if colors were unsupported
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ư
>>> import os
>>> os.linesep
'\r\n'
889 hoặc >>> import os
>>> os.linesep
'\r\n'
890, để thay đổi giao diện của các thành phần trong tài liệu. Các thẻ này được trộn lẫn với nội dung của bạn nhưng bản thân chúng không hiển thị. Tương tự, mã thoát sẽ không hiển thị trong thiết bị đầu cuối miễn là nó nhận ra chúng. Otherwise, they’ll appear in the literal form as if you were viewing the source of a websiteNhư 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à
>>> import os
>>> os.linesep
'\r\n'
891 . Bạn có thể sử dụng chữ số Python để nhanh chóng xác minh đó thực sự là cùng một số. >>>
>>> import os
>>> os.linesep
'\r\n'
36Ngoài ra, bạn có thể lấy nó bằng chuỗi thoát
>>> import os
>>> os.linesep
'\r\n'
893 trong trình bao>>> import os
>>> os.linesep
'\r\n'
37Các chuỗi thoát ANSI phổ biến nhất có dạng sau
ElementDescriptionVí dụ Esc ký tự thoát không in được
>>> import os
>>> os.linesep
'\r\n'
894>>> import os
>>> os.linesep
'\r\n'
895mở dấu ngoặc vuông>>> import os
>>> os.linesep
'\r\n'
895mã sốmột hoặc nhiều số được phân tách bằng >>> import os
>>> os.linesep
'\r\n'
897>>> import os
>>> os.linesep
'\r\n'
898mã ký tự chữ hoa hoặc chữ thường>>> import os
>>> os.linesep
'\r\n'
899Mã 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. 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'
899>>> import os
>>> os.linesep
'\r\n'
38Ở đầ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'
39Bạ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í nó 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'
40Điều này sẽ làm cho từ
>>> import os
>>> os.linesep
'\r\n'
001 xuất hiện ở phông chữ màu đỏ, in đậm và gạch chânTuy 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
>>> import os
>>> os.linesep
'\r\n'
888 đã đề cập, cũng như các công cụ để xây dựng giao diện người dùng trong bảng điều khiểnRemove adsXâ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. There are a few libraries that provide such a high level of control over the terminal, but
>>> import os
>>> os.linesep
'\r\n'
003 seems to be the most popular choiceGhi chú. Để sử dụng thư viện
>>> import os
>>> os.linesep
'\r\n'
003 trong Windows, bạn cần cài đặt gói của bên thứ ba>>> import os
>>> os.linesep
'\r\n'
41That’s because
>>> import os
>>> os.linesep
'\r\n'
003 isn’t available in the standard library of the Python distribution for WindowsVề 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. 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'
003 module. Since it modifies the state of a running terminal, it’s important to handle errors and gracefully restore the previous state. You can do this manually, but the library comes with a convenient wrapper for your main function>>> import os
>>> os.linesep
'\r\n'
42Note, the function must accept a reference to the screen object, also known as
>>> import os
>>> os.linesep
'\r\n'
007, that you’ll use later for additional setupIf you run this program now, you won’t see any effects, because it terminates immediately. However, you can add a small delay to have a sneak peek
>>> import os
>>> os.linesep
'\r\n'
43This time the screen went completely blank for a second, but the cursor was still blinking. To hide it, just call one of the configuration functions defined in the module
>>> import os
>>> os.linesep
'\r\n'
44Let’s define the snake as a list of points in screen coordinates
>>> import os
>>> os.linesep
'\r\n'
45The head of the snake is always the first element in the list, whereas the tail is the last one. The initial shape of the snake is horizontal, starting from the top-left corner of the screen and facing to the right. While its y-coordinate stays at zero, its x-coordinate decreases from head to tail
To draw the snake, you’ll start with the head and then follow with the remaining segments. Each segment carries
>>> import os
>>> os.linesep
'\r\n'
008 coordinates, so you can unpack them>>> import os
>>> os.linesep
'\r\n'
46Again, 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'
47You want to move the snake in one of four directions, which can be defined as vectors. Eventually, the direction will change in response to an arrow keystroke, so you may hook it up to the library’s key codes
>>> import os
>>> os.linesep
'\r\n'
48How does a snake move? It turns out that only its head really moves to a new location, while all other segments shift towards it. In each step, almost all segments remain the same, except for the head and the tail. 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'
49To get the new coordinates of the head, you need to add the direction vector to it. However, adding tuples in Python results in a bigger tuple instead of the algebraic sum of the corresponding vector components. One way to fix this is by using the built-in
>>> import os
>>> os.linesep
'\r\n'
009, >>> import os
>>> os.linesep
'\r\n'
010, and >>> import os
>>> os.linesep
'\r\n'
011 functionsHướng sẽ thay đổi khi nhấn phím, vì vậy bạn cần gọi
>>> import os
>>> os.linesep
'\r\n'
012 để lấy mã phím đã nhấn. However, if the pressed key doesn’t correspond to the arrow keys defined earlier as dictionary keys, the direction won’t change>>> import os
>>> os.linesep
'\r\n'
50By default, however,
>>> import os
>>> os.linesep
'\r\n'
012 is a blocking call that would prevent the snake from moving unless there was a keystroke. Therefore, you need to make the call non-blocking by adding yet another configuration>>> import os
>>> os.linesep
'\r\n'
51You’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'
52This is merely scratching the surface of the possibilities that the
>>> import os
>>> os.linesep
'\r\n'
003 module opens up. You may use it for game development like this or more business-oriented applicationsLiving 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'
003 library. However, I’d like to show you an even simpler wayIf the animation can be constrained to a single line of text, then you might be interested in two special escape character sequences
- Carriage return.
08>>> import os >>> os.linesep '\n'
- Backspace.
13>>> import os >>> os.linesep '\n'
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'
53The 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'
54As before, each request for update repaints the entire line
Note. There’s a feature-rich
>>> import os
>>> os.linesep
'\r\n'
018 library, along with a few other similar tools, that can show progress in a much more comprehensive wayMaking Sounds With >>> import os
>>> os.linesep
'\r\n'
94
>>> import os
>>> os.linesep
'\r\n'
If you’re old enough to remember computers with a PC speaker, then you must also remember their distinctive beep sound, often used to indicate hardware problems. They could barely make any more noises than that, yet video games seemed so much better with it
Today you can still take advantage of this small loudspeaker, but chances are your laptop didn’t come with one. In such a case, you can enable terminal bell emulation in your shell, so that a system warning sound is played instead
Go ahead and type this command to see if your terminal can play a sound
>>> import os
>>> os.linesep
'\r\n'
55This would normally print text, but the
>>> import os
>>> os.linesep
'\r\n'
020 flag enables the interpretation of backslash escapes. As you can see, there’s a dedicated escape sequence >>> import os
>>> os.linesep
'\r\n'
021, which stands for “alert”, that outputs a special bell character. Some terminals make a sound whenever they see itSimilarly, you can print this character in Python. Perhaps in a loop to form some kind of melody. While it’s only a single note, you can still vary the length of pauses between consecutive instances. That seems like a perfect toy for Morse code playback
The rules are the following
- Letters are encoded with a sequence of dot [·] and dash [–] symbols
- A dot is one unit of time
- A dash is three units of time
- Individual symbols in a letter are spaced one unit of time apart
- Symbols of two adjacent letters are spaced three units of time apart
- Symbols of two adjacent words are spaced seven units of time apart
According to those rules, you could be “printing” an SOS signal indefinitely in the following way
>>> import os
>>> os.linesep
'\r\n'
56In Python, you can implement it in merely ten lines of code
>>> import os
>>> os.linesep
'\r\n'
57Maybe you could even take it one step further and make a command line tool for translating text into Morse code? Either way, I hope you’re having fun with this
Mocking Python >>> import os
>>> os.linesep
'\r\n'
94 in Unit Tests
>>> import os
>>> os.linesep
'\r\n'
Nowadays, it’s expected that you ship code that meets high quality standards. If you aspire to become a professional, you must learn how to test your code
Software testing is especially important in dynamically typed languages, such as Python, which don’t have a compiler to warn you about obvious mistakes. Defects can make their way to the production environment and remain dormant for a long time, until that one day when a branch of code finally gets executed
Sure, you have linters, type checkers, and other tools for static code analysis to assist you. But they won’t tell you whether your program does what it’s supposed to do on the business level
So, should you be testing
>>> import os
>>> os.linesep
'\r\n'
94? No. After all, it’s a built-in function that must have already gone through a comprehensive suite of tests. What you want to test, though, is whether your code is calling >>> import os
>>> os.linesep
'\r\n'
94 at the right time with the expected parameters. Đó được gọi là một hành viYou can test behaviors by mocking real objects or functions. In this case, you want to mock
>>> import os
>>> os.linesep
'\r\n'
94 to record and verify its invocationsNote. You might have heard the terms. dummy, fake, stub, spy, or mock used interchangeably. Some people make a distinction between them, while others don’t
Martin Fowler explains their differences in a short glossary and collectively calls them test doubles
Mocking in Python can be done twofold. First, you can take the traditional path of statically-typed languages by employing dependency injection. This may sometimes require you to change the code under test, which isn’t always possible if the code is defined in an external library
>>> import os
>>> os.linesep
'\r\n'
58This is the same example I used in an earlier section to talk about function composition. It basically allows for substituting
>>> import os
>>> os.linesep
'\r\n'
94 with a custom function of the same interface. To check if it prints the right message, you have to intercept it by injecting a mocked function>>>
>>> import os
>>> os.linesep
'\r\n'
59Calling this mock makes it save the last message in an attribute, which you can inspect later, for example in an
>>> import os
>>> os.linesep
'\r\n'
850 statementIn a slightly alternative solution, instead of replacing the entire
>>> import os
>>> os.linesep
'\r\n'
94 function with a custom wrapper, you could redirect the standard output to an in-memory file-like stream of characters>>>
>>> import os
>>> os.linesep
'\r\n'
60This time the function explicitly calls
>>> import os
>>> os.linesep
'\r\n'
94, but it exposes its >>> import os
>>> os.linesep
'\r\n'
043 parameter to the outside worldHowever, a more Pythonic way of mocking objects takes advantage of the built-in
>>> import os
>>> os.linesep
'\r\n'
031 module, which uses a technique called monkey patching. This derogatory name stems from it being a “dirty hack” that you can easily shoot yourself in the foot with. It’s less elegant than dependency injection but definitely quick and convenientNote. The
>>> import os
>>> os.linesep
'\r\n'
031 module got absorbed by the standard library in Python 3, but before that, it was a third-party package. You had to install it separately>>> import os
>>> os.linesep
'\r\n'
61Other than that, you referred to it as
>>> import os
>>> os.linesep
'\r\n'
031, whereas in Python 3 it’s part of the unit testing module, so you must import from >>> import os
>>> os.linesep
'\r\n'
034What monkey patching does is alter implementation dynamically at runtime. Một thay đổi như vậy có thể nhìn thấy trên toàn cầu, vì vậy nó có thể gây ra những hậu quả không mong muốn. In practice, however, patching only affects the code for the duration of test execution
To mock
>>> import os
>>> os.linesep
'\r\n'
94 in a test case, you’ll typically use the >>> import os
>>> os.linesep
'\r\n'
036 decorator and specify a target for patching by referring to it with a fully qualified name, that is including the module name>>> import os
>>> os.linesep
'\r\n'
62This will automatically create the mock for you and inject it to the test function. However, you need to declare that your test function accepts a mock now. The underlying mock object has lots of useful methods and attributes for verifying behavior
Did you notice anything peculiar about that code snippet?
Despite injecting a mock to the function, you’re not calling it directly, although you could. That injected mock is only used to make assertions afterward and maybe to prepare the context before running the test
In real life, mocking helps to isolate the code under test by removing dependencies such as a database connection. You rarely call mocks in a test, because that doesn’t make much sense. Rather, it’s other pieces of code that call your mock indirectly without knowing it
Here’s what that means
>>> import os
>>> os.linesep
'\r\n'
63Mã đang kiểm tra là một chức năng in lời chào. Mặc dù đây là một chức năng khá đơn giản nhưng bạn không thể dễ dàng kiểm tra nó vì nó không trả về giá trị. Nó có tác dụng phụ
Để loại bỏ tác dụng phụ đó, bạn cần loại bỏ sự phụ thuộc. Bản vá cho phép bạn tránh thực hiện các thay đổi đối với chức năng ban đầu, điều này có thể vẫn là bất khả tri về
>>> import os
>>> os.linesep
'\r\n'
94. Nó nghĩ rằng nó đang gọi >>> import os
>>> os.linesep
'\r\n'
94, nhưng trên thực tế, nó đang gọi một kẻ giả mạo mà bạn có toàn quyền kiểm soátCó nhiều lý do để kiểm thử phần mềm. Một trong số họ đang tìm kiếm lỗi. Ví dụ, khi bạn viết bài kiểm tra, bạn thường muốn loại bỏ hàm
>>> import os
>>> os.linesep
'\r\n'
94 bằng cách chế nhạo nó. Tuy nhiên, nghịch lý thay, chính chức năng đó có thể giúp bạn tìm lỗi trong quá trình gỡ lỗi có liên quan mà bạn sẽ đọc trong phần tiếp theoSyntax in Python 2Show/Hide
Bạn không thể vá câu lệnh
>>> import os
>>> os.linesep
'\n'
02 trong Python 2, bạn cũng không thể đưa nó vào làm phụ thuộc. Tuy nhiên, bạn có một vài lựa chọn khác- Sử dụng chuyển hướng luồng
- Vá đầu ra tiêu chuẩn được xác định trong mô-đun
004>>> import os >>> os.linesep '\r\n'
- Nhập
94 từ mô-đun>>> import os >>> os.linesep '\r\n'
41>>> import os >>> os.linesep '\n'
Hãy kiểm tra từng cái một
Chuyển hướng luồng gần giống với ví dụ bạn đã thấy trước đó
>>>
>>> import os
>>> os.linesep
'\r\n'
64Chỉ có hai sự khác biệt. Đầu tiên, cú pháp chuyển hướng luồng sử dụng chevron [
>>> import os
>>> os.linesep
'\r\n'
044] thay vì đối số >>> import os
>>> os.linesep
'\r\n'
043. Sự khác biệt khác là nơi >>> import os
>>> os.linesep
'\r\n'
046 được xác định. Bạn có thể nhập nó từ mô-đun >>> import os
>>> os.linesep
'\r\n'
046 có tên tương tự hoặc >>> import os
>>> os.linesep
'\r\n'
048 để triển khai nhanh hơnVá đầu ra tiêu chuẩn từ mô-đun
>>> import os
>>> os.linesep
'\r\n'
004 đúng như tên gọi, nhưng bạn cần lưu ý một số vấn đề>>> import os
>>> os.linesep
'\r\n'
65Trước hết, hãy nhớ cài đặt mô-đun
>>> import os
>>> os.linesep
'\r\n'
031 vì nó không có sẵn trong thư viện chuẩn của Python 2Thứ hai, câu lệnh
>>> import os
>>> os.linesep
'\n'
02 gọi phương thức >>> import os
>>> os.linesep
'\r\n'
040 cơ bản trên đối tượng giả định thay vì gọi chính đối tượng đó. Đó là lý do tại sao bạn sẽ chạy các xác nhận đối với >>> import os
>>> os.linesep
'\r\n'
053Cuối cùng, một câu lệnh
>>> import os
>>> os.linesep
'\n'
02 không phải lúc nào cũng tương ứng với một lệnh gọi tới >>> import os
>>> os.linesep
'\r\n'
055. Trên thực tế, bạn sẽ thấy ký tự xuống dòng được viết riêngTùy chọn cuối cùng bạn có là nhập
>>> import os
>>> os.linesep
'\r\n'
94 từ >>> import os
>>> os.linesep
'\r\n'
057 và vá nó>>> import os
>>> os.linesep
'\r\n'
66Một lần nữa, nó gần giống với Python 3, nhưng hàm
>>> import os
>>> os.linesep
'\r\n'
94 được định nghĩa trong mô-đun >>> import os
>>> os.linesep
'\r\n'
059 thay vì >>> import os
>>> os.linesep
'\r\n'
060>>> import os
>>> os.linesep
'\r\n'
94 Gỡ lỗi
>>> import os
>>> os.linesep
'\r\n'
Trong phần này, bạn sẽ xem xét các công cụ có sẵn để gỡ lỗi trong Python, bắt đầu từ một hàm khiêm tốn
>>> import os
>>> os.linesep
'\r\n'
94, thông qua mô-đun >>> import os
>>> os.linesep
'\r\n'
063, cho đến một trình gỡ lỗi chính thức. Sau khi đọc nó, bạn sẽ có thể đưa ra quyết định sáng suốt về cách nào phù hợp nhất trong một tình huống nhất địnhGhi chú. Gỡ lỗi là quá trình tìm kiếm nguyên nhân gốc rễ của lỗi hoặc khiếm khuyết trong phần mềm sau khi chúng được phát hiện, cũng như thực hiện các bước để khắc phục chúng
Mối có một câu chuyện thú vị về nguồn gốc tên gọi của nó
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'
67Như bạn có thể thấy, hàm không trả về giá trị mong muốn là
>>> import os
>>> os.linesep
'\r\n'
064, nhưng bây giờ bạn biết điều đó là do tổng hơi sai. Theo dõi trạng thái của các biến ở các bước khác nhau của thuật toán có thể cho bạn gợi ý về vấ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'
064 hóa ra có dạng biểu diễn nhị phân vô hạn, được làm trò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'
94 mà bạn đã thực hiện mà không vô tình chạm vào cuộc gọi chính hãngBê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'
68Như 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 vô hiệu hóa hoặc kích hoạt thông báo ở các mức 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ì module
>>> import os
>>> os.linesep
'\r\n'
063 được đóng gói với thư viện chuẩn. Bạn chỉ cần nhập và định cấu hình nó chỉ trong hai dòng mã>>> import os
>>> os.linesep
'\r\n'
69Bạ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'
70Ư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
>>> import os
>>> os.linesep
'\r\n'
068Ghi chú. Có một mô-đun
>>> import os
>>> os.linesep
'\r\n'
069 hơi liên quan trong Python, mô-đun này cũng có thể ghi thông báo vào luồng lỗi tiêu chuẩn. Tuy nhiên, nó có phạm vi ứng dụng hẹp hơn, chủ yếu là mã thư viện, trong khi các ứng dụng khách nên sử dụng mô-đun >>> import os
>>> os.linesep
'\r\n'
063Đ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'
071Một lý do cuối cùng để chuyển từ chức năng
>>> import os
>>> os.linesep
'\r\n'
94 sang ghi nhật ký là sự an toàn của luồng. Trong phần sắp tới, bạn sẽ thấy rằng phần trước không hoạt động tốt với nhiều luồng thực thigỡ 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
A crude debugger that runs in the terminal, unsurprisingly named
>>> import os
>>> os.linesep
'\r\n'
073 for “The Python Debugger,” is distributed as part of the standard library. Điều này làm cho nó luôn khả dụng, vì vậy nó có thể là lựa chọn duy nhất của bạn để thực hiện gỡ lỗi từ xa. Có lẽ đó là một lý do tốt để làm quen với 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'
073 có thể hơi phức tạp một chút. Nếu bạn không thể chỉnh sửa mã, bạn phải chạy mã đó dưới dạng mô-đun và chuyển vị trí tập lệnh của bạn>>> import os
>>> os.linesep
'\r\n'
71Nế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'
72Thao 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'
73Mặ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'
075 tích hợp sẵn, hàm này thực hiện tương tự nhưng theo cách nhỏ gọn hơn và có thêm một số chuông và còi>>> import os
>>> os.linesep
'\r\n'
74Hầ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
In chỉ an toàn
Trước đây, tôi đã đề cập sơ qua về vấn đề an toàn luồng, khuyến nghị sử dụng
>>> import os
>>> os.linesep
'\r\n'
063 thay vì chức năng >>> import os
>>> os.linesep
'\r\n'
94. Nếu bạn vẫn đang đọc điều này, thì bạn phải cảm thấy thoải mái với khái niệm chủ đềAn toàn luồng có nghĩa là một đoạn mã có thể được chia sẻ an toàn giữa nhiều luồng thực thi. Chiến lược đơn giản nhất để đảm bảo an toàn luồng là chỉ chia sẻ các đối tượng bất biến. Nếu các luồng không thể sửa đổi trạng thái của một đối tượng, thì sẽ không có nguy cơ phá vỡ tính nhất quán của nó
Một phương pháp khác tận dụng bộ nhớ cục bộ, làm cho mỗi luồng nhận bản sao của cùng một đối tượng. Bằng cách đó, các luồng khác không thể thấy các thay đổi được thực hiện đối với luồng đó trong luồng hiện tại
Nhưng điều đó không giải quyết được vấn đề, phải không? . The most common way of synchronizing concurrent access to such a resource is by locking it. Điều này cho phép truy cập ghi độc quyền vào một hoặc đôi khi một vài luồng tại một thời điểm
Tuy nhiên, khóa đắt tiền và làm giảm thông lượng đồng thời, vì vậy các phương tiện khác để kiểm soát quyền truy cập đã được phát minh, chẳng hạn như các biến nguyên tử hoặc thuật toán so sánh và hoán đổi
In không an toàn theo luồng trong Python. Hàm
>>> import os
>>> os.linesep
'\r\n'
94 giữ tham chiếu đến đầu ra tiêu chuẩn, là biến toàn cục được chia sẻ. Về lý thuyết, do không có khóa nên việc chuyển đổi ngữ cảnh có thể xảy ra trong khi gọi tới >>> import os
>>> os.linesep
'\r\n'
055, đan xen các đoạn văn bản từ nhiều lệnh gọi >>> import os
>>> os.linesep
'\r\n'
94Ghi chú. Chuyển đổi ngữ cảnh có nghĩa là một luồng tạm dừng thực thi của nó, một cách tự nguyện hoặc không, để một luồng khác có thể tiếp quản. Điều này có thể xảy ra bất cứ lúc nào, ngay cả khi đang gọi hàm
Tuy nhiên, trong thực tế, điều đó không xảy ra. Cho dù bạn có cố gắng thế nào, việc ghi vào đầu ra tiêu chuẩn dường như là nguyên tử. Vấn đề duy nhất mà đôi khi bạn có thể quan sát thấy là việc ngắt dòng bị lộn xộn
>>> import os
>>> os.linesep
'\r\n'
75Để mô phỏng điều này, bạn có thể tăng khả năng chuyển đổi ngữ cảnh bằng cách đặt phương thức
>>> import os
>>> os.linesep
'\r\n'
040 cơ bản ở chế độ ngủ trong một khoảng thời gian ngẫu nhiên. Làm sao? >>> import os
>>> os.linesep
'\r\n'
76Trước tiên, bạn cần lưu trữ phương thức gốc
>>> import os
>>> os.linesep
'\r\n'
040 trong một biến mà bạn sẽ ủy thác sau này. Sau đó, bạn cung cấp triển khai giả của mình, sẽ mất tối đa một giây để thực thi. Mỗi chuỗi sẽ thực hiện một vài cuộc gọi >>> import os
>>> os.linesep
'\r\n'
94 với tên và một chữ cái. A, B và CNếu bạn đã đọc phần mô phỏng trước đó, thì bạn có thể đã biết tại sao việc in lại hoạt động sai như vậy. Tuy nhiên, để làm cho nó rõ ràng, bạn có thể nắm bắt các giá trị được đưa vào hàm
>>> import os
>>> os.linesep
'\r\n'
084 của mình. Bạn sẽ nhận thấy rằng bạn nhận được một trình tự hơi khác mỗi lần>>> import os
>>> os.linesep
'\r\n'
77Mặc dù bản thân
>>> import os
>>> os.linesep
'\r\n'
055 là một phép toán nguyên tử, nhưng một lần gọi hàm >>> import os
>>> os.linesep
'\r\n'
94 có thể mang lại nhiều hơn một lần ghi. Ví dụ: ngắt dòng được viết riêng biệt với phần còn lại của văn bản và chuyển đổi ngữ cảnh diễn ra giữa các lần viết đóGhi chú. Bản chất nguyên tử của đầu ra tiêu chuẩn trong Python là sản phẩm phụ của Khóa phiên dịch toàn cầu, áp dụng khóa xung quanh các hướng dẫn mã byte. Tuy nhiên, hãy lưu ý rằng nhiều hương vị trình thông dịch không có GIL, nơi in đa luồng yêu cầu khóa rõ ràng
Bạn có thể làm cho ký tự xuống dòng trở thành một phần không thể thiếu của tin nhắn bằng cách xử lý thủ công
>>> import os
>>> os.linesep
'\r\n'
78Điều này sẽ khắc phục đầu ra
>>> import os
>>> os.linesep
'\r\n'
79Tuy nhiên, lưu ý rằng hàm
>>> import os
>>> os.linesep
'\r\n'
94 vẫn tiếp tục thực hiện lệnh gọi riêng cho hậu tố trống, điều này chuyển thành lệnh >>> import os
>>> os.linesep
'\r\n'
088 vô dụng>>> import os
>>> os.linesep
'\r\n'
80Phiên bản thực sự an toàn cho luồng của hàm
>>> import os
>>> os.linesep
'\r\n'
94 có thể trông như thế này>>> import os
>>> os.linesep
'\r\n'
81Bạn có thể đặt chức năng đó trong một mô-đun và nhập nó vào nơi khác
>>> import os
>>> os.linesep
'\r\n'
82Bây giờ, mặc dù thực hiện hai lần ghi cho mỗi yêu cầu
>>> import os
>>> os.linesep
'\r\n'
94, nhưng chỉ một luồng được phép tương tác với luồng, trong khi phần còn lại phải đợi>>> import os
>>> os.linesep
'\r\n'
83Tôi đã thêm nhận xét để cho biết khóa đang giới hạn quyền truy cập vào tài nguyên được chia sẻ như thế nào
Ghi chú. Ngay cả trong mã đơn luồng, bạn có thể gặp phải tình huống tương tự. Cụ thể, khi bạn đang in ra đầu ra tiêu chuẩn và các luồng lỗi tiêu chuẩn cùng một lúc. Trừ khi bạn chuyển hướng một hoặc cả hai thành các tệp riêng biệt, cả hai sẽ chia sẻ một cửa sổ đầu cuối duy nhất
Ngược lại, mô-đun
>>> import os
>>> os.linesep
'\r\n'
063 được thiết kế an toàn cho luồng, điều này được thể hiện qua khả năng hiển thị tên luồng trong thông báo được định dạng>>>
>>> import os
>>> os.linesep
'\r\n'
84Đó là một lý do khác khiến bạn có thể không muốn sử dụng hàm
>>> import os
>>> os.linesep
'\r\n'
94 mọi lúcĐối tác in Python
Đến bây giờ, bạn đã biết rất nhiều điều cần biết về
>>> import os
>>> os.linesep
'\r\n'
94. Tuy nhiên, chủ đề sẽ không hoàn chỉnh nếu không nói một chút về các đối tác của nó. Trong khi >>> import os
>>> os.linesep
'\r\n'
94 là về đầu ra, có các chức năng và thư viện cho đầu vàoĐượ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'
095. Nó chấp nhận dữ liệu từ luồng đầu vào tiêu chuẩn, thường là bàn phím>>>
>>> import os
>>> os.linesep
'\r\n'
85Hà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'
86Tham 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'
87Tuy 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'
096, đây là một tích hợp khác. Thật không may, cũng có một hàm >>> import os
>>> os.linesep
'\r\n'
095 được đặt tên gây hiểu nhầm, thực hiện một việc hơi khácTrê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'
096 được đổi tên thành >>> import os
>>> os.linesep
'\r\n'
095Dướ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'
096____3095 >>> import os
>>> os.linesep
'\r\n'
095>>> import os
>>> os.linesep
'\r\n'
203Như 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'
095 là một ý tưởng tồi vì nó sẽ hiển thị ở dạng văn bản gốc khi họ nhập mật khẩu. Trong trường hợp này, bạn nên sử dụng hàm >>> import os
>>> os.linesep
'\r\n'
205 để che các ký tự đã nhập. Chức năng này được định nghĩa trong một mô-đun có cùng tên, cũng có sẵn trong thư viện tiêu chuẩn>>>
>>> import os
>>> os.linesep
'\r\n'
88Mô-đun
>>> import os
>>> os.linesep
'\r\n'
206 có một chức năng khác để lấy tên người dùng từ một biến môi trường>>>
>>> import os
>>> os.linesep
'\r\n'
89Cá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
207>>> import os >>> os.linesep '\r\n'
208>>> import os >>> os.linesep '\r\n'
209>>> import os >>> os.linesep '\r\n'
210>>> import os >>> os.linesep '\r\n'
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'
211 bổ sung miễn phí khả năng chỉnh sửa dòng mạnh mẽ cho các tập lệnh Python của bạn. Bạn không phải làm bất cứ điều gì để nó hoạt độngGiả 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'
90Thoạ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'
91Như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'
92Bâ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'
211. Bạn không chỉ làm cho các phím mũi tên hoạt động mà còn có thể tìm kiếm trong lịch sử liên tục của các lệnh tùy chỉnh của mình, sử dụng tính năng tự động hoàn thành và chỉnh sửa dòng bằng phím tắt>>> import os
>>> os.linesep
'\r\n'
93Isn’t that great?
Sự kết luận
Bây giờ bạn đã được trang bị một lượng kiến thức về hàm
>>> import os
>>> os.linesep
'\r\n'
94 trong Python, cũng như nhiều chủ đề xung quanh. Bạn hiểu sâu về nó là gì và nó hoạt động như thế nào, liên quan đến tất cả các yếu tố chính của nó. Nhiều ví dụ đã cho bạn cái nhìn sâu sắc về sự phát triển của nó từ Python 2Ngoài ra, bạn đã học cách
- Tránh những lỗi phổ biến với
94 trong Python>>> import os >>> os.linesep '\r\n'
- Xử lý các dòng mới, mã hóa ký tự và bộ đệm
- Write text to files
- Giả lập chức năng
94 trong các bài kiểm tra đơn vị>>> import os >>> os.linesep '\r\n'
- Build advanced user interfaces in the terminal
Bây giờ bạn đã biết tất cả những điều này, bạn có thể tạo các chương trình tương tác giao tiếp với người dùng hoặc tạo dữ liệu ở các định dạng tệp phổ biến. Bạn có thể nhanh chóng chẩn đoán các sự cố trong mã của mình và tự bảo vệ mình khỏi chúng. Cuối cùng nhưng không kém phần quan trọng, bạn biết cách thực hiện trò chơi rắn cổ điển
Nếu bạn vẫn khao khát biết thêm thông tin, có câu hỏi hoặc chỉ đơn giản là muốn chia sẻ suy nghĩ của mình, thì hãy liên hệ trong phần bình luận bên dưới
Đánh dấu là đã hoàn thành
Xem ngay Hướng dẫn này có một khóa học video liên quan do nhóm Real Python tạo. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn. Hàm print[] của Python. Đi xa hơn những điều cơ bản
🐍 Thủ thuật Python 💌
Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python
Gửi cho tôi thủ thuật Python »
Giới thiệu về Bartosz Zaczyński
Bartosz là người hướng dẫn bootcamp, tác giả và lập trình viên đa ngôn ngữ yêu thích Python. Anh ấy giúp sinh viên của mình tiếp cận công nghệ phần mềm bằng cách chia sẻ kinh nghiệm thương mại hơn một thập kỷ trong ngành CNTT
» Thông tin thêm về BartoszMỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là
Aldren
Joanna
Mike
Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực
Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonistas chuyên gia
Nâng cao kỹ năng Python của bạn »
Bậc thầy Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực
Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia
Nâng cao kỹ năng Python của bạn »
Bạn nghĩ sao?
Đánh giá bài viết này
Tweet Chia sẻ Chia sẻ EmailBài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?
Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. Nhận các mẹo để đặt câu hỏi hay và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi