Cara menggunakan python print multiple characters

Calling

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

94

The simplest example of using Python

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

>>>

>>> print[]

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

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

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

Newline CharacterShow/Hide

A newline character is a special control character used to indicate the end of a line [EOL]. It usually doesn’t have a visible representation on the screen, but some text editors can display such non-printable characters with little graphics.

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

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

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

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

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

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

>>>

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

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

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

>>>

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

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

>>>

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

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

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

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

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

  12: backslash

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

  13: backspace

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

  14: tab

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

  08: carriage return [CR]

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

  09: newline, also known as line feed [LF]

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

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

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

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

>>>

>>> ord['r']
114
>>> ord['\r']
13

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

As you just saw, calling

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

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

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

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

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

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

>>>

>>> 'A line of text.\n'.rstrip[]
'A line of text.'

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

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

First, you may pass a string literal directly to

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

>>>

>>> print['Please wait while the program is loading...']

This will print the message verbatim onto the screen.

String LiteralsShow/Hide

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

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

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

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

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

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

'My favorite book is "Python Tricks"'

The same trick would work the other way around:

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

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

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

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

One classic example is a file path on Windows:

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

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

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

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

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

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

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

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

That’s much better, isn’t it?

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

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

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

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

Here’s an example:

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

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

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

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

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

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

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

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

>>>

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

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

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

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

>>>

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

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

>>>

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

In fact, there are a dozen ways to format messages in Python. I highly encourage you to take a look at f-strings, introduced in Python 3.6, because they offer the most concise syntax of them all:

>>>

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

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

>>>

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

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

>>>

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

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

Note:

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

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

>>>

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

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

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

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

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

>>>

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

Watch out for the

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

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

>>>

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

How does

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

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

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

Okay, you’re now able to call

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

Syntax in Python 2Show/Hide

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

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

That’s because

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

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

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

>>>

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

Round brackets are actually part of the expression rather than the

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

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

>>>

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

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

>>>

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

The bottom line is that you shouldn’t call

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

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

Separating Multiple Arguments

You saw

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

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

Positional ArgumentsShow/Hide

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

>>>

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

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

>>>

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

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

>>>

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

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

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

Let’s have a look at this example:

>>>

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

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

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

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

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

>>>

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

Apart from accepting a variable number of positional arguments,

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

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

Let’s focus on

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

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

It has to be either a string or

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

>>>

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

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

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

>>>

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

You may want

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

>>>

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

A more useful example of the

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

>>>

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

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

>>>

>>> ord['r']
114
>>> ord['\r']
13

Specifically, you can insert a slash character [

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

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

Doing it manually will result in a well-known

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

>>>

>>> ord['r']
114
>>> ord['\r']
13

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

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

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

>>>

>>> ord['r']
114
>>> ord['\r']
13

Unpacking is effectively the same as calling

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

One more interesting example could be exporting data to a comma-separated values [CSV] format:

>>>

>>> ord['r']
114
>>> ord['\r']
13

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

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

Finally, the

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

>>>

>>> ord['r']
114
>>> ord['\r']
13

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

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

Syntax in Python 2Show/Hide

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

>>>

>>> ord['r']
114
>>> ord['\r']
13

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

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

>>>

>>> ord['r']
114
>>> ord['\r']
13

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

>>>

>>> ord['r']
114
>>> ord['\r']
13

That was the default way of formatting strings until the

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

Preventing Line Breaks

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

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

>>> ord['r']
114
>>> ord['\r']
13

Many programming languages expose functions similar to

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

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

Here are a few examples of syntax in such languages:

LanguageExamplePerl

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

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

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

In contrast, Python’s

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

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

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

In terms of semantics, the

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

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

• It must be a string or

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

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

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

  78.
• If equal to

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

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

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

  53], it’ll suppress the newline.

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

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

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

Note: You may be wondering why the

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

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

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

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

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

>>>

>>> ord['r']
114
>>> ord['\r']
13

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

>>>

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

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

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

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

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

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

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

Even though these are two separate

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

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

However, after the second call to

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

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

As with

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

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

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

These three instructions will output a single line of text:

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

You can mix the two keyword arguments:

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

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

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

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

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

It would print out the following piece of text:

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

As you can see, the

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

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

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

>>>

>>> 'A line of text.\n'.rstrip[]
'A line of text.'

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

>>> 'A line of text.\n'.rstrip[]
'A line of text.'

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

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

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

>>>

>>> 'A line of text.\n'.rstrip[]
'A line of text.'

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

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

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

Syntax in Python 2Show/Hide

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

>>> 'A line of text.\n'.rstrip[]
'A line of text.'

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

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

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

>>> 'A line of text.\n'.rstrip[]
'A line of text.'

Notice there’s a space between the words

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

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

>>> 'A line of text.\n'.rstrip[]
'A line of text.'

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

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

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

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

>>> 'A line of text.\n'.rstrip[]
'A line of text.'

This will print the correct output without extra space:

>>> 'A line of text.\n'.rstrip[]
'A line of text.'

While using the

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

Printing to a File

Believe it or not,

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

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

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

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

   08: standard input

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

   09: standard output

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

   10: standard error

Standard StreamsShow/Hide

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

>>> 'A line of text.\n'.rstrip[]
'A line of text.'

Unless otherwise instructed,

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

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

>>> 'A line of text.\n'.rstrip[]
'A line of text.'

That’s called stream redirection.

The standard error is similar to

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

Note: To redirect

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

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

StreamFile Descriptor

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

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

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

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

CommandDescription

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

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

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

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

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

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

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

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

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

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

Note that

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

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

Some programs use different coloring to distinguish between messages printed to

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

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

While both

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

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

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

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

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

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

>>>

>>> print['Please wait while the program is loading...']

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

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

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

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

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

By default,

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

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

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

>>> print['Please wait while the program is loading...']

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

For more information on working with files in Python, you can check out Reading and Writing Files in Python [Guide].

Note: Don’t try using

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

Just call the binary file’s

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

>>> print['Please wait while the program is loading...']

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

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

>>>

>>> print['Please wait while the program is loading...']

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

>>>

>>> print['Please wait while the program is loading...']

This prints an uppercase letter

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

Note that

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

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

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

>>> print['Please wait while the program is loading...']

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

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

>>>

>>> print['Please wait while the program is loading...']

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

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

Syntax in Python 2Show/Hide

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

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

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

>>> print['Please wait while the program is loading...']

Because strings and bytes are represented with the same

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

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

>>> print['Please wait while the program is loading...']

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

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

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

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

>>>

>>> print['Please wait while the program is loading...']

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

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

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

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

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

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

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

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

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

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

Buffering

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

94 Calls

In the previous subsection, you learned that

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

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

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

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

Your first attempt may look something like this:

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

As long as the

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Syntax in Python 2Show/Hide

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

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

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

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

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

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

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

Note that

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

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

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

>>>

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

What you’re seeing here is a docstring of the

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

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

Printing Custom Data Types

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

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

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

>>>

'My favorite book is "Python Tricks"'

That’s great as long as holding data is enough, but in order to add behaviors to the

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

'My favorite book is "Python Tricks"'

If you now create an instance of the

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

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

>>>

'My favorite book is "Python Tricks"'

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

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

'My favorite book is "Python Tricks"'

Your

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

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

Note: In Python 3, the

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

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

'My favorite book is "Python Tricks"'

This prevents the interpreter from raising

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

That’s better than a plain

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

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

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

>>>

'My favorite book is "Python Tricks"'

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

From earlier subsections, you already know that

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

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

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

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

>>>

'My favorite book is "Python Tricks"'

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

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

   93

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

   94

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

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

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

>>>

'My favorite book is "Python Tricks"'

Notice the use of another built-in function,

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

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

Note: Even though

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

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

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

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

'My favorite book is "Python Tricks"'

If you print a single object of the

>>> ord['r']
114
>>> ord['\r']
13

>>> ord['r']
114
>>> ord['\r']
13

>>> ord['r']
114
>>> ord['\r']
13

>>> ord['r']
114
>>> ord['\r']
13

>>>

'My favorite book is "Python Tricks"'

However, if you put the same

>>> ord['r']
114
>>> ord['\r']
13

>>>

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

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

>>> ord['r']
114
>>> ord['\r']
13

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

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

Syntax in Python 2Show/Hide

The semantics of

>>> ord['r']
114
>>> ord['\r']
13

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

>>> ord['r']
114
>>> ord['\r']
13

Here’s an example of the same

>>> ord['r']
114
>>> ord['\r']
13

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

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

>>> ord['r']
114
>>> ord['\r']
13

Both

>>> ord['r']
114
>>> ord['\r']
13

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

>>> ord['r']
114
>>> ord['\r']
13

>>> ord['r']
114
>>> ord['\r']
13

>>> ord['r']
114
>>> ord['\r']
13

The

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

>>> ord['r']
114
>>> ord['\r']
13

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

>>>

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

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

>>>

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

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

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

>>> ord['r']
114
>>> ord['\r']
13

>>> ord['r']
114
>>> ord['\r']
13

>>>

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

Using the built-in

>>> ord['r']
114
>>> ord['\r']
13

>>> ord['r']
114
>>> ord['\r']
13

Print Is a Function in Python 3

You’ve seen that

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

>>>

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

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

>>>

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

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

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

>>> ord['r']
114
>>> ord['\r']
13

>>>

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

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

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

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

On the other hand,

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

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

>>>

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

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

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

Because

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

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

Another benefit of

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

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

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

Here, the

>>> ord['r']
114
>>> ord['\r']
13

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

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

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

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

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

Dependency injection for five-year-olds

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

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

— John Munsch, 28 October 2009. [Source]

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

>>> ord['r']
114
>>> ord['\r']
13

>>>

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

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

>>> ord['r']
114
>>> ord['\r']
13

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

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

>>>

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

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

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

Another kind of expression is a ternary conditional expression:

>>>

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

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

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

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

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

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

02 Was a Statement in Python 2

A statement is an instruction that may evoke a side-effect when executed but never evaluates to a value. In other words, you wouldn’t be able to print a statement or assign it to a variable like this:

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

That’s a syntax error in Python 2.

Here are a few more examples of statements in Python:

• assignment:

  >>> ord['r']
  114
  >>> ord['\r']
  13
  

  47
• conditional:

  >>> ord['r']
  114
  >>> ord['\r']
  13
  

  48
• loop:

  >>> ord['r']
  114
  >>> ord['\r']
  13
  

  49
• assertion:

  >>> ord['r']
  114
  >>> ord['\r']
  13
  

  50

Note: Python 3.8 brings a controversial walrus operator [

>>> ord['r']
114
>>> ord['\r']
13

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

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

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

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

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

Statements are usually comprised of reserved keywords such as

>>> ord['r']
114
>>> ord['\r']
13

>>> ord['r']
114
>>> ord['\r']
13

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

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

Furthermore, you can’t print from anonymous functions, because statements aren’t accepted in lambda expressions:

>>>

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

The syntax of the

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

>>>

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

At other times they change how the message is printed:

>>>

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

String concatenation can raise a

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

>>>

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

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

>>>

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

There aren’t any keyword arguments for common tasks such as flushing the buffer or stream redirection. You need to remember the quirky syntax instead. Even the built-in

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

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

>>>

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

Trailing newline removal doesn’t work quite right, because it adds an unwanted space. You can’t compose multiple

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

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

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

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

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

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

>>> ord['r']
114
>>> ord['\r']
13

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

>>>

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

You could also call

>>> ord['r']
114
>>> ord['\r']
13

To enable the

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

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

From now on the

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

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

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

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

Here’s an example of calling the

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

>>>

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

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

Pretty-Printing Nested Data Structures

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

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

Python comes with the

>>> ord['r']
114
>>> ord['\r']
13

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

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

>>>

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

This is an example of Magic in IPython. There are a lot of built-in commands that start with a percent sign [

>>> ord['r']
114
>>> ord['\r']
13

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

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

>>> ord['r']
114
>>> ord['\r']
13

>>>

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

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

>>> ord['r']
114
>>> ord['\r']
13

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

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

>>>

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

That’s because

>>> ord['r']
114
>>> ord['\r']
13

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

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

>>>

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

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

>>>

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

The ordinary

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

>>>

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

However,

>>> ord['r']
114
>>> ord['\r']
13

>>>

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

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

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

>>> ord['r']
114
>>> ord['\r']
13

>>>

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

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

>>> ord['r']
114
>>> ord['\r']
13

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

>>> ord['r']
114
>>> ord['\r']
13

>>>

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

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

>>> ord['r']
114
>>> ord['\r']
13

>>> ord['r']
114
>>> ord['\r']
13

Surprisingly, the signature of

>>> ord['r']
114
>>> ord['\r']
13

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

Adding Colors With ANSI Escape Sequences

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

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

>>> ord['r']
114
>>> ord['\r']
13

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

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

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

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

>>> ord['r']
114
>>> ord['\r']
13

>>> ord['r']
114
>>> ord['\r']
13

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

>>> ord['r']
114
>>> ord['\r']
13

>>> ord['r']
114
>>> ord['\r']
13

>>>

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

Additionally, you can obtain it with the

>>> ord['r']
114
>>> ord['\r']
13

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

The most common ANSI escape sequences take the following form:

ElementDescriptionExampleEscnon-printable escape character

>>> ord['r']
114
>>> ord['\r']
13

>>> ord['r']
114
>>> ord['\r']
13

>>> ord['r']
114
>>> ord['\r']
13

>>> ord['r']
114
>>> ord['\r']
13

>>> ord['r']
114
>>> ord['\r']
13

>>> ord['r']
114
>>> ord['\r']
13

The numeric code can be one or more numbers separated with a semicolon, while the character code is just one letter. Their specific meaning is defined by the ANSI standard. For example, to reset all formatting, you would type one of the following commands, which use the code zero and the letter

>>> ord['r']
114
>>> ord['\r']
13

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

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

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

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

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

>>>

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

This would make the word

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

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

>>> ord['r']
114
>>> ord['\r']
13

Building Console User Interfaces

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

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

Note: To use the

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

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

That’s because

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

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

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

First, you need to import the

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

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

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

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

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

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

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

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

Let’s define the snake as a list of points in screen coordinates:

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

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

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

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

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

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

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

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

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

How does a snake move? It turns out that only its head really moves to a new location, while all other segments shift towards it. In each step, almost all segments remain the same, except for the head and the tail. Assuming the snake isn’t growing, you can remove the tail and insert a new head at the beginning of the list:

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

To get the new coordinates of the head, you need to add the direction vector to it. However, adding tuples in Python results in a bigger tuple instead of the algebraic sum of the corresponding vector components. One way to fix this is by using the built-in

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

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

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

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

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

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

By default, however,

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

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

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

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

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

This is merely scratching the surface of the possibilities that the

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

Living It Up With Cool Animations

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

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

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

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

• Carriage return:

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

  08
• Backspace:

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

  13

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

Let’s take a look at a few examples.

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

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

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

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

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

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

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

As before, each request for update repaints the entire line.

Note: There’s a feature-rich

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

Making Sounds With

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

94

If you’re old enough to remember computers with a PC speaker, then you must also remember their distinctive beep sound, often used to indicate hardware problems. They could barely make any more noises than that, yet video games seemed so much better with it.

Today you can still take advantage of this small loudspeaker, but chances are your laptop didn’t come with one. In such a case, you can enable terminal bell emulation in your shell, so that a system warning sound is played instead.

Go ahead and type this command to see if your terminal can play a sound:

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

This would normally print text, but the

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

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

Similarly, you can print this character in Python. Perhaps in a loop to form some kind of melody. While it’s only a single note, you can still vary the length of pauses between consecutive instances. That seems like a perfect toy for Morse code playback!

The rules are the following:

• Letters are encoded with a sequence of dot [·] and dash [–] symbols.
• A dot is one unit of time.
• A dash is three units of time.
• Individual symbols in a letter are spaced one unit of time apart.
• Symbols of two adjacent letters are spaced three units of time apart.
• Symbols of two adjacent words are spaced seven units of time apart.

According to those rules, you could be “printing” an SOS signal indefinitely in the following way:

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

In Python, you can implement it in merely ten lines of code:

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

Maybe you could even take it one step further and make a command line tool for translating text into Morse code? Either way, I hope you’re having fun with this!

Tracing

Also known as print debugging or caveman debugging, it’s the most basic form of debugging. While a little bit old-fashioned, it’s still powerful and has its uses.

The idea is to follow the path of program execution until it stops abruptly, or gives incorrect results, to identify the exact instruction with a problem. You do that by inserting print statements with words that stand out in carefully chosen places.

Take a look at this example, which manifests a rounding error:

>>>

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

As you can see, the function doesn’t return the expected value of

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

Rounding ErrorShow/Hide

In this case, the problem lies in how floating point numbers are represented in computer memory. Remember that numbers are stored in binary form. Decimal value of

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

For more information on rounding numbers in Python, you can check out How to Round Numbers in Python.

This method is simple and intuitive and will work in pretty much every programming language out there. Not to mention, it’s a great exercise in the learning process.

On the other hand, once you master more advanced techniques, it’s hard to go back, because they allow you to find bugs much quicker. Tracing is a laborious manual process, which can let even more errors slip through. The build and deploy cycle takes time. Afterward, you need to remember to meticulously remove all the

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

Besides, it requires you to make changes in the code, which isn’t always possible. Maybe you’re debugging an application running in a remote web server or want to diagnose a problem in a post-mortem fashion. Sometimes you simply don’t have access to the standard output.

That’s precisely where logging shines.

Logging

Let’s pretend for a minute that you’re running an e-commerce website. One day, an angry customer makes a phone call complaining about a failed transaction and saying he lost his money. He claims to have tried purchasing a few items, but in the end, there was some cryptic error that prevented him from finishing that order. Yet, when he checked his bank account, the money was gone.

You apologize sincerely and make a refund, but also don’t want this to happen again in the future. How do you debug that? If only you had some trace of what happened, ideally in the form of a chronological list of events with their context.

Whenever you find yourself doing print debugging, consider turning it into permanent log messages. This may help in situations like this, when you need to analyze a problem after it happened, in an environment that you don’t have access to.

There are sophisticated tools for log aggregation and searching, but at the most basic level, you can think of logs as text files. Each line conveys detailed information about an event in your system. Usually, it won’t contain personally identifying information, though, in some cases, it may be mandated by law.

Here’s a breakdown of a typical log record:

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

As you can see, it has a structured form. Apart from a descriptive message, there are a few customizable fields, which provide the context of an event. Here, you have the exact date and time, the log level, the logger name, and the thread name.

Log levels allow you to filter messages quickly to reduce noise. If you’re looking for an error, you don’t want to see all the warnings or debug messages, for example. It’s trivial to disable or enable messages at certain log levels through the configuration, without even touching the code.

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

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

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

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

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

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

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

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

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

Note: There’s a somewhat related

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

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

That said, you can make them work together by calling

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

One last reason to switch from the

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

Debugging

The truth is that neither tracing nor logging can be considered real debugging. To do actual debugging, you need a debugger tool, which allows you to do the following:

• Step through the code interactively.
• Set breakpoints, including conditional breakpoints.
• Introspect variables in memory.
• Evaluate custom expressions at runtime.

A crude debugger that runs in the terminal, unsurprisingly named

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

However, it doesn’t come with a graphical interface, so using

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

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

Otherwise, you can set up a breakpoint directly in the code, which will pause the execution of your script and drop you into the debugger. The old way of doing this required two steps:

>>>

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

This shows up an interactive prompt, which might look intimidating at first. However, you can still type native Python at this point to examine or modify the state of local variables. Apart from that, there’s really only a handful of debugger-specific commands that you want to use for stepping through the code.

Note: It’s customary to put the two instructions for spinning up a debugger on a single line. This requires the use of a semicolon, which is rarely found in Python programs:

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

While certainly not Pythonic, it stands out as a reminder to remove it after you’re done with debugging.

Since Python 3.7, you can also call the built-in

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

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

You’re probably going to use a visual debugger integrated with a code editor for the most part. PyCharm has an excellent debugger, which boasts high performance, but you’ll find plenty of alternative IDEs with debuggers, both paid and free of charge.

Debugging isn’t the proverbial silver bullet. Sometimes logging or tracing will be a better solution. For example, defects that are hard to reproduce, such as race conditions, often result from temporal coupling. When you stop at a breakpoint, that little pause in program execution may mask the problem. It’s kind of like the Heisenberg principle: you can’t measure and observe a bug at the same time.

These methods aren’t mutually exclusive. They complement each other.

Built-In

Python comes with a built-in function for accepting input from the user, predictably called

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

>>>

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

The function always returns a string, so you might need to parse it accordingly:

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

The prompt parameter is completely optional, so nothing will show if you skip it, but the function will still work:

>>>

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

Nevertheless, throwing in a descriptive call to action makes the user experience so much better.

Note: To read from the standard input in Python 2, you have to call

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

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

In fact, it also takes the input from the standard stream, but then it tries to evaluate it as if it was Python code. Because that’s a potential security vulnerability, this function was completely removed from Python 3, while

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

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

Here’s a quick comparison of the available functions and what they do:

Python 2Python 3

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

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

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

>>> 'A line of text.\n'.rstrip[]
'A line of text.'

As you can tell, it’s still possible to simulate the old behavior in Python 3.

Asking the user for a password with

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

>>> 'A line of text.\n'.rstrip[]
'A line of text.'

>>>

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

The

>>> 'A line of text.\n'.rstrip[]
'A line of text.'

>>>

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

Python’s built-in functions for handling the standard input are quite limited. At the same time, there are plenty of third-party packages, which offer much more sophisticated tools.

Third-Party

There are external Python packages out there that allow for building complex graphical interfaces specifically to collect data from the user. Some of their features include:

• Advanced formatting and styling
• Automated parsing, validation, and sanitization of user data
• A declarative style of defining layouts
• Interactive autocompletion
• Mouse support
• Predefined widgets such as checklists or menus
• Searchable history of typed commands
• Syntax highlighting

Demonstrating such tools is outside of the scope of this article, but you may want to try them out. I personally got to know about some of those through the Python Bytes Podcast. Here they are:

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

Nonetheless, it’s worth mentioning a command line tool called

>>> 'A line of text.\n'.rstrip[]
'A line of text.'

Let’s assume you wrote a command-line interface that understands three instructions, including one for adding numbers:

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

At first glance, it seems like a typical prompt when you run it:

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

But as soon as you make a mistake and want to fix it, you’ll see that none of the function keys work as expected. Hitting the Left arrow, for example, results in this instead of moving the cursor back:

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

Now, you can wrap the same script with the

>>> 'A line of text.\n'.rstrip[]
'A line of text.'

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

Isn’t that great?