The need to print when you program is of course one of the most important, and probably the very first things you ever did! This is your full guide on how to print for both python 2 and python 3).

The quickest and simplest scenario on how to print is to simply write the following:

print("Hello World")

However, there are many other variations of printing that comes up when you are coding in python. These could be printing json files, printing without a new line, printing to a log file, printing formatted text, and many more. Find below what you’re looking for in this one stop guide to printing!

Printing without a new line

When you normally use the print(“abc”) construct it still adds a new line character. In order to print without a new line use the end parameter.

print("Hello World", end="")

Normally when printing:

See example with the print parameter:

Printing Text together

When printing items, there are often times you need to print text write next to each other, or you need concatenate text together. Concatenating text in Python is simple and can be done in several ways.

Note that in the below approach that for the method 2, there is no space between the text which is why method 3 helps to solve this problem.

text1 = 'shoe'
text2 = 'laces'
print("Method 1:", text1,  text2)
print("Method 2:", text1 +  text2)
print("Method 3:", text1 + ' ' + text2)
print("Method 4:", "%s %s" % ( text1, text2) )

Formatting numeric output when printing

When printing, often it’s needed to format the print output. Here’s a list of formatting scenarios.

Printing a number with a string

When printing a number, it is typically simple to do with the following statement:

counter = 5
print(counter) 

The problem arises when you want to print text along the same line. You will typically get this error TypeError: unsupported operand type(s) for +: ‘int’ and ‘str’ . For example for the following:

The trick is that you can always concatenate two strings together. Hence, you simply need to convert the int (short for integer, or whole number) into a str (string).

counter = 5
print( str(counter) + ' apples'  )

Padding zeros when printing numbers

When printing numbers, often you need to pad with zeros. There are multiple ways to do this, but one of the easier ways is to first convert the number to a string, and then use the zfill function of the string where you can specify how long the number should be.

#this prints the number 10 with up to 8 padded zeros
counter = 10
str(counter).zfill(8)

A more advanced example follows where we’re printing 7 numbers. Notice that for the last number where the number is more than 8 digits, that there are no padded zeros.

counter = 2
for x in range(1, 7):
     print(  str(counter).zfill(8) )   
        counter = counter * counter

Another method to pad zeros is the following method to use the format function where a zero is placed in front of the number of digits. Here the “08” refers to padding zeros for 8 digits

counter = 2
for x in range(1, 7):
    print( format(counter, '08'))  
    counter = counter * counter

Printing with text alignment

The following can be used when you want to print a table of contents where the structure “{:>nn”.format(‘text to format’) is used. nn is the number of letters to pad.

'{:>15}'.format('text')

Without any alignment:

With alignment:

Printing complex data structures in readable format

One of the great things about python is that you can put together complex data structures fairly easily. This could be a dictionary where each dictionary item is a list. However, to print this out normally is quite difficult to read. This is where pretty print comes in. Suppose you have the following structure:

Within python, this is represented as a dictionary where the main items “furniture” and “appliances” have the sub-items. So if the data structure is “listitems”, then the data coudl be represented as follows:

listitems ={ 'furniture':[ 'desk', 'chair', 'sofa'], 'appliances':['tv', 'lamp', 'hifi']}

With this in mind, then printing of this data would be as follows:

listitems ={ 'furniture':[ 'desk', 'chair', 'sofa'], 'appliances':['tv', 'lamp', 'hifi']}
print(listitems)

This is where the import library pprint comes in. You can simply use this to print out the output in a more readable fashion. There are two important parameters though. You should use the indent parameter to specify how much space there is per element, and then width to ensure that limited items are put on a single two. If you put a width of 1 character, then that’ll ensure only show one element at most (so if a element has more than 1 character it’s ok, but you cannot include a second element in there as you’re already the 1 width limit).

import pprint; 
listitems ={ 'furniture':[ 'desk', 'chair', 'sofa'], 'appliances':['tv', 'lamp', 'hifi']}
pprint.pprint(listitems,  indent=1, width=1)

Printing time

Printing time is another important item that you tend to do often in case you want to monitor performance or perhaps to give an update that your long operation is still running.

Print the time

First lets simply print the current date and time

import datetime
print(datetime.datetime.now())

This date time can be easily formatted using the special function from the date object “strftime”. With strftime you can convert the format of the time quite easily to a specified format of hours, mins, seconds and date, with or without the timezone information

import datetime

currentTime = datetime.datetime.now()

print(currentTime.strftime("%Y-%m-%d"))
print(currentTime.strftime("%Y-%m-%d %H:%M:%S"))
print(currentTime.strftime("%Y-%m-%d %H:%M:%S %Z%z"))

As you can guess the Y=year, m = month, d = year, H = hour, M=minutes, S = seconds. Z = timezone. You’ll notice that for the 3rd print item the timezone is blank. We’ll address that in the next section.

Print the time in the correct timezone

However, if you are using a remote machine, or a virtual machine where your local timezone is not set, you may want to chose your own timezone. Also, if you are running services which are across different machines, it is important to make sure you use the right timezone. One simple way is to use universal time (UTC), or to simply to set a single timezone. You can then convert as required.

import datetime
import pytz   #include the timezone module

currentTime = datetime.datetime.now( pytz.timezone('UTC') ) 

print(currentTime.strftime("%Y-%m-%d"))
print(currentTime.strftime("%Y-%m-%d %H:%M:%S"))
print(currentTime.strftime("%Y-%m-%d %H:%M:%S %Z%z"))

Please note in the above example that when the timezone format was shown it showed that the timezone was set to UTC+0000 unlike the previous example. This means that the timezone information was present there.

In the following code, we will first get the time in the UTC timezone, and then convert the time to Hong Kong timezone.

import datetime
import pytz

currentTime = datetime.datetime.now( pytz.timezone('UTC') ) 
print("Time 1 (UTC time):", currentTime.strftime("%Y-%m-%d %H:%M:%S %Z%z"))

now_local = currentTime.astimezone(pytz.timezone('Asia/Hong_Kong'))
print("Time 2a(HK time) :", now_local.strftime("%Y-%m-%d %H:%M:%S %Z%z"))
print("Time 2b(HK time) :", now_local.strftime("%Y-%m-%d %H:%M:%S  "))

Please note that in the “Time 2a” output, you can see the Hong Kong time as 2am with the timezone indicator at the end of +8 hours. The final “Time 2b” is the same time without the timezone included.

Finally, you can get a list of all the timezones available with a quick check on the pytz module and checking “all_timezones”.

import pytz

 for tz in pytz.all_timezones:
     print(tz)

How to print an exception

Things will go wrong in your code all the time – especially things that you don’t expect. This is where exceptions come in where the try exception blocks fit in quite nicely. The tricky part is that you need to make sure you output what the exception is in order for you to understand what’s going on.

Firstly a quick example of where a try /except can be helpful. Suppose you had the following code where after the definition of the function, the function was called.

def badFunction():
     print(a)     #print an undefined function

badFunction()     #call the function
print("have a nice day")

In here, as the variable “a” was not defined, then the program terminated and the final line “have a nice day” was never printed.

This is where try/except blocks can come in where you can catch errors from uncertain actions. So you can wrap the “badfunction” in a try block. See following example:

def badFunction():
     print(a)

#Try the unsafe code
 try:
     badFunction()
 except NameError:
     print("Variable x is not defined")
 except:
   print("Something else went wrong")

 print("have a nice day")

Here, the program continued to run gracefully and it caught the exception with the error “Variable x is not defined”. The reason it was caught was due to “NameError” exception object being defined.

In this next example, we have put a different error. Now the variable is defined as a number but there will be an exception as the number will be concatenated to a string.

def badFunction():
     a = 1
     print(a + ' join str')  #this will fail as joining a string with a number

#try the unsafe code
try:
     badFunction()
except NameError:
     print("Variable x is not defined")
except:
   print("Something else went wrong")

print("have a nice day")

Here another exception was caught but with the generic message of “Something else went wrong”. This is where printing the actual exception is really important. This is where you can define the exception object and print out the error.

 ef badFunction():
     a = 1
     print(a + ' join str')

 try:
     badFunction()
 except NameError:
     print("Variable x is not defined")
 except Exception as e:  
   print(e)   #print the exception object

 print("have a nice day")

Here you can see that the reason for the failure was included, and the program continued to run.

There’s a final improvement we can make which is to include where the problem occurred. This is really important where you have logging defined and you can see where the issue was caused.

import traceback

def badFunction():
     a = 1
     print(a + ' join str')

#run the unsafe code
try:
     badFunction()
except NameError:
     print("Variable x is not defined")
except Exception as e:
   print(e)
   traceback.print_tb(e.__traceback__)  #show the call list

print("have a nice day")

Here you can see the error description “Unsupported operand type(s) for +”, and then also where the error occurred from the initial call on line 8 with the call to “badFunction()” and the actual offending line of line 5.

Many more printing on python

There’s many more ways to print outputs within python, however this was intended to be a simple resource for some of the common printing challenges that come up, how you can use them, and with a simple example to get you up to speed very quickly with usable code. More to come!

Subscribe to our newsletter