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.

If you're only dealing with the one column (gross margins) or don't mind the same formatting being applied to all float values, the code below should work. If you need to format just a single column in your dataframe, you may need to convert the values to a string (making further calculations break, since you mentioned this is a requirement). An option for this latter case would be to simply make a copy of the dataframe, format that copy for display, but keep the original for calculations. I couldn't get the df.style.format() methods mentioned in similar questions to work, possibly due to Pandas version.

import pandas as pd
# pd version == 2.0.1

margin_data = {"margins":[0.3646, 0.2584, 0.8954]}
my_df = pd.DataFrame(margin_data)

# What you were printing before
print("Old formatting")
gross_margins = my_df['margins']
print(gross_margins)

# Apply new formatting to all floats
print("\nNew formatting")
pd.options.display.float_format = '{:.2%}'.format
gross_margins = my_df['margins']
print(gross_margins)

# Confirm values are still what you expect
print("\nValues")
print(my_df['margins'].iloc[0])

# Apply formatting to only one column, but makes 
# values a string instead of float
print("\nString formatting single column")
margin_data["more data"] = [1,2,3]
my_df2 = pd.DataFrame(margin_data)
my_df2['margins'].map('{:.2%}'.format)
print(my_df2)

Produces:

Old formatting
0    0.3646
1    0.2584
2    0.8954
Name: margins, dtype: float64

New formatting
0   36.46%
1   25.84%
2   89.54%
Name: margins, dtype: float64

Values
0.3646

String formatting single column
   margins  more data
0   36.46%          1
1   25.84%          2
2   89.54%          3

First convert column to floats by astype:

df['C'] = df['C'].astype(float).map(lambda n: '{:.2%}'.format(n))

Also solution should be simplify:

df['C'] = df['C'].astype(float).map("{:.2%}".format)

EDIT:

Problem is some non numeric values in column.

Replace non numeric to 0:

print (df)
                  C
0            0.9977
1            0.1234
2  Covered fraction
df['C'] = pd.to_numeric(df['C'], errors='coerce').fillna(0).map("{:.2%}".format)
print (df)
        C
0  99.77%
1  12.34%
2   0.00%

Or remove rows with these values:

df['C'] = pd.to_numeric(df['C'], errors='coerce')
df = df.dropna(subset=['C'])
df['C'] = df['C'].astype(float).map("{:.2%}".format)
print (df)
        C
0  99.77%
1  12.34%

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%