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

Hàm tích hợp print() của Python được sử dụng để in nội dung đã cho bên trong dấu nhắc lệnh. Chức năng mặc định của Python print là nó thêm một ký tự xuống dòng ở cuối

Trong hướng dẫn Python này, bạn sẽ học

Hoạt động của hàm Normal print()

Hàm print() dùng để hiển thị nội dung trong command prompt hoặc console

Đây là một ví dụ cho thấy hoạt động của Python print không có chức năng dòng mới

print("Hello World")
print("Welcome to Guru99 Tutorials")

đầu ra

Hello World
Welcome to Guru99 Tutorials

Trong kết quả đã cho, bạn có thể thấy rằng các chuỗi mà chúng tôi đã cung cấp trong print() được hiển thị trên các dòng riêng biệt. Chuỗi “Xin chào thế giới” được in đầu tiên và “Chào mừng đến với Hướng dẫn của Guru99” được in trên dòng tiếp theo

Làm cách nào để in mà không có dòng mới trong Python?

Từ Python 3+, có một tham số bổ sung được giới thiệu cho print() được gọi là end=. Tham số này đảm nhiệm việc xóa dòng mới được thêm theo mặc định trong print()

Trong ví dụ in Python 3 không có dòng mới bên dưới, chúng tôi muốn các chuỗi in trên cùng một dòng trong Python. Để làm việc đó, chỉ cần thêm end=”” bên trong print() như trong ví dụ bên dưới

print("Hello World ", end="")
print("Welcome to Guru99 Tutorials")

đầu ra

Hello World Welcome to Guru99 Tutorials

Chúng tôi đang nhận được đầu ra mà chúng tôi muốn, nhưng không có khoảng cách giữa các chuỗi. Chuỗi Hello World và Welcome to Guru99 Tutorials được in liền nhau mà không có bất kỳ khoảng trống nào

Để thêm dấu cách hoặc ký tự đặc biệt hoặc thậm chí chuỗi sẽ được in, bạn có thể thêm đối số end=””, như trong ví dụ dưới đây

print("Hello World ", end=" ")
print("Welcome to Guru99 Tutorials")

Vì vậy, tôi ở đây, chúng tôi đã thêm một khoảng trắng vào đối số kết thúc, ví dụ (end="”). Bây giờ, nếu bạn thấy đầu ra, bạn sẽ thấy một khoảng trống giữa Hello World và Welcome to Guru99 Tutorials

đầu ra

Hello World  Welcome to Guru99 Tutorials

Bạn không chỉ có thể cung cấp khoảng trống cho đối số kết thúc mà còn có thể chỉ định một chuỗi bạn muốn in giữa các chuỗi đã cho. Vì vậy, đây là một ví dụ về nó

print("Hello World ", end="It's a nice day! ")
print("Welcome to Guru99 Tutorials")

đầu ra

Hello, World It's a nice day!  Welcome to Guru99 Tutorials

In không có dòng mới trong Python 2. x

Để in các chuỗi mà không cần dòng mới, trong python2. x bạn sẽ phải thêm dấu phẩy (,) vào cuối câu lệnh in như hình bên dưới

________số 8_______

đầu ra

Hello World  Welcome to Guru99 Tutorials

Sử dụng mô-đun hệ thống Python

Tuy nhiên, một phương pháp khác mà bạn có thể sử dụng để in mà không cần dòng mới trong Python là mô-đun tích hợp có tên là sys

Đây là một ví dụ hoạt động cho thấy cách sử dụng mô-đun sys để in mà không cần chuỗi Python dòng mới

To work with the sys module, first, import the module sys using the import keyword. Next, make use of the stdout. write() method available inside the sys module, to print your strings

Hello World
Welcome to Guru99 Tutorials
0

đầu ra

Hello World Welcome to Guru99 Tutorials

Using print() to print a list without a newline

Consider a list of items for example. mylist = [“PHP”, JAVA”, “C++”, “C”, “PHYTHON”] and you want to print the values inside the list using for-loop. So here you can make use of print() to display the values inside the list as shown in the example below

Hello World
Welcome to Guru99 Tutorials
2

đầu ra

Hello World
Welcome to Guru99 Tutorials
3

The output shows the list items, each printed one after another, on a new line. What if you want all the items on the list in the same line? For that, make use of end argument inside print() that will remove new line in Python and print all items of the list in the same line

Hello World
Welcome to Guru99 Tutorials
4

đầu ra

Hello World
Welcome to Guru99 Tutorials
5

Printing the star(*) pattern without newline and space

The example of Python print without newline will make use of print() function to print stars(*) on the same line using for-loop

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. Bạn có thể sử dụng nó để hiển thị các tin nhắn được định dạng trên màn hình và có thể tìm thấy một số lỗi. 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 lot

Keep reading to take full advantage of this seemingly boring and unappreciated little function. This tutorial will get you up to speed with using Python

>>> import os
>>> os.linesep
'\r\n'
94 effectively. 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 offer

By the end of this tutorial, you’ll know how to

  • Avoid common mistakes with Python’s
    >>> import os
    >>> os.linesep
    '\r\n'
    
    94
  • Deal with newlines, character encodings, and buffering
  • Write text to files
  • Mock
    >>> import os
    >>> os.linesep
    '\r\n'
    
    94 in unit tests
  • 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 2

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

Remove ads

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

The simplest example of using Python

>>> import os
>>> os.linesep
'\r\n'
94 requires just a few keystrokes

>>>

>>> print()

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

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

>>> import os
>>> os.linesep
'\r\n'
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 module

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

Notice how these characters appear in string literals. 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 screen

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

  • >>> import os
    >>> os.linesep
    '\n'
    
    12. backslash
  • >>> import os
    >>> os.linesep
    '\n'
    
    13. backspace
  • >>> import os
    >>> os.linesep
    '\n'
    
    14. chuyển hướng
  • >>> import os
    >>> os.linesep
    '\n'
    
    08. carriage return (CR)
  • >>> import os
    >>> os.linesep
    '\n'
    
    09. newline, also known as line feed (LF)

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

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

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

>>> import os
>>> os.linesep
'\n'
17 tích hợp sẵn

>>>

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

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

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

>>> import os
>>> os.linesep
'\r\n'
94 mà không có đối số sẽ dẫn đến một dòng trống, là dòng chỉ bao gồm ký tự xuống dòng. Đừng nhầm lẫn điều này với một dòng trống, không chứa bất kỳ ký tự nào, thậm chí không có dòng mới

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

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

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

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

>>> import os
>>> os.linesep
'\n'
19 của nó, như thế này

>>>

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

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

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

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

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

>>>

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

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

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

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

>>> import os
>>> os.linesep
'\n'
21) hoặc dấu ngoặc kép (_______24_______22). Theo hướng dẫn phong cách 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ác

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

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

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

'My favorite book is "Python Tricks"'

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

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

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

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

Chạy trốn là tốt và bảnh bao, nhưng đôi khi nó có thể cản trở. Cụ thể, khi bạn cần chuỗi của mình chứa tương đối nhiều ký tự gạch chéo ngược ở dạng chữ

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

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

Lưu ý cách mỗi ký tự dấu gạch chéo ngược cần được thoát bằng một dấu gạch chéo ngược khác

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

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

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

>>> import os
>>> os.linesep
'\n'
23 hoặc
>>> import os
>>> os.linesep
'\n'
24 trước câu trích dẫn mở đầu, và bây giờ bạn sẽ có được điều này

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

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

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

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

>>> import os
>>> os.linesep
'\n'
25 hoặc
>>> import os
>>> os.linesep
'\n'
26, thường được sử dụng làm chuỗi tài liệu

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

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

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

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

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

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

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

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

>>> import os
>>> os.linesep
'\n'
28 tích hợp sẵn

>>>

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

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

>>> import os
>>> os.linesep
'\n'
28 để căn chỉnh văn bản mà bạn có thể tìm thấy trong trình xử lý văn bản

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

>>>

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

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

>>>

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

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

>>>

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

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

>>>

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

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

>>>

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

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

Note.

>>> import os
>>> os.linesep
'\n'
30 is a global built-in function that converts an object into its string representation

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

>>>

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

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

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

>>> import os
>>> os.linesep
'\r\n'
94 will accept anything regardless of its type

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

>>>

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

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

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

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

Okay, you’re now able to call

>>> import os
>>> os.linesep
'\r\n'
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 bit

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

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

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

That’s because

>>> import os
>>> os.linesep
'\n'
02 wasn’t a function back then, as you’ll see in the . Note, however, that in some cases parentheses in Python are redundant. It wouldn’t harm to include them as they’d just get ignored. Does that mean you should be using the
>>> import os
>>> os.linesep
'\n'
02 statement as if it were a function? Absolutely not

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

>>>

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

Round brackets are actually part of the expression rather than the

>>> import os
>>> os.linesep
'\n'
02 statement. If your expression happens to contain only one item, then it’s as if you didn’t include the brackets at all

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

>>>

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

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

>>>

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

The bottom line is that you shouldn’t call

>>> import os
>>> os.linesep
'\n'
02 with brackets in Python 2. Although, to be completely accurate, you can work around this with the help of a
>>> import os
>>> os.linesep
'\n'
41 import, which you’ll read more about in the relevant section

Remove ads

Separating Multiple Arguments

You saw

>>> import os
>>> os.linesep
'\r\n'
94 called without any arguments to produce a blank line and then called with a single argument to display either a fixed or a formatted message

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

Positional ArgumentsShow/Hide

Arguments can be passed to a function in one of several ways. One way is by explicitly naming the arguments when you’re calling the function, like this

>>>

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

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

>>>

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

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

>>>

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

>>> import os
>>> os.linesep
'\r\n'
94 allows an thanks to the
>>> import os
>>> os.linesep
'\n'
44 parameter

Let’s have a look at this example

>>>

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

>>> import os
>>> os.linesep
'\r\n'
94 concatenated all four arguments passed to it, and it inserted a single space between them so that you didn’t end up with a squashed message like
>>> import os
>>> os.linesep
'\n'
46

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

>>> import os
>>> os.linesep
'\n'
30 on each argument before joining them together. If you recall from the previous subsection, a naïve concatenation may easily result in an error due to incompatible types

>>>

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

Apart from accepting a variable number of positional arguments,

>>> import os
>>> os.linesep
'\r\n'
94 defines four named or keyword arguments, which are optional since they all have default values. You can view their brief documentation by calling
>>> import os
>>> os.linesep
'\n'
49 from the interactive interpreter

Let’s focus on

>>> import os
>>> os.linesep
'\n'
50 just for now. It stands for separator and is assigned a single space (
>>> import os
>>> os.linesep
'\n'
51) by default. It determines the value to join elements with

It has to be either a string or

>>> import os
>>> os.linesep
'\n'
32, but the latter has the same effect as the default space

>>>

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

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

>>> import os
>>> os.linesep
'\n'
53) instead

>>>

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

You may want

>>> import os
>>> os.linesep
'\r\n'
94 to join its arguments as separate lines. In that case, simply pass the escaped newline character described earlier

>>>

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

A more useful example of the

>>> import os
>>> os.linesep
'\n'
50 parameter would be printing something like file paths

>>>

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

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

>>>

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

Specifically, you can insert a slash character (

>>> import os
>>> os.linesep
'\n'
56) into the first positional argument, or use an empty string as the first argument to enforce the leading slash

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

Doing it manually will result in a well-known

>>> import os
>>> os.linesep
'\n'
57 if at least one of the elements isn’t a string

>>>

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

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

>>> import os
>>> os.linesep
'\n'
58) and let
>>> import os
>>> os.linesep
'\r\n'
94 handle type casting

>>>

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

Unpacking is effectively the same as calling

>>> import os
>>> os.linesep
'\r\n'
94 with individual elements of the list

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

>>>

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

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

>>> import os
>>> os.linesep
'\r\n'
94 to write text to files straight from Python

Finally, the

>>> import os
>>> os.linesep
'\n'
50 parameter isn’t constrained to a single character only. You can join elements with strings of any length

>>>

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

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

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

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

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

>>>

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

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

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

>>>

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

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

>>>

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

That was the default way of formatting strings until the

>>> import os
>>> os.linesep
'\n'
65 method got backported from Python 3

Remove ads

Preventing Line Breaks

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

>>> import os
>>> os.linesep
'\r\n'
94 will continue on the same line. Classic examples include updating the progress of a long-running operation or prompting the user for input. In the latter case, you want the user to type in the answer on the same line

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

Many programming languages expose functions similar to

>>> import os
>>> os.linesep
'\r\n'
94 through their standard libraries, but they let you decide whether to add a newline or not. For example, in Java and C#, you have two distinct functions, while other languages require you to explicitly append
>>> import os
>>> os.linesep
'\n'
09 at the end of a string literal

Here are a few examples of syntax in such languages

LanguageExamplePerl

>>> import os
>>> os.linesep
'\n'
69C
>>> import os
>>> os.linesep
'\n'
70C++
>>> import os
>>> os.linesep
'\n'
71

In contrast, Python’s

>>> import os
>>> os.linesep
'\r\n'
94 function always adds
>>> import os
>>> os.linesep
'\n'
09 without asking, because that’s what you want in most cases. To disable it, you can take advantage of yet another keyword argument,
>>> import os
>>> os.linesep
'\n'
74, which dictates what to end the line with

In terms of semantics, the

>>> import os
>>> os.linesep
'\n'
74 parameter is almost identical to the
>>> import os
>>> os.linesep
'\n'
50 one that you saw earlier

  • It must be a string or
    >>> import os
    >>> os.linesep
    '\n'
    
    32
  • It can be arbitrarily long
  • It has a default value of
    >>> import os
    >>> os.linesep
    '\n'
    
    78
  • If equal to
    >>> import os
    >>> os.linesep
    '\n'
    
    32, it’ll have the same effect as the default value
  • If equal to an empty string (
    >>> import os
    >>> os.linesep
    '\n'
    
    53), it’ll suppress the newline

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

>>> import os
>>> os.linesep
'\r\n'
94 without arguments. Since you don’t provide any positional arguments to the function, there’s nothing to be joined, and so the default separator isn’t used at all. However, the default value of
>>> import os
>>> os.linesep
'\n'
74 still applies, and a blank line shows up

Note. You may be wondering why the

>>> import os
>>> os.linesep
'\n'
74 parameter has a fixed default value rather than whatever makes sense on your operating system

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

>>> import os
>>> os.linesep
'\r\n'
94 will handle the conversion automatically. Just remember to always use the
>>> import os
>>> os.linesep
'\n'
09 escape sequence in string literals

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

>>>

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

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

>>>

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

On 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. The function will translate any system-specific newline it encounters into a universal
>>> import os
>>> os.linesep
'\n'
78. At the same time, you have control over how the newlines should be treated both on input and output if you really need that

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

>>> import os
>>> os.linesep
'\n'
74 keyword argument

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

Even though these are two separate

>>> import os
>>> os.linesep
'\r\n'
94 calls, which can execute a long time apart, you’ll eventually see only one line. First, it’ll look like this

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

However, after the second call to

>>> import os
>>> os.linesep
'\r\n'
94, the same line will appear on the screen as

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

Như 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. Instead of joining multiple arguments, however, it’ll append text from each function call to the same line

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

These three instructions will output a single line of text

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

You can mix the two keyword arguments

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

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

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

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

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

It would print out the following piece of text

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

As you can see, the

>>> import os
>>> os.linesep
'\n'
74 keyword argument will accept arbitrary strings

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

>>> import os
>>> os.linesep
'\r\n'
94 function’s default behavior will result in a redundant newline character

>>>

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

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

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

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

>>> import os
>>> os.linesep
'\r\n'
94 automatically. You’d use the
>>> import os
>>> os.linesep
'\n'
74 keyword argument to do that

>>>

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

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

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

>>> import os
>>> os.linesep
'\r\n'
94 function’s output

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

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

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

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

>>> import os
>>> os.linesep
'\n'
98 instead of
>>> import os
>>> os.linesep
'\n'
99 in Python 3. You can test this with the following code snippet

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

Notice there’s a space between the words

>>> import os
>>> os.linesep
'\r'
00 and
>>> import os
>>> os.linesep
'\r'
01

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

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

>>> import os
>>> os.linesep
'\r\n'
94 function from
>>> import os
>>> os.linesep
'\n'
41 or falling back to the
>>> import os
>>> os.linesep
'\r'
04 module

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

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

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

While using the

>>> import os
>>> os.linesep
'\r'
04 module gives you control over what gets printed to the standard output, the code becomes a little bit more cluttered

Remove ads

Printing to a File

Believe it or not,

>>> import os
>>> os.linesep
'\r\n'
94 doesn’t know how to turn messages into text on your screen, and frankly it doesn’t need to. That’s a job for lower-level layers of code, which understand bytes and know how to push them around

>>> import os
>>> os.linesep
'\r\n'
94 is an abstraction over these layers, providing a convenient interface that merely delegates the actual printing to a stream or file-like object. A stream can be any file on your disk, a network socket, or perhaps an in-memory buffer

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

  1. >>> import os
    >>> os.linesep
    '\r'
    
    08. standard input
  2. >>> import os
    >>> os.linesep
    '\r'
    
    09. standard output
  3. >>> import os
    >>> os.linesep
    '\r'
    
    10. standard error

Standard StreamsShow/Hide

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

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

Unless otherwise instructed,

>>> import os
>>> os.linesep
'\r\n'
94 will default to writing to standard output. However, you can tell your operating system to temporarily swap out
>>> import os
>>> os.linesep
'\r'
09 for a file stream, so that any output ends up in that file rather than the screen

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

That’s called stream redirection

The standard error is similar to

>>> import os
>>> os.linesep
'\r'
09 in that it also shows up on the screen. Nonetheless, it’s a separate stream, whose purpose is to log error messages for diagnostics. By redirecting one or both of them, you can keep things clean

Note. To redirect

>>> import os
>>> os.linesep
'\r'
10, you need to know about file descriptors, also known as file handles

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

StreamFile Descriptor

>>> import os
>>> os.linesep
'\r'
080
>>> import os
>>> os.linesep
'\r'
091
>>> import os
>>> os.linesep
'\r'
102

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

CommandDescription

>>> import os
>>> os.linesep
'\r'
18Redirect
>>> import os
>>> os.linesep
'\r'
09
>>> import os
>>> os.linesep
'\r'
20Redirect
>>> import os
>>> os.linesep
'\r'
10
>>> import os
>>> os.linesep
'\r'
22Redirect
>>> import os
>>> os.linesep
'\r'
09 and
>>> import os
>>> os.linesep
'\r'
10 to separate files
>>> import os
>>> os.linesep
'\r'
25Redirect
>>> import os
>>> os.linesep
'\r'
09 and
>>> import os
>>> os.linesep
'\r'
10 to the same file

Note that

>>> import os
>>> os.linesep
'\r'
28 is the same as
>>> import os
>>> os.linesep
'\r'
29

Some programs use different coloring to distinguish between messages printed to

>>> import os
>>> os.linesep
'\r'
09 and
>>> import os
>>> os.linesep
'\r'
10

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

While both

>>> import os
>>> os.linesep
'\r'
09 and
>>> import os
>>> os.linesep
'\r'
10 are write-only,
>>> import os
>>> os.linesep
'\r'
08 is read-only. You can think of standard input as your keyboard, but just like with the other two, you can swap out
>>> import os
>>> os.linesep
'\r'
08 for a file to read data from

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

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

>>>

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

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

>>> import os
>>> os.linesep
'\r'
37 and
>>> import os
>>> os.linesep
'\r'
38 attributes as well as
>>> import os
>>> os.linesep
'\r'
39 and
>>> import os
>>> os.linesep
'\r'
40 methods among many others

By default,

>>> import os
>>> os.linesep
'\r\n'
94 is bound to
>>> import os
>>> os.linesep
'\r'
42 through its
>>> import os
>>> os.linesep
'\r'
43 argument, but you can change that. Use that keyword argument to indicate a file that was open in write or append mode, so that messages go straight to it

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

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

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

Note. Don’t try using

>>> import os
>>> os.linesep
'\r\n'
94 for writing binary data as it’s only well suited for text

Just call the binary file’s

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

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

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

>>> import os
>>> os.linesep
'\r'
42 is a character stream

>>>

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

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

>>>

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

This prints an uppercase letter

>>> import os
>>> os.linesep
'\r'
47 and a newline character, which correspond to decimal values of 65 and 10 in ASCII. However, they’re encoded using hexadecimal notation in the bytes literal

Note that

>>> import os
>>> os.linesep
'\r\n'
94 has no control over character encoding. It’s the stream’s responsibility to encode received Unicode strings into bytes correctly. In most cases, you won’t set the encoding yourself, because the default UTF-8 is what you want. If you really need to, perhaps for legacy systems, you can use the
>>> import os
>>> os.linesep
'\r'
38 argument of
>>> import os
>>> os.linesep
'\n'
86

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

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

>>> import os
>>> os.linesep
'\r\n'
94 in unit tests

>>>

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

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

>>> import os
>>> os.linesep
'\r\n'
94, which you’ll see in the next subsection. It’s probably the least used of them all. Nevertheless, there are times when it’s absolutely necessary

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

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

>>> import os
>>> os.linesep
'\r'
42 with a custom file in the
>>> import os
>>> os.linesep
'\n'
02 statement

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

Because strings and bytes are represented with the same

>>> import os
>>> os.linesep
'\r'
55 type in Python 2, the
>>> import os
>>> os.linesep
'\n'
02 statement can handle binary data just fine

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

Although, there’s a problem with character encoding. The

>>> import os
>>> os.linesep
'\n'
86 function in Python 2 lacks the
>>> import os
>>> os.linesep
'\r'
38 parameter, which would often result in the dreadful
>>> import os
>>> os.linesep
'\r'
59

>>>

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

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

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

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

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

Đặt cược tốt nhất của bạn là mã hóa chuỗi Unicode ngay trước khi in nó. You can do this manually

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

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

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

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

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

Remove ads

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

In the previous subsection, you learned that

>>> import os
>>> os.linesep
'\r\n'
94 delegates printing to a file-like object such as
>>> import os
>>> os.linesep
'\r'
42. Some streams, however, buffer certain I/O operations to enhance performance, which can get in the way. Let’s take a look at an example

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

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

Your first attempt may look something like this

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

As long as the

>>> import os
>>> os.linesep
'\r'
64 variable is greater than zero, the code keeps appending text without a trailing newline and then goes to sleep for one second. Finally, when the countdown is finished, it prints
>>> import os
>>> os.linesep
'\r'
65 and terminates the line

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

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

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

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

Unbuffered is self-explanatory, that is, no buffering is taking place, and all writes have immediate effect. A line-buffered stream waits before firing any I/O calls until a line break appears somewhere in the buffer, whereas a block-buffered one simply allows the buffer to fill up to a certain size regardless of its content. Standard output is both line-buffered and block-buffered, depending on which event comes first

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

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

>>> import os
>>> os.linesep
'\r\n'
94 to forcefully flush the stream without waiting for a newline character in the buffer using its
>>> import os
>>> os.linesep
'\r'
67 flag

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

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

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

>>> import os
>>> os.linesep
'\r\n'
94 that cover all of its parameters. You know their purpose and when to use them. Tuy nhiên, việc hiểu chữ ký chỉ là bước đầu. In the upcoming sections, you’ll see why

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

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

>>> import os
>>> os.linesep
'\n'
02 statement doesn’t allow for it by itself. You need to get a handle of its lower-level layer, which is the standard output, and call it directly

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

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

>>> import os
>>> os.linesep
'\r'
70 flag to the Python interpreter or by setting up the
>>> import os
>>> os.linesep
'\r'
71 environment variable

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

Lư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'
67

>>>

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

What you’re seeing here is a docstring of the

>>> import os
>>> os.linesep
'\r\n'
94 function. You can display docstrings of various objects in Python using the built-in
>>> import os
>>> os.linesep
'\r'
76 function

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

Up until now, you only dealt with built-in data types such as strings and numbers, but you’ll often want to print your own abstract data types. Chúng ta hãy xem xét các cách khác nhau để định nghĩa chúng

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

>>> import os
>>> os.linesep
'\r'
77, có sẵn trong thư viện tiêu chuẩn. Các bộ dữ liệu được đặt tên có một biểu diễn văn bản gọn gàng ngoài hộp

>>>

'My favorite book is "Python Tricks"'
0

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

>>> import os
>>> os.linesep
'\r'
78, cuối cùng bạn sẽ cần xác định một lớp. Hãy xem ví dụ này

'My favorite book is "Python Tricks"'
1

If you now create an instance of the

>>> import os
>>> os.linesep
'\r'
78 class and try to print it, you’ll get this bizarre output, which is quite different from the equivalent
>>> import os
>>> os.linesep
'\r'
77

>>>

'My favorite book is "Python Tricks"'
2

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

>>> import os
>>> os.linesep
'\r'
77 and a custom class through inheritance

'My favorite book is "Python Tricks"'
3

Your

>>> import os
>>> os.linesep
'\r'
78 class has just become a specialized kind of
>>> import os
>>> os.linesep
'\r'
77 with two attributes, which you can customize

Note. In Python 3, the

>>> import os
>>> os.linesep
'\r'
84 statement can be replaced with the ellipsis (
>>> import os
>>> os.linesep
'\r'
85) literal to indicate a placeholder

'My favorite book is "Python Tricks"'
4

This prevents the interpreter from raising

>>> import os
>>> os.linesep
'\r'
86 due to missing indented block of code

That’s better than a plain

>>> import os
>>> os.linesep
'\r'
77, because not only do you get printing right for free, but you can also add custom methods and properties to the class. However, it solves one problem while introducing another. Remember that tuples, including named tuples, are immutable in Python, so they can’t change their values once created

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

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

>>>

'My favorite book is "Python Tricks"'
5

The syntax for variable annotations, which is required to specify class fields with their corresponding types, was defined in Python 3. 6

From earlier subsections, you already know that

>>> import os
>>> os.linesep
'\r\n'
94 implicitly calls the built-in
>>> import os
>>> os.linesep
'\n'
30 function to convert its positional arguments into strings. Indeed, calling
>>> import os
>>> os.linesep
'\n'
30 manually against an instance of the regular
>>> import os
>>> os.linesep
'\r'
78 class yields the same result as printing it

>>>

'My favorite book is "Python Tricks"'
6

>>> import os
>>> os.linesep
'\n'
30, in turn, looks for one of two magic methods within the class body, which you typically implement. If it doesn’t find one, then it falls back to the ugly default representation. Those magic methods are, in order of search

  1. >>> import os
    >>> os.linesep
    '\r'
    
    93
  2. >>> import os
    >>> os.linesep
    '\r'
    
    94

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

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

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

>>>

'My favorite book is "Python Tricks"'
7

Notice the use of another built-in function,

>>> import os
>>> os.linesep
'\r'
96, which always tries to call
>>> import os
>>> os.linesep
'\r'
97 in an object, but falls back to the default representation if it doesn’t find that method

Note. Even though

>>> import os
>>> os.linesep
'\r\n'
94 itself uses
>>> import os
>>> os.linesep
'\n'
30 for type casting, some compound data types delegate that call to
>>> import os
>>> os.linesep
'\r'
96 on their members. This happens to lists and tuples, for example

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

'My favorite book is "Python Tricks"'
8

If you print a single object of the

>>> ord('r')
114
>>> ord('\r')
13
01 class, then you won’t see the password, because
>>> ord('r')
114
>>> ord('\r')
13
02 will call
>>> ord('r')
114
>>> ord('\r')
13
03, which eventually will invoke
>>> ord('r')
114
>>> ord('\r')
13
04

>>>

'My favorite book is "Python Tricks"'
9

However, if you put the same

>>> ord('r')
114
>>> ord('\r')
13
05 variable inside a list by wrapping it in square brackets, then the password will become clearly visible

>>>

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

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

>>> ord('r')
114
>>> ord('\r')
13
06 method so that all of their elements are first converted with
>>> import os
>>> os.linesep
'\r'
96

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

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

The semantics of

>>> ord('r')
114
>>> ord('\r')
13
06 and
>>> import os
>>> os.linesep
'\r'
97 didn’t change since Python 2, but you must remember that strings were nothing more than glorified byte arrays back then. To convert your objects into proper Unicode, which was a separate data type, you’d have to provide yet another magic method.
>>> ord('r')
114
>>> ord('\r')
13
10

Here’s an example of the same

>>> ord('r')
114
>>> ord('\r')
13
01 class in Python 2

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

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

>>> ord('r')
114
>>> ord('\r')
13
12 function on itself

Both

>>> ord('r')
114
>>> ord('\r')
13
06 and
>>> import os
>>> os.linesep
'\r'
97 methods must return strings, so they encode Unicode characters into specific byte representations called character sets. UTF-8 is the most widespread and safest encoding, while
>>> ord('r')
114
>>> ord('\r')
13
15 is a special constant to express funky characters, such as
>>> ord('r')
114
>>> ord('\r')
13
16, as escape sequences in plain ASCII, such as
>>> ord('r')
114
>>> ord('\r')
13
17

The

>>> import os
>>> os.linesep
'\n'
02 statement is looking for the magic
>>> ord('r')
114
>>> ord('\r')
13
06 method in the class, so the chosen charset must correspond to the one used by the terminal. For example, default encoding in DOS and Windows is CP 852 rather than UTF-8, so running this can result in a
>>> import os
>>> os.linesep
'\r'
59 or even garbled output

>>>

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

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

>>>

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

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

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

>>> ord('r')
114
>>> ord('\r')
13
10 method in Python 3 anymore. You may be asking yourself if it’s possible to convert an object to its byte string representation rather than a Unicode string in Python 3. It’s possible, with a special
>>> ord('r')
114
>>> ord('\r')
13
22 method that does just that

>>>

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

Using the built-in

>>> ord('r')
114
>>> ord('\r')
13
23 function on an instance delegates the call to its
>>> ord('r')
114
>>> ord('\r')
13
24 method defined in the corresponding class

Remove ads

Understanding Python >>> import os >>> os.linesep '\r\n' 94

You know how to use

>>> import os
>>> os.linesep
'\r\n'
94 quite well at this point, but knowing what it is will allow you to use it even more effectively and consciously. 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 qua

You’ve seen that

>>> import os
>>> os.linesep
'\r\n'
94 is a function in Python 3. More specifically, it’s a built-in function, which means that you don’t need to import it from anywhere

>>>

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

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

>>>

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

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

>>> import os
>>> os.linesep
'\r\n'
94 so that it doesn’t append a trailing newline. At the same time, you wanted to rename the original function to something like
>>> ord('r')
114
>>> ord('\r')
13
29

>>>

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

Now you have two separate printing functions just like in the Java programming language. Bạn cũng sẽ định nghĩa các hàm

>>> import os
>>> os.linesep
'\r\n'
94 tùy chỉnh sau này. Also, note that you wouldn’t be able to overwrite
>>> import os
>>> os.linesep
'\r\n'
94 in the first place if it wasn’t a function

Mặ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ị ngầm định
>>> import os
>>> os.linesep
'\n'
32

>>>

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

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

>>> import os
>>> os.linesep
'\r\n'
94, that side-effect is showing a message on the standard output or writing to a file

Because

>>> import os
>>> os.linesep
'\r\n'
94 is a function, it has a well-defined signature with known attributes. You can quickly find its documentation using the editor of your choice, without having to remember some weird syntax for performing a certain task

Besides, functions are easier to extend. Adding a new feature to a function is as easy as adding another keyword argument, whereas changing the language to support that new feature is much more cumbersome. Think of stream redirection or buffer flushing, for example

Another benefit of

>>> import os
>>> os.linesep
'\r\n'
94 being a function is composability. Functions are so-called first-class objects or first-class citizens in Python, which is a fancy way of saying they’re values just like strings or numbers. This way, you can assign a function to a variable, pass it to another function, or even return one from another.
>>> import os
>>> os.linesep
'\r\n'
94 isn’t different in this regard. For instance, you can take advantage of it for dependency injection

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

Here, the

>>> ord('r')
114
>>> ord('\r')
13
38 parameter lets you inject a callback function, which defaults to
>>> import os
>>> os.linesep
'\r\n'
94 but can be any callable. In this example, printing is completely disabled by substituting
>>> import os
>>> os.linesep
'\r\n'
94 with a dummy function that does nothing

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

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

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

Dependency injection for five-year-olds

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

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

— John Munsch, 28 October 2009. (Source)

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

>>> ord('r')
114
>>> ord('\r')
13
41 function that prints to the standard error stream and prefixes all messages with a given log level

>>>

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

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

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

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

>>> import os
>>> os.linesep
'\r\n'
94 with, you can make an anonymous lambda expression that calls it

>>>

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

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

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

Another kind of expression is a ternary conditional expression

>>>

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

Python has both conditional statements and . Cái sau được đánh giá thành một giá trị có thể được gán cho một biến hoặc được truyền cho một hàm. In the example above, you’re interested in the side-effect rather than the value, which evaluates to

>>> import os
>>> os.linesep
'\n'
32, so you simply ignore it

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

>>> import os
>>> os.linesep
'\r\n'
94 là một hàm gây ra nhiều vấn đề đau đầu như thế nào

Remove ads

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

Một câu lệnh là một hướng dẫn có thể gây ra tác dụng phụ khi được thực thi nhưng không bao giờ đánh giá thành một giá trị. In other words, you wouldn’t be able to print a statement or assign it to a variable like this

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

That’s a syntax error in Python 2

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

  • assignment.
    >>> ord('r')
    114
    >>> ord('\r')
    13
    
    47
  • conditional.
    >>> ord('r')
    114
    >>> ord('\r')
    13
    
    48
  • loop.
    >>> ord('r')
    114
    >>> ord('\r')
    13
    
    49
  • quả quyết.
    >>> ord('r')
    114
    >>> ord('\r')
    13
    
    50

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

>>> ord('r')
114
>>> ord('\r')
13
51), là một biểu thức gán. Với nó, bạn có thể đánh giá một biểu thức và gán kết quả cho một biến cùng một lúc, ngay cả trong một biểu thức khác

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

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

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

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

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

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

>>> ord('r')
114
>>> ord('\r')
13
48,
>>> ord('r')
114
>>> ord('\r')
13
53 hoặc
>>> import os
>>> os.linesep
'\n'
02 có nghĩa cố định trong ngôn ngữ. Bạn không thể sử dụng chúng để đặt tên cho các biến của mình hoặc các ký hiệu khác. Đó là lý do tại sao không thể xác định lại hoặc chế nhạo câu lệnh
>>> import os
>>> os.linesep
'\n'
02 trong Python 2. Bạn bị mắc kẹt với những gì bạn nhận được

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

>>>

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

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

>>> import os
>>> os.linesep
'\n'
02 không rõ ràng. Đôi khi bạn có thể thêm dấu ngoặc đơn xung quanh tin nhắn và chúng hoàn toàn không bắt buộc

>>>

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

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

>>>

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

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

>>> import os
>>> os.linesep
'\n'
57 do các loại không tương thích, chẳng hạn như bạn phải xử lý thủ công

>>>

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

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

>>>

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

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

>>> import os
>>> os.linesep
'\r'
76 tích hợp cũng không hữu ích đối với câu lệnh
>>> import os
>>> os.linesep
'\n'
02

>>>

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

Loại bỏ dòng mới ở cuối không hoạt động hoàn toàn đúng vì nó thêm một khoảng trống không mong muốn. Bạn không thể soạn nhiều câu lệnh

>>> import os
>>> os.linesep
'\n'
02 cùng nhau, và trên hết, bạn phải cực kỳ siêng năng trong việc mã hóa ký tự

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

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

>>> import os
>>> os.linesep
'\r\n'
94 đã được nhập lại để dễ dàng chuyển sang Python 3. Bạn có thể nhập nó từ một mô-đun
>>> import os
>>> os.linesep
'\n'
41 đặc biệt, hiển thị một loạt các tính năng ngôn ngữ được phát hành trong các phiên bản Python sau này

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

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

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

>>>

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

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

>>> ord('r')
114
>>> ord('\r')
13
64, nhưng điều đó sẽ hiển thị nhiều chi tiết bên trong không thú vị của mô-đun

Để bật hàm

>>> import os
>>> os.linesep
'\r\n'
94 trong Python 2, bạn cần thêm câu lệnh nhập này vào đầu mã nguồn của mình

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

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

>>> import os
>>> os.linesep
'\n'
02 không còn nữa, nhưng bạn có thể tùy ý sử dụng hàm
>>> import os
>>> os.linesep
'\r\n'
94. Lưu ý rằng nó không giống chức năng như trong Python 3, vì nó thiếu đối số từ khóa
>>> import os
>>> os.linesep
'\r'
67, nhưng các đối số còn lại đều giống nhau

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

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

>>> import os
>>> os.linesep
'\r\n'
94 trong Python 2

>>>

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

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

Remove ads

In ấn theo phong cách

Nếu bạn nghĩ rằng in ấn chỉ là làm sáng các điểm ảnh trên màn hình, thì về mặt kỹ thuật, bạn đã đúng. Tuy nhiên, có nhiều cách để làm cho nó trông thật ngầu. Trong phần này, bạn sẽ tìm hiểu cách định dạng cấu trúc dữ liệu phức tạp, thêm màu sắc và các trang trí khác, xây dựng giao diện, sử dụng hoạt ảnh và thậm chí phát âm thanh với văn bản

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

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

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

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

>>> ord('r')
114
>>> ord('\r')
13
70 trong thư viện tiêu chuẩn của nó, mô-đun này sẽ giúp bạn in các cấu trúc dữ liệu lớn đẹp mắt không vừa trên một dòng. Vì nó in theo cách thân thiện với con người hơn nên nhiều công cụ REPL phổ biến, bao gồm JupyterLab và IPython, sử dụng nó theo mặc định thay cho hàm
>>> import os
>>> os.linesep
'\r\n'
94 thông thường

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

>>>

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

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

>>> ord('r')
114
>>> ord('\r')
13
72), nhưng bạn có thể tìm thêm trên PyPI hoặc thậm chí tạo lệnh của riêng mình

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

>>> import os
>>> os.linesep
'\r\n'
94 ban đầu, thì bạn có thể thay thế nó bằng
>>> ord('r')
114
>>> ord('\r')
13
74 trong mã của mình bằng cách nhập đổi tên

>>>

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

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

>>> ord('r')
114
>>> ord('\r')
13
75 làm bí danh ngắn

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

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

>>>

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

Đó là bởi vì

>>> ord('r')
114
>>> ord('\r')
13
74 gọi
>>> import os
>>> os.linesep
'\r'
96 thay vì
>>> import os
>>> os.linesep
'\n'
30 thông thường để truyền kiểu, do đó bạn có thể đánh giá đầu ra của nó dưới dạng mã Python nếu bạn muốn. Sự khác biệt trở nên rõ ràng khi bạn bắt đầu cung cấp cho nó các cấu trúc dữ liệu phức tạp hơn

>>>

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

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

>>>

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

>>> import os
>>> os.linesep
'\r\n'
94 thông thường cũng sử dụng dấu chấm lửng nhưng để hiển thị cấu trúc dữ liệu đệ quy, tạo thành một chu trình, để tránh lỗi tràn ngăn xếp

>>>

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

Tuy nhiên,

>>> ord('r')
114
>>> ord('\r')
13
74 rõ ràng hơn về nó bằng cách bao gồm danh tính duy nhất của một đối tượng tự tham chiếu

>>>

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

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

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

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

>>>

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

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

>>> ord('r')
114
>>> ord('\r')
13
74 tự động sắp xếp các khóa từ điển cho bạn trước khi in, cho phép so sánh nhất quán. Khi bạn đang so sánh các chuỗi, bạn thường không quan tâm đến thứ tự cụ thể của các thuộc tính được tuần tự hóa. Dù sao đi nữa, tốt nhất bạn nên so sánh các từ điển thực tế trước khi đăng nhiều kỳ hơn

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

>>> ord('r')
114
>>> ord('\r')
13
83. Nó cũng có khả năng in đẹp

>>>

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

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

>>> ord('r')
114
>>> ord('\r')
13
70 có thêm một hàm
>>> ord('r')
114
>>> ord('\r')
13
85 trả về một chuỗi, trong trường hợp bạn phải làm gì đó ngoài việc in nó

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

>>> ord('r')
114
>>> ord('\r')
13
74 không giống chữ ký của hàm
>>> import os
>>> os.linesep
'\r\n'
94. 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ệu

Remove ads

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

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

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

>>> ord('r')
114
>>> ord('\r')
13
88 trong Python. Nó dịch mã ANSI sang các đối tác thích hợp của chúng trong Windows trong khi vẫn giữ chúng nguyên vẹn trong các hệ điều hành khác

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

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

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

>>> ord('r')
114
>>> ord('\r')
13
89 hoặc
>>> ord('r')
114
>>> ord('\r')
13
90, để thay đổi giao diện của các phần tử 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. Nếu không, chúng sẽ xuất hiện ở dạng chữ như thể bạn đang xem mã nguồn của một trang web

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

>>> ord('r')
114
>>> ord('\r')
13
91 . 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'
36

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

>>> ord('r')
114
>>> ord('\r')
13
93 trong trình bao

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

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

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

>>> ord('r')
114
>>> ord('\r')
13
95mở dấu ngoặc vuông
>>> ord('r')
114
>>> ord('\r')
13
95mã sốmột hoặc nhiều số được phân tách bằng
>>> ord('r')
114
>>> ord('\r')
13
97
>>> ord('r')
114
>>> ord('\r')
13
98mã ký tự chữ hoa hoặc chữ thường
>>> ord('r')
114
>>> ord('\r')
13
99

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

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

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

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

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

>>>

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

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

'\n'  # Blank line
''    # Empty line
01 xuất hiện ở phông chữ màu đỏ, in đậm và gạch chân

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

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

>>> ord('r')
114
>>> ord('\r')
13
88 đã đề 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ển

Remove ads

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

Mặc dù không thể phủ nhận việc chơi với các mã thoát ANSI rất thú vị, nhưng trong thế giới thực, bạn muốn có nhiều khối xây dựng trừu tượng hơn để kết hợp giao diện người dùng. Có một số thư viện cung cấp mức độ kiểm soát cao như vậy đối với thiết bị đầu cuối, nhưng

'\n'  # Blank line
''    # Empty line
03 dường như là lựa chọn phổ biến nhất

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

'\n'  # Blank line
''    # Empty line
03 trong Windows, bạn cần cài đặt gói của bên thứ ba

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

Đó là bởi vì

'\n'  # Blank line
''    # Empty line
03 không có sẵn trong thư viện tiêu chuẩn của bản phân phối Python cho Windows

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

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

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

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

'\n'  # Blank line
''    # Empty line
03. Vì nó sửa đổi trạng thái của thiết bị đầu cuối đang chạy, điều quan trọng là phải xử lý lỗi và khôi phục trạng thái trước đó một cách duyên dáng. Bạn có thể thực hiện việc này theo cách thủ công, nhưng thư viện đi kèm với trình bao bọc thuận tiện cho chức năng chính của bạn

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

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

'\n'  # Blank line
''    # Empty line
07, mà bạn sẽ sử dụng sau này để thiết lập bổ sung

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

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

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

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

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

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

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

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

'\n'  # Blank line
''    # Empty line
08, vì vậy bạn có thể giải nén chúng

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

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

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

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

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

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

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

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

'\n'  # Blank line
''    # Empty line
09,
'\n'  # Blank line
''    # Empty line
10 và
'\n'  # Blank line
''    # Empty line
11

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

'\n'  # Blank line
''    # Empty line
12 để lấy mã phím đã nhấn. Tuy nhiên, nếu phím được nhấn không tương ứng với các phím mũi tên được xác định trước đó là phím từ điển, hướng sẽ không thay đổi

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

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

'\n'  # Blank line
''    # Empty line
12 là một cuộc gọi chặn sẽ ngăn con rắn di chuyển trừ khi có một lần nhấn phím. Do đó, bạn cần thực hiện cuộc gọi không bị chặn bằng cách thêm một cấu hình khác

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

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

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

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

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

'\n'  # Blank line
''    # Empty line
03 mở ra. Bạn có thể sử dụng nó để phát triển trò chơi như thế này hoặc nhiều ứng dụng định hướng kinh doanh hơn

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

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

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

'\n'  # Blank line
''    # Empty line
03. Tuy nhiên, tôi muốn chỉ cho bạn một cách thậm chí còn đơn giản hơn

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

  • Vận chuyển trở lại.
    >>> import os
    >>> os.linesep
    '\n'
    
    08
  • xóa lùi.
    >>> import os
    >>> os.linesep
    '\n'
    
    13

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

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

Bạn sẽ thường muốn hiển thị một số loại bánh xe quay để chỉ ra một công việc đang tiến hành mà không biết chính xác còn bao nhiêu thời gian để hoàn thành

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

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

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

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

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

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

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

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

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

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

'\n'  # Blank line
''    # Empty line
18 giàu tính năng, cùng với một số công cụ tương tự khác, có thể hiển thị tiến độ theo cách toàn diện hơn nhiều

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

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

Ngày nay, bạn vẫn có thể tận dụng chiếc loa nhỏ này, nhưng rất có thể máy tính xách tay của bạn không đi kèm với chiếc loa này. Trong trường hợp như vậy, bạn có thể bật mô phỏng chuông đầu cuối trong trình bao của mình để âm thanh cảnh báo hệ thống được phát thay thế

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

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

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

'\n'  # Blank line
''    # Empty line
20 cho phép giải thích các dấu gạch chéo ngược thoát. Như bạn có thể thấy, có một chuỗi thoát chuyên dụng
'\n'  # Blank line
''    # Empty line
21, viết tắt của “alert”, tạo ra một ký tự chuông đặc biệt. Một số thiết bị đầu cuối phát ra âm thanh bất cứ khi nào họ nhìn thấy nó

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

Các quy tắc như sau

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

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

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

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

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

Có lẽ bạn thậm chí có thể tiến thêm một bước và tạo một công cụ dòng lệnh để dịch văn bản sang mã Morse?

Mocking Python >>> import os >>> os.linesep '\r\n' 94 trong bài kiểm tra đơn vị

Ngày nay, bạn mong đợi rằng bạn gửi mã đáp ứng các tiêu chuẩn chất lượng cao. Nếu bạn khao khát trở thành một chuyên gia, bạn phải học cách kiểm tra mã của mình

Kiểm thử phần mềm đặc biệt quan trọng trong các ngôn ngữ được nhập động, chẳng hạn như Python, không có trình biên dịch để cảnh báo bạn về những lỗi rõ ràng. Các lỗi có thể tìm đường đến môi trường sản xuất và không hoạt động trong một thời gian dài, cho đến một ngày khi một nhánh mã cuối cùng được thực thi

Chắc chắn rồi, bạn có , trình kiểm tra loại và các công cụ khác để phân tích mã tĩnh để hỗ trợ bạn. Nhưng họ sẽ không cho bạn biết liệu chương trình của bạn có làm những gì nó phải làm ở cấp độ doanh nghiệp hay không

Vì vậy, bạn có nên thử nghiệm

>>> import os
>>> os.linesep
'\r\n'
94 không? . Xét cho cùng, đó là một chức năng tích hợp sẵn phải trải qua một bộ kiểm tra toàn diện. Tuy nhiên, điều bạn muốn kiểm tra là liệu mã của bạn có đang gọi
>>> import os
>>> os.linesep
'\r\n'
94 vào đúng thời điểm với các tham số dự kiến ​​hay không. Đó được gọi là một hành vi

Bạn có thể kiểm tra các hành vi bằng cách mô phỏng các đối tượng hoặc chức năng thực. Trong trường hợp này, bạn muốn giả định

>>> import os
>>> os.linesep
'\r\n'
94 để ghi lại và xác minh các yêu cầu của nó

Ghi chú. Bạn có thể đã nghe các điều khoản. dummy, fake, stub, spy, hoặc mock được sử dụng thay thế cho nhau. Một số người phân biệt giữa chúng, trong khi những người khác thì không

Martin Fowler giải thích sự khác biệt của chúng trong một bảng thuật ngữ ngắn và gọi chung chúng là kiểm tra nhân đôi

Mocking trong Python có thể được thực hiện gấp đôi. Đầu tiên, bạn có thể đi theo con đường truyền thống của các ngôn ngữ được gõ tĩnh bằng cách sử dụng phép nội xạ phụ thuộc. Điều này đôi khi có thể yêu cầu bạn thay đổi mã đang được kiểm tra, điều này không phải lúc nào cũng thực hiện được nếu mã được xác định trong thư viện bên ngoài

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

Đây là ví dụ giống như tôi đã sử dụng trong phần trước để nói về thành phần chức năng. Về cơ bản, nó cho phép thay thế

>>> import os
>>> os.linesep
'\r\n'
94 bằng một chức năng tùy chỉnh của cùng một giao diện. Để kiểm tra xem nó có in đúng thông báo hay không, bạn phải chặn nó bằng cách đưa vào một hàm giả lập

>>>

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

Gọi mô hình này làm cho nó lưu thông báo cuối cùng trong một thuộc tính mà bạn có thể kiểm tra sau này, chẳng hạn như trong câu lệnh

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

Trong một giải pháp hơi thay thế, thay vì thay thế toàn bộ hàm

>>> import os
>>> os.linesep
'\r\n'
94 bằng một trình bao bọc tùy chỉnh, bạn có thể chuyển hướng đầu ra tiêu chuẩn sang luồng ký tự giống như tệp trong bộ nhớ

>>>

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

Lần này, hàm gọi rõ ràng là

>>> import os
>>> os.linesep
'\r\n'
94, nhưng nó để lộ tham số
>>> import os
>>> os.linesep
'\r'
43 của nó ra thế giới bên ngoài

Tuy nhiên, một cách chế nhạo các đối tượng Pythonic hơn tận dụng mô-đun

'\n'  # Blank line
''    # Empty line
31 tích hợp, sử dụng một kỹ thuật gọi là vá khỉ. Cái tên xúc phạm này bắt nguồn từ việc nó là một "mánh khóe bẩn thỉu" mà bạn có thể dễ dàng tự bắn vào chân mình. Nó kém thanh lịch hơn so với tiêm phụ thuộc nhưng chắc chắn nhanh chóng và tiện lợi

Ghi chú. Mô-đun

'\n'  # Blank line
''    # Empty line
31 đã được thư viện tiêu chuẩn trong Python 3 hấp thụ, nhưng trước đó, nó là gói của bên thứ ba. Bạn đã phải cài đặt nó một cách riêng biệt

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

Ngoài ra, bạn gọi nó là

'\n'  # Blank line
''    # Empty line
31, trong khi trong Python 3, nó là một phần của mô-đun thử nghiệm đơn vị, vì vậy bạn phải nhập từ
'\n'  # Blank line
''    # Empty line
34

Bản vá khỉ làm gì là thay đổi triển khai một cách linh hoạt trong thời gian chạy. 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. Tuy nhiên, trên thực tế, việc vá lỗi chỉ ảnh hưởng đến mã trong thời gian thực hiện kiểm tra

Để giả định

>>> import os
>>> os.linesep
'\r\n'
94 trong một trường hợp thử nghiệm, thông thường bạn sẽ sử dụng trình trang trí
'\n'  # Blank line
''    # Empty line
36 và chỉ định mục tiêu để vá bằng cách tham chiếu đến mục tiêu đó bằng một tên đủ điều kiện, bao gồm tên mô-đun

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

Điều này sẽ tự động tạo mô hình cho bạn và đưa nó vào chức năng kiểm tra. Tuy nhiên, bạn cần khai báo rằng chức năng kiểm tra của bạn chấp nhận mô hình ngay bây giờ. Đối tượng mô phỏng bên dưới có rất nhiều phương thức và thuộc tính hữu ích để xác minh hành vi

Bạn có nhận thấy điều gì đặc biệt về đoạn mã đó không?

Mặc dù đã thêm một hàm giả vào hàm, nhưng bạn không gọi nó trực tiếp, mặc dù bạn có thể. Mô hình được đưa vào đó chỉ được sử dụng để đưa ra các xác nhận sau đó và có thể để chuẩn bị bối cảnh trước khi chạy thử nghiệm

Trong cuộc sống thực, chế nhạo giúp cô lập mã đang kiểm tra bằng cách loại bỏ các phụ thuộc như kết nối cơ sở dữ liệu. Bạn hiếm khi gọi các bản giả trong một bài kiểm tra, vì điều đó không có nhiều ý nghĩa. Thay vào đó, đó là những đoạn mã khác gián tiếp gọi mô hình của bạn mà bạn không biết

Đây là ý nghĩa của nó

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

Mã đang được 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. Việc vá lỗi 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át

Có 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 theo

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

Bạn không thể vá lỗi 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
    >>> import os
    >>> os.linesep
    '\r'
    
    04
  • Nhập
    >>> import os
    >>> os.linesep
    '\r\n'
    
    94 từ mô-đun
    >>> import os
    >>> os.linesep
    '\n'
    
    41

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

Chỉ có hai sự khác biệt. Đầu tiên, cú pháp chuyển hướng luồng sử dụng chữ cái (

'\n'  # Blank line
''    # Empty line
44) thay vì đối số
>>> import os
>>> os.linesep
'\r'
43. Sự khác biệt khác là nơi
'\n'  # Blank line
''    # Empty line
46 được xác định. Bạn có thể nhập nó từ mô-đun
'\n'  # Blank line
''    # Empty line
46 có tên tương tự hoặc
'\n'  # Blank line
''    # Empty line
48 để triển khai nhanh hơn

Vá đầu ra tiêu chuẩn từ mô-đun

>>> import os
>>> os.linesep
'\r'
04 đúng như tên gọi của nó, nhưng bạn cần lưu ý một số vấn đề

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

Trước hết, hãy nhớ cài đặt mô-đun

'\n'  # Blank line
''    # Empty line
31 vì nó không có sẵn trong thư viện chuẩn của Python 2

Thứ hai, câu lệnh

>>> import os
>>> os.linesep
'\n'
02 gọi phương thức
>>> import os
>>> os.linesep
'\r'
40 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
'\n'  # Blank line
''    # Empty line
53

Cuố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
'\n'  # Blank line
''    # Empty line
55. Trên thực tế, bạn sẽ thấy ký tự xuống dòng được viết riêng

Tùy chọn cuối cùng bạn có là nhập

>>> import os
>>> os.linesep
'\r\n'
94 từ
'\n'  # Blank line
''    # Empty line
57 và vá nó

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

Mộ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
'\n'  # Blank line
''    # Empty line
59 thay vì
'\n'  # Blank line
''    # Empty line
60

>>> import os >>> os.linesep '\r\n' 94 Gỡ lỗi

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
'\n'  # Blank line
''    # Empty line
63, 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 định

Ghi 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

Thuật ngữ lỗi có nguồn gốc tên 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'
67

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

'\n'  # Blank line
''    # Empty line
64, nhưng bây giờ bạn biết đó 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

'\n'  # Blank line
''    # Empty line
64 hóa ra có một 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ãng

Bên cạnh đó, nó yêu cầu bạn thực hiện các thay đổi trong mã, điều này không phải lúc nào cũng có thể thực hiện được. Có thể bạn đang gỡ lỗi một ứng dụng đang chạy trong máy chủ web từ xa hoặc muốn chẩn đoán sự cố theo kiểu khám nghiệm tử thi. Đôi khi bạn chỉ đơn giản là không có quyền truy cập vào đầu ra tiêu chuẩn

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

ghi nhật ký

Giả sử bạn đang điều hành một trang web thương mại điện tử trong một phút. Một ngày nọ, một khách hàng tức giận gọi điện thoại phàn nàn về một giao dịch không thành công và nói rằng anh ta đã mất tiền. Anh ấy tuyên bố đã thử mua một số mặt hàng, nhưng cuối cùng, có một số lỗi khó hiểu khiến anh ấy không thể hoàn thành đơn hàng đó. Tuy nhiên, khi anh ta kiểm tra tài khoản ngân hàng của mình, tiền đã biến mất

Bạn chân thành xin lỗi và hoàn tiền, nhưng cũng không muốn điều này lặp lại trong tương lai. Làm thế nào để bạn gỡ lỗi đó?

Bất cứ khi nào bạn thấy mình đang gỡ lỗi bản in, hãy cân nhắc biến nó thành thông báo tường trình vĩnh viễn. Điều này có thể hữu ích trong những tình huống như thế này, khi bạn cần phân tích một vấn đề sau khi nó xảy ra, trong một môi trường mà bạn không có quyền truy cập

Có những công cụ tinh vi để tổng hợp và tìm kiếm nhật ký, nhưng ở cấp độ cơ bản nhất, bạn có thể coi nhật ký là tệp văn bản. Mỗi dòng truyền tải thông tin chi tiết về một sự kiện trong hệ thống của bạn. Thông thường, nó sẽ không chứa thông tin nhận dạng cá nhân, tuy nhiên, trong một số trường hợp, nó có thể được pháp luật quy định

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

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

Như bạn có thể thấy, nó có dạng cấu trúc. Ngoài một thông báo mô tả, có một số trường có thể tùy chỉnh, cung cấp ngữ cảnh của một sự kiện. Tại đây, bạn có ngày giờ chính xác, cấp nhật ký, tên nhật ký và tên luồng

Các cấp nhật ký cho phép bạn lọc tin nhắn nhanh chóng để giảm tiếng ồn. Ví dụ: nếu bạn đang tìm lỗi, bạn không muốn xem tất cả các cảnh báo hoặc thông báo gỡ lỗi. Việc tắt hoặc bật thông báo ở các cấp nhật ký nhất định thông qua cấu hình là chuyện nhỏ mà không cần chạm vào mã

Với tính năng ghi nhật ký, bạn có thể giữ các thông báo gỡ lỗi của mình tách biệt với đầu ra tiêu chuẩn. Theo mặc định, tất cả các thông báo nhật ký đều chuyển đến luồng lỗi tiêu chuẩn, có thể hiển thị thuận tiện bằng các màu khác nhau. Tuy nhiên, bạn có thể chuyển hướng thông điệp tường trình sang các tệp riêng biệt, ngay cả đối với các mô-đun riêng lẻ

Khá phổ biến, ghi nhật ký bị định cấu hình sai có thể dẫn đến hết dung lượng trên đĩa của máy chủ. Để ngăn chặn điều đó, bạn có thể thiết lập xoay vòng nhật ký, thao tác này sẽ giữ các tệp nhật ký trong một khoảng thời gian nhất định, chẳng hạn như một tuần hoặc khi chúng đạt đến một kích thước nhất định. Tuy nhiên, lưu trữ các nhật ký cũ hơn luôn là một cách thực hành tốt. Một số quy định buộc dữ liệu khách hàng phải được lưu giữ trong vòng 5 năm

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

'\n'  # Blank line
''    # Empty line
63 đượ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'
69

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

>>> import os
>>> os.linesep
'\r\n'
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

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

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

'\n'  # Blank line
''    # Empty line
69 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
'\n'  # Blank line
''    # Empty line
63

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

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

Mộ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 thi

gỡ lỗi

Sự thật là cả truy tìm và ghi nhật ký đều không thể được coi là gỡ lỗi thực sự. Để thực hiện gỡ lỗi thực tế, bạn cần một công cụ gỡ lỗi, cho phép bạn thực hiện các thao tác sau

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

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

'\n'  # Blank line
''    # Empty line
73 cho “Trình gỡ lỗi Python,” được phân phối như một phần của thư viện chuẩn. Đ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

'\n'  # Blank line
''    # Empty line
73 có thể hơi phức tạp. 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'
71

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

>>>

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

Thao tác này sẽ hiển thị lời nhắc tương tác, thoạt nhìn có vẻ đáng sợ. Tuy nhiên, bạn vẫn có thể nhập Python nguyên gốc vào thời điểm này để kiểm tra hoặc sửa đổi trạng thái của các biến cục bộ. Ngoài ra, thực sự chỉ có một số lệnh dành riêng cho trình gỡ lỗi mà bạn muốn sử dụng để xem qua mã

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

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

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

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

'\n'  # Blank line
''    # Empty line
75 tích hợp, thực hiện điều tương tự, nhưng theo cách nhỏ gọn hơn và có thêm một số

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

Hầu hết các phần có thể bạn sẽ sử dụng trình gỡ lỗi trực quan được tích hợp với trình chỉnh sửa mã. PyCharm có một trình gỡ lỗi tuyệt vời, tự hào có hiệu suất cao, nhưng bạn sẽ tìm thấy nhiều IDE thay thế có trình gỡ lỗi, cả trả phí và miễn phí

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

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

In chỉ an toàn

Trước đây, tôi đã đề cập sơ qua về vấn đề an toàn của luồng, khuyến nghị sử dụng

'\n'  # Blank line
''    # Empty line
63 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? . Cách phổ biến nhất để đồng bộ hóa quyền truy cập đồng thời vào một tài nguyên như vậy là khóa nó. Đ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
'\n'  # Blank line
''    # Empty line
55, đan xen các đoạn văn bản từ nhiều lệnh gọi
>>> import os
>>> os.linesep
'\r\n'
94

Ghi 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 ngữ cảnh bằng cách đặt phương thức

>>> import os
>>> os.linesep
'\r'
40 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'
76

Trước tiên, bạn cần lưu trữ phương thức gốc

>>> import os
>>> os.linesep
'\r'
40 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 chủ đề sẽ thực hiện một vài cuộc gọi
>>> import os
>>> os.linesep
'\r\n'
94 với tên của nó và một chữ cái. A, B và C

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

'\n'  # Blank line
''    # Empty line
84 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'
77

Mặc dù bản thân

'\n'  # Blank line
''    # Empty line
55 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'
79

Tuy 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
'\n'  # Blank line
''    # Empty line
88 vô dụng

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

Phiê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'
81

Bạ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'
82

Bâ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'
83

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

'\n'  # Blank line
''    # Empty line
63 được thiết kế an toàn cho luồng, được phản ánh bởi 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 hàm 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 sẵn để chấp nhận đầu vào từ người dùng, có thể đoán trước được gọi là

'\n'  # Blank line
''    # Empty line
95. 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'
85

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

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

Tham số dấu nhắc là hoàn toàn tùy chọn, vì vậy sẽ không có gì hiển thị nếu bạn bỏ qua nó, nhưng chức năng vẫn hoạt động

>>>

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

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

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

'\n'  # Blank line
''    # Empty line
96, đây là một tích hợp khác. Thật không may, cũng có một hàm
'\n'  # Blank line
''    # Empty line
95 được đặt tên gây hiểu nhầm, thực hiện một việc hơi khác

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

'\n'  # Blank line
''    # Empty line
96 được đổi tên thành
'\n'  # Blank line
''    # Empty line
95

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

Python 2Python 3

'\n'  # Blank line
''    # Empty line
96
'\n'  # Blank line
''    # Empty line
95
'\n'  # Blank line
''    # Empty line
95
>>> 'A line of text.\n'.rstrip()
'A line of text.'
03

Như bạn có thể thấy, vẫn có thể mô phỏng hành vi cũ trong Python 3

Yêu cầu người dùng nhập mật khẩu bằng

'\n'  # Blank line
''    # Empty line
95 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
>>> 'A line of text.\n'.rstrip()
'A line of text.'
05 để 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'
88

Mô-đun

>>> 'A line of text.\n'.rstrip()
'A line of text.'
06 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'
89

Các hàm tích hợp của Python để xử lý đầu vào tiêu chuẩn khá hạn chế. Đồng thời, có rất nhiều gói của bên thứ ba cung cấp các công cụ tinh vi hơn nhiều

bên thứ ba

Có các gói Python bên ngoài cho phép xây dựng các giao diện đồ họa phức tạp đặc biệt để thu thập dữ liệu từ người dùng. Một số tính năng của họ bao gồm

  • Định dạng và kiểu dáng nâng cao
  • Tự động phân tích cú pháp, xác thực và vệ sinh dữ liệu người dùng
  • Một phong cách khai báo xác định bố cục
  • Tự động hoàn thành tương tác
  • hỗ trợ chuột
  • Các vật dụng được xác định trước như danh sách kiểm tra hoặc menu
  • Lịch sử có thể tìm kiếm của các lệnh đã gõ
  • Đánh dấu cú pháp

Trình diễn các công cụ như vậy nằm ngoài phạm vi của bài viết này, nhưng bạn có thể muốn dùng thử chúng. Cá nhân tôi đã biết về một số trong số đó thông qua Python Bytes Podcast. Họ đây rồi

  • >>> 'A line of text.\n'.rstrip()
    'A line of text.'
    
    07
  • >>> 'A line of text.\n'.rstrip()
    'A line of text.'
    
    08
  • >>> 'A line of text.\n'.rstrip()
    'A line of text.'
    
    09
  • >>> 'A line of text.\n'.rstrip()
    'A line of text.'
    
    10

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

>>> 'A line of text.\n'.rstrip()
'A line of text.'
11 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 động

Giả sử bạn đã viết một giao diện dòng lệnh hiểu ba hướng dẫn, bao gồm một hướng dẫn để thêm số

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

Thoạt nhìn, nó giống như một lời nhắc điển hình khi bạn chạy nó

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

Nhưng ngay khi bạn mắc lỗi và muốn sửa nó, bạn sẽ thấy không có phím chức năng nào hoạt động như mong muốn. Ví dụ: nhấn vào mũi tên Trái sẽ dẫn đến điều này thay vì di chuyển con trỏ trở lại.

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

Bây giờ, bạn có thể bọc cùng một tập lệnh bằng lệnh

>>> 'A line of text.\n'.rstrip()
'A line of text.'
11. 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'
93

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

Phần 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 2

Ngoài ra, bạn đã học cách

  • Tránh những lỗi phổ biến với
    >>> import os
    >>> os.linesep
    '\r\n'
    
    94 trong Python
  • Xử lý các dòng mới, mã hóa ký tự và bộ đệm
  • Write text to files
  • Giả lập hàm
    >>> import os
    >>> os.linesep
    '\r\n'
    
    94 trong các bài kiểm tra đơn vị
  • 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

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

Gửi cho tôi thủ thuật Python »

Giới thiệu về Bartosz Zaczyński

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

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


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

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

Aldren

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

Joanna

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

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 »

Chuyên gia 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ẻ Email

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

Làm cách nào để in văn bản Python?

Hàm print() của Python nhận bất kỳ số lượng tham số nào và in chúng ra trên một dòng văn bản . Mỗi mục được chuyển đổi thành dạng văn bản, được phân tách bằng dấu cách và có một ký tự '\n' duy nhất ở cuối (ký tự "dòng mới"). Khi được gọi với tham số bằng 0, print() chỉ in '\n' và không có gì khác.