The accepted answer suggests to modify the raw data for presentation purposes, something you generally do not want. Imagine you need to make further analyses with these columns and you need the precision you lost with rounding.

You can modify the formatting of individual columns in data frames, in your case:

output = df.to_string(formatters={
    'var1': '{:,.2f}'.format,
    'var2': '{:,.2f}'.format,
    'var3': '{:,.2%}'.format
})
print(output)

For your information '{:,.2%}'.format(0.214) yields 21.40%, so no need for multiplying by 100.

You don't have a nice HTML table anymore but a text representation. If you need to stay with HTML use the to_html function instead.

from IPython.core.display import display, HTML
output = df.to_html(formatters={
    'var1': '{:,.2f}'.format,
    'var2': '{:,.2f}'.format,
    'var3': '{:,.2%}'.format
})
display(HTML(output))

Update

As of pandas 0.17.1, life got easier and we can get a beautiful html table right away:

df.style.format({
    'var1': '{:,.2f}'.format,
    'var2': '{:,.2f}'.format,
    'var3': '{:,.2%}'.format,
})

You can do this using basic pandas operators .div and .sum, using the axis argument to make sure the calculations happen the way you want:

cols = ['<80%', '80-90', '>90']
df[cols] = df[cols].div(df[cols].sum(axis=1), axis=0).multiply(100)

• Calculate the sum of each column (df[cols].sum(axis=1). axis=1 makes the summation occur across the rows, rather than down the columns.
• Divide the dataframe by the resulting series (df[cols].div(df[cols].sum(axis=1), axis=0). axis=0 makes the division happen across the columns.
• To finish, multiply the results by 100 so they are percentages between 0 and 100 instead of proportions between 0 and 1 (or you can skip this step and store them as proportions).

You forgot to make a string:

format_percent = '{:.2f}'.format(percent_val)
#                ^      ^

Also, if you want a percent, you'll need to multiply by 100, and if you're on Python 2 (I can't tell), you'll either need to use floats or from __future__ import division.

If you want to round the number to two decimal places, rather than creating formatted output, there's the round function:

rounded = round(percent_val, 2)

Then your output will be a float instead of a string, and you can keep doing math with it.

Showing us what CSV_DAX['EL4F'] and date_DAX looks like would help us a lot. What you have seems okay with the limited information you gave us.

Here's one way

In [1371]: (100. * df / df.sum()).round(0)
Out[1371]:
               2014/2015  2015/2016  2016/2017  2017/2018
FinancialYear
April                9.0        6.0        6.0       24.0
May                  7.0        7.0        6.0       29.0
June                 5.0       10.0        6.0       24.0
July                 6.0       10.0        5.0       24.0
August               9.0        8.0       10.0        0.0
September            9.0        6.0       12.0        0.0
October              9.0       10.0        8.0        0.0
November            10.0        8.0        9.0        0.0
December             9.0       11.0        7.0        0.0
January              9.0        8.0       10.0        0.0
February             9.0        7.0       11.0        0.0
March                9.0        8.0       10.0        0.0

And, if you want to rounded to 1 decimal place with value as strings with '%'

In [1375]: (100. * df / df.sum()).round(1).astype(str) + '%'
Out[1375]:
              2014/2015 2015/2016 2016/2017 2017/2018
FinancialYear
April              8.7%      6.4%      6.4%     23.5%
May                7.4%      6.9%      6.1%     29.4%
June               4.8%     10.3%      6.4%     23.5%
July               5.9%     10.3%      5.2%     23.5%
August             9.2%      8.0%      9.9%      0.0%
September          8.9%      6.1%     12.0%      0.0%
October            9.2%      9.8%      7.9%      0.0%
November           9.7%      8.2%      8.7%      0.0%
December           9.2%     10.9%      6.7%      0.0%
January            8.7%      8.0%     10.2%      0.0%
February           9.4%      6.9%     10.8%      0.0%
March              9.2%      8.2%      9.6%      0.0%

You could use .apply('{:.0%}'.format):

import pandas as pd

df = pd.DataFrame([(168,219,185,89,112), (85,85,84,41,46)], 
                  index=['Total Listings', 'Total Sales'], columns=list(range(1,6)))
df.loc['Total Sales Rate'] = ((df.loc['Total Sales']/df.loc['Total Listings'])
                              .apply('{:.0%}'.format))

print(df)

yields

                    1    2    3    4    5
Total Listings    168  219  185   89  112
Total Sales        85   85   84   41   46
Total Sales Rate  51%  39%  45%  46%  41%

Notice that the Python str.format method has a built-in % format which multiplies the number by 100 and displays in fixed ('f') format, followed by a percent sign.

It is important to be aware that Pandas DataFrame columns must have a single dtype. Changing one value to a string forces the entire column to change its dtype to the generic object dtype. Thus the int64s or int32s in the Total Listings and Total Sales rows get recast as plain Python ints. This prevents Pandas from taking advantage of fast NumPy-based numerical operations which only work on native NumPy dtypes (like int64 or float64 -- not object).

So while the above code achieves the desired look, it isn't advisable to use this if further computation is to be done on the DataFrame. Instead, only convert to strings at the end if you need to do so for presentation.

Or, alternatively, transpose your DataFrame so the Total Sales Rate strings are in a column, not a row:

import pandas as pd

df = pd.DataFrame([(168,219,185,89,112), (85,85,84,41,46)], 
                  index=['Total Listings', 'Total Sales'], columns=list(range(1,6))).T

df['Total Sales Rate'] = ((df['Total Sales']/df['Total Listings'])
                              .apply('{:.0%}'.format))

print(df)

yields

   Total Listings  Total Sales Total Sales Rate
1             168           85              51%
2             219           85              39%
3             185           84              45%
4              89           41              46%
5             112           46              41%

The reason why

block_combine.loc["Total Sales Rate"] = pd.Series(["{0:.0f}%".format(val * 100) for val in block_combine.loc["Total Sales Rate"]])

shifted the values to the left by one column is because the new Series has an index which starts at 0 not 1. Pandas aligns the index of the Series on the right with the index of block_combine.loc["Total Sales Rate"] before assigning values to block_combine.loc["Total Sales Rate"].

Thus, you could alternatively have used:

block_combine.loc["Total Sales Rate"] = pd.Series(["{0:.0f}%".format(val * 100) 
    for val in block_combine.loc["Total Sales Rate"]], 
    index=block_combine.columns)

Use pandas' broadcasting operations:

df.rating = (df.rating * 100).astype(str) + '%'
df 
     name  rating
0  Johnny  100.0%
1    Brad   90.0%

Alternatively, using df.mul and df.add:

df.rating = df.rating.mul(100).astype(str).add('%')
df
     name  rating
0  Johnny  100.0%
1    Brad   90.0%

Toy example:

df=DataFrame({
    'No Show (%)':[5e-01, 4e-01]
})
df

Input

No Show (%)
0   0.5
1   0.4

Code

mergedgc.style.format({"No Show (%)": "{:.2%}"})

can be replaced by

df['No Show (%)'] = df['No Show (%)'].transform(lambda x: '{:,.2%}'.format(x))

Output

No Show (%)
0   50.00%
1   40.00%

Edit

Plot

df['No Show (%)'].replace('\%','', regex=True).astype(float).plot()