Try:

import pandas as pd
pd.set_option('display.precision', 2)

This causes it to use scientific (exponential) notation when appropriate, and keeps 2 decimal places. It makes the decision about whether to use scientific notation or not on a per-column basis, so if 1 value requires scientific notation, the whole column is displayed that way.

Examples:

0.0012             1.23e-03
0.0123             1.23e-02
100                1.00e+02
1234567890.123456  1.23e+09

Fixed the issue, seems to be related to how Decimal converts from float to decimal. Setting the Values column to be of data type string then converting to Decimal got me the result I desired.

def get_df(table_filepath):
    df = pd.read_csv(table_filepath)
    df['Value'] = df['Value'].apply(str) 
    df['Value'] = df['Value'].apply(Decimal)

You could go through each value, and if it is a number x, subtract int(x) from it, and if this difference is not 0.0, convert the number x to int(x). Or, if you're not dealing with any non-integers, you could just convert all values that are numbers to ints.

For an example of the latter (when your original data does not contain any non-integer numbers):

for index, row in df1.iterrows():
    for c, x in enumerate(row):
        if isinstance(x, float):
            df1.iloc[index,c] = int(x)

For an example of the former (if you want to keep non-integer numbers as non-integer numbers, but want to guarantee that integer numbers stay as integers):

import numbers
import sys

for c, col in enumerate(df1.columns):
    foundNonInt = False
    for r, index in enumerate(df1.index):
        if isinstance(x, float):
            if (x - int(x) > sys.float_info.epsilon):
                foundNonInt = True
                    break
    if (foundNonInt==False):
        df1.iloc[:,c] = int(df1.iloc[:,c])
    else:

Note, the above method is not fool-proof: if by chance, a non-integer number column from the original data set contains non-integers that are all x.0000000, all the way to the last decimal place, this will fail.

You can also use the 'display.float_format' option

with pd.option_context('display.float_format', '{:0.20f}'.format):
    print(pd.DataFrame([34.98774564765]))

                        0
0 34.98774564765000150146

The round method only works as I think you want if the values in each column (i.e., in each pandas.Series) of the DataFrame already have more decimal points than the value you are passing to round.

For instance:

pd.Series([1.09185, 2.31476]).round(2)

returns:

0    1.09
1    2.31
dtype: float64

But if the Series has fewer decimal points than the number you are trying to round, you will not get the desired visual result. For instance:

pd.Series([1.6, 2.3]).round(2)

returns:

0    1.6
1    2.3
dtype: float64

This is mathematically correct, since the numbers in the second Series already have fewer decimal points than 2. But it is not what you visually expect.

If you only want to change the display of a Series or DataFrame inside a notebook, you should use pandas.set_option("display.precision", 2). This changes the visual representation of the Series or DataFrame, without changing the inner precision of the actual numbers.

If for some reason you need to save a Series or DataFrame with the numbers already with the desired decimal points, you can apply a function that converts the object to string type and formats the string:

pd.Series([1.6, 2.3]).apply(lambda x: f"{x:.2f}")

which returns a new Series of dtype object instead of float:

0    1.60
1    2.30
dtype: object

import numpy as np
np.round(p_table, decimals=2)