You can use format with > to right justify

N = 10
for i in range(1, N+1):
    print('{:>10}'.format('#'*i))

Output

         #
        ##
       ###
      ####
     #####
    ######
   #######
  ########
 #########
##########

You can programattically figure out how far to right-justify using rjust as well.

for i in range(1, N+1):
    print(('#'*i).rjust(N))

The amount can be formated like this:

"${:.2f}".format(amount)

You can add padding to a string, for example for a width of 20:

"{:20s}".format(mystring)

You can right align the string, for example with a width of 7:

"{:>7s}".format(mystring)

Putting all this together:

s = "The subtotal was:"
a = 24.95
print("{:20s}{:>7s}".format(s, "${.2f}".format(a))

1. There's no docstring. What does this code do? How do I call it? What does it return?

2. A class represents a group of persistent objects with common behaviour. But there are no persistent objects here, so there is no need for a class. This is also apparent from the fact that the fullJustify method does not refer to self. So don't write a class, just write a function.

3. Python strings have a join method for concatenation. So this code:

   oneline = ""
   for ind in range(start_ind, num_of_words-1):
       oneline = oneline + words[ind] + " "
   oneline = oneline + words[num_of_words-1]
   

   can be simplified to:

   oneline = ' '.join(words[start_ind:])
   

4. Python strings have an ljust method for left-justification within a fixed-width field. So this code:

   pad_spaces = maxWidth - len(oneline)
   oneline = oneline + " "*pad_spaces
   

   can be simplified to:

   oneline = oneline.ljust(maxWidth)
   

5. Python has a built-in function divmod that simultaneously computes the quotient and remainder. So this code:

   basic_pad_spaces = extra_spaces // (word_num - 1)
   addition_pad_spaces = extra_spaces % (word_num - 1)
   

   can be simplied to:

   basic_pad_spaces, addition_pad_spaces = divmod(extra_spaces, word_num - 1)
   

6. Left justification has to be done in two cases: a single word on a line, and the last line. It would therefore make sense to extract this common code into a function:

   def left_justify(words, width):
       """Given an iterable of words, return a string consisting of the words
       left-justified in a line of the given width.
   
       >>> left_justify(["hello", "world"], 16)
       'hello world     '
   
       """
       return ' '.join(words).ljust(width)
   

   Even though this is a simple one-line implementation, giving it a name improves the readability of the code where it is called. Note also the example in the docstring: this can be run and checked using the doctest module.

7. When you are writing code that takes an input sequence (here, some words) and produces an output sequence (here, the justified lines), then it's a good idea in Python to write the code so that it iterates over the input (using for), and generates the output (using yield).

   With this approach: there's no need to keep the whole input and output sequences in memory at once (you operate on one or a few items at a time); there's no need to remember indexes into the input sequence (you just process each item as you get it); and there's no need to accumulate and return the output sequence (you just yield each item as you compute it).

   In this case:

   def justify(words, width):
       """Divide words (an iterable of strings) into lines of the given
       width, and generate them. The lines are fully justified, except
       for the last line, and lines with a single word, which are
       left-justified.
   
       >>> words = "This is an example of text justification.".split()
       >>> list(justify(words, 16))
       ['This    is    an', 'example  of text', 'justification.  ']
   
       """
       line = []             # List of words in current line.
       col = 0               # Starting column of next word added to line.
       for word in words:
           if line and col + len(word) > width:
               if len(line) == 1:
                   yield left_justify(line, width)
               else:
                   # After n + 1 spaces are placed between each pair of
                   # words, there are r spaces left over; these result in
                   # wider spaces at the left.
                   n, r = divmod(width - col + 1, len(line) - 1)
                   narrow = ' ' * (n + 1)
                   if r == 0:
                       yield narrow.join(line)
                   else:
                       wide = ' ' * (n + 2)
                       yield wide.join(line[:r] + [narrow.join(line[r:])])
               line, col = [], 0
           line.append(word)
           col += len(word) + 1
       if line:
           yield left_justify(line, width)
   

Here's a recipe in the ActiveState Python Cookbook for exactly that:

"Align string with spaces between words to fit specified width"

Try this approach using the newer str.format syntax. This uses a width of 12, space padded, right aligned.

line_new = '{:>12}  {:>12}  {:>12}'.format(words[0], words[1], words[2])

Example with the interpreter:

>>> line = "123 456 789"
>>> words = line.split(' ')
>>> line_new = '{:>12}  {:>12}  {:>12}'.format(words[0], words[1], words[2])
>>> print(line_new)
         123           456           789

And here's how to do it using the old % syntax (useful for older versions of Python that don't support str.format):

line_new = '%12s  %12s  %12s' % (words[0], words[1], words[2])