格式输出字符串，右对齐

Try this approach using the newer str.format syntax:

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

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' % (word[0], word[1], word[2])

It can be achieved by using rjust:

line_new = word[0].rjust(10) + word[1].rjust(10) + word[2].rjust(10)

You can align it like that:

print('{:>8} {:>8} {:>8}'.format(*words))

where > means "align to right" and 8 is the width for specific value.

And here is a proof:

>>> for line in [[1, 128, 1298039], [123388, 0, 2]]:
print('{:>8} {:>8} {:>8}'.format(*line))




1      128  1298039
123388        0        2

Ps. *line means the line list will be unpacked, so .format(*line) works similarly to .format(line[0], line[1], line[2]) (assuming line is a list with only three elements).

Simple tabulation of the output:

a = 0.3333333
b = 200/3
print("variable a    variable b")
print("%10.2f    %10.2f" % (a, b))

output:

variable a    variable b
0.33         66.67

%10.2f: 10 is the minimum length and 2 is the number of decimal places.

I really enjoy a new literal string interpolation in Python 3.6+:

line_new = f'{word[0]:>12}  {word[1]:>12}  {word[2]:>12}'

Reference: PEP 498 -- Literal String Interpolation

Here is another way how you can format using 'f-string' format:

print(
f"{'Trades:':<15}{cnt:>10}",
f"\n{'Wins:':<15}{wins:>10}",
f"\n{'Losses:':<15}{losses:>10}",
f"\n{'Breakeven:':<15}{evens:>10}",
f"\n{'Win/Loss Ratio:':<15}{win_r:>10}",
f"\n{'Mean Win:':<15}{mean_w:>10}",
f"\n{'Mean Loss:':<15}{mean_l:>10}",
f"\n{'Mean:':<15}{mean_trd:>10}",
f"\n{'Std Dev:':<15}{sd:>10}",
f"\n{'Max Loss:':<15}{max_l:>10}",
f"\n{'Max Win:':<15}{max_w:>10}",
f"\n{'Sharpe Ratio:':<15}{sharpe_r:>10}",
)

This will provide the following output:

Trades:              2304
Wins:                1232
Losses:              1035
Breakeven:             37
Win/Loss Ratio:      1.19
Mean Win:           0.381
Mean Loss:         -0.395
Mean:               0.026
Std Dev:             0.56
Max Loss:          -3.406
Max Win:             4.09
Sharpe Ratio:      0.7395

What you are doing here is you are saying that the first column is 15 chars long and it's left-justified and the second column (values) is 10 chars long and it's right-justified.

If you joining items from the list and you want to format space between items you can use `` and regular formatting techniques.

This example separates each number by 3 spaces. The key here is f"{'':>3}"

print(f"{'':>3}".join(str(i) for i in range(1, 11)))

output:

1   2   3   4   5   6   7   8   9   10

To do it by using f-string and with control of the number of trailing digits:

print(f'A number -> {my_number:>20.5f}')

Mixing Vlad's fine content with others, the code can also be written for readabily and ease-of-use like ...

>>> cnt = wins = losses      = str(   2)
>>> evens = win_r = mean_w   = str(  14)
>>> mean_l = mean_trd = sd   = str( 336)
>>> max_l = max_w = sharpe_r = str(4278)
>>>
>>> rpad = 10
>>>
>>> print(
...     '\n Trades         ' +      cnt.rjust(rpad),
...     '\n Wins           ' +     wins.rjust(rpad),
...     '\n Losses         ' +   losses.rjust(rpad),
...     '\n Breakeven      ' +    evens.rjust(rpad),
...     '\n Win/Loss Ratio ' +    win_r.rjust(rpad),
...     '\n Mean Win       ' +   mean_w.rjust(rpad),
...     '\n Mean Loss      ' +   mean_l.rjust(rpad),
...     '\n Mean           ' + mean_trd.rjust(rpad),
...     '\n Std Dev        ' +       sd.rjust(rpad),
...     '\n Max Loss       ' +    max_l.rjust(rpad),
...     '\n Max Win        ' +    max_w.rjust(rpad),
...     '\n Sharpe Ratio   ' + sharpe_r.rjust(rpad),
... )


Trades                  2
Wins                    2
Losses                  2
Breakeven              14
Win/Loss Ratio         14
Mean Win               14
Mean Loss             336
Mean                  336
Std Dev               336
Max Loss             4278
Max Win              4278
Sharpe Ratio         4278