For a flexible method that works even when formatting complicated string, you probably should use the string-formatting mini-language,

using either f-strings

>>> f'{"Hi": <16} StackOverflow!' # Python >= 3.6 'Hi StackOverflow!' 

or the str.format() method

>>> '{0: <16} StackOverflow!'.format('Hi') # Python >=2.6 'Hi StackOverflow!' 

The string format method lets you do some fun stuff with nested keyword arguments. The simplest case:

>>> '{message: <16}'.format(message='Hi') 'Hi ' 

If you want to pass in 16 as a variable:

>>> '{message: <{width}}'.format(message='Hi', width=16) 'Hi ' 

If you want to pass in variables for the whole kit and kaboodle:

'{message:{fill}{align}{width}}'.format( message='Hi', fill=' ', align='<', width=16, ) 

Which results in (you guessed it):

'Hi ' 

And for all these, you can use python 3.6+ f-strings:

message = 'Hi' fill = ' ' align = '<' width = 16 f'{message:{fill}{align}{width}}' 

And of course the result:

'Hi ' 

You can try this:

print("'%-100s'" % 'hi') 

Correct way of doing this would be to use Python's format syntax as described in the official documentation

For this case it would simply be:
'{:10}'.format('hi')
which outputs:
'hi '

Explanation:

format_spec ::= [[fill]align][sign][#][0][width][,][.precision][type] fill ::= <any character> align ::= "<" | ">" | "=" | "^" sign ::= "+" | "-" | " " width ::= integer precision ::= integer type ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%" 

Pretty much all you need to know is there ^.

Update: as of python 3.6 it's even more convenient with literal string interpolation!

foo = 'foobar' print(f'{foo:10} is great!') # foobar is great! 

Use str.ljust():

>>> 'Hi'.ljust(6) 'Hi ' 

You should also consider string.zfill(), str.rjust() and str.center() for string formatting. These can be chained and have the 'fill' character specified, thus:

>>> ('3'.zfill(8) + 'blind'.rjust(8) + 'mice'.ljust(8, '.')).center(40) ' 00000003 blindmice.... ' 

These string formatting operations have the advantage of working in Python v2 and v3.

Take a look at pydoc str sometime: there's a wealth of good stuff in there.

TL;DR

text = 'hi' print(f'{text:10}') # 'hi ' 

Longer explanation

Since Python3.6 you can use f-strings literal interpolation.

Variable space:

value = 4 space = 10 # move value to left print(f'foo {value:<{space}} bar') # foo 4 bar # move value to right print(f'foo {value:>{space}} bar') # foo 4 bar # center value print(f'foo {value:^{space}} bar') # foo 4 bar 

Constant space:

value = 4 # move value to left print(f'foo {value:<10} bar') # foo 4 bar # move value to right print(f'foo {value:>10} bar') # foo 4 bar # center value print(f'foo {value:^10} bar') # foo 4 bar 

If you want to padd with some other char then space, specify it at the beginning:

value = 4 space = 10 padd = '_' print(f'foo {value:{padd}^{space}} bar') # foo ____4_____ bar print(f'foo {value:_^10} bar') # foo ____4_____ bar 

As of Python 3.6 you can just do

>>> strng = 'hi' >>> f'{strng: <10}' 

with literal string interpolation.

Or, if your padding size is in a variable, like this (thanks @Matt M.!):

>>> to_pad = 10 >>> f'{strng: <{to_pad}}' 

you can also center your string:

'{0: ^20}'.format('nice') 

Use Python 2.7's mini formatting for strings:

'{0: <8}'.format('123') 

This left aligns, and pads to 8 characters with the ' ' character.

Just remove the 0 and it will add space instead:

>>> print("'%6d'"%4) 

Since it is not mentioned in other answers, I would like to point out that you can use strings methods for justificate text.

You have three options at least:

• Left justified:

>>> "left justified".ljust(30, "*") left justified**************** 

• Right justified:

>>> "right justified".rjust(30, "*") ***************right justified 

• Center justified

>>> "center justified".center(30, "*") *******center justified******* 

I am using python 3.10.13, but I believe it works in most 3.X python versions.

Wouldn't it be more pythonic to use slicing?

For example, to pad a string with spaces on the right until it's 10 characters long:

>>> x = "string" >>> (x + " " * 10)[:10] 'string ' 

To pad it with spaces on the left until it's 15 characters long:

>>> (" " * 15 + x)[-15:] ' string' 

It requires knowing how long you want to pad to, of course, but it doesn't require measuring the length of the string you're starting with.

A nice trick to use in place of the various print formats:

(1) Pad with spaces to the right:

('hi' + ' ')[:8] 

(2) Pad with leading zeros on the left:

('0000' + str(2))[-4:] 

This approach is not recommended in Python but the logic is useful for languages and macros that lack quality text formatting functions. :)