To make all your floats show comma separators by default in pandas versions 0.23 through 0.25 set the following:

pd.options.display.float_format = '{:,}'.format

https://pandas.pydata.org/pandas-docs/version/0.23.4/options.html

In pandas version 1.0 this leads to some strange formatting in some cases.

When formatting a number with , you can just use '{:,}'.format:

n = 10000
print '{:,}'.format(n)
n = 1000.1
print '{:,}'.format(n)

In pandas, you can use the formatters parameter to to_html as discussed here.

num_format = lambda x: '{:,}'.format(x)
def build_formatters(df, format):
    return {
        column:format 
        for column, dtype in df.dtypes.items()
        if dtype in [ np.dtype('int64'), np.dtype('float64') ] 
    }
formatters = build_formatters(data_frame, num_format)
data_frame.to_html(formatters=formatters)

Adding the thousands separator has actually been discussed quite a bit on stackoverflow. You can read here or here.

You could monkey-patch pandas.io.formats.format.IntArrayFormatter:

import contextlib
import numpy as np
import pandas as pd
import pandas.io.formats.format as pf
np.random.seed(2015)

@contextlib.contextmanager
def custom_formatting():
    orig_float_format = pd.options.display.float_format
    orig_int_format = pf.IntArrayFormatter

    pd.options.display.float_format = '{:0,.2f}'.format
    class IntArrayFormatter(pf.GenericArrayFormatter):
        def _format_strings(self):
            formatter = self.formatter or '{:,d}'.format
            fmt_values = [formatter(x) for x in self.values]
            return fmt_values
    pf.IntArrayFormatter = IntArrayFormatter
    yield
    pd.options.display.float_format = orig_float_format
    pf.IntArrayFormatter = orig_int_format


df = pd.DataFrame(np.random.randint(10000, size=(5,3)), columns=list('ABC'))
df['D'] = np.random.random(df.shape[0])*10000

with custom_formatting():
    print(df)

yields

      A     B     C        D
0 2,658 2,828 4,540 8,961.77
1 9,506 2,734 9,805 2,221.86
2 3,765 4,152 4,583 2,011.82
3 5,244 5,395 7,485 8,656.08
4 9,107 6,033 5,998 2,942.53

while outside of the with-statement:

print(df)

yields

      A     B     C            D
0  2658  2828  4540  8961.765260
1  9506  2734  9805  2221.864779
2  3765  4152  4583  2011.823701
3  5244  5395  7485  8656.075610
4  9107  6033  5998  2942.530551

Styler is developing its own options. The current version 1.3.0 of pandas has not got many. Perhaps only the styler.render.max_elements.

Some recent pull requests to the github repo are adding these features but they will be Stylers own version.

The default formatter actually addresses string, float/complex and int separately. So you just need to give the necessary arguments:

df = pd.DataFrame({0: ['age',200000,300000.54321],1: ['city',200000,'']},
                  index=['feature','N','mean'])
df.style.format(thousands=",", precision=2, subset=[0])

           0    1
feature  age    city
N       200,000 200000
mean    300,000.54  

Alternatively you can write your own formatter, but this is essentially copying the pandas default formatter:

def func(v):
    if isinstance(v, (float, complex)):
        return "{:,.2f}".format(v)
    elif isinstance(v, int):
        return "{:,.0f}".format(v)
    return v

df.style.format({0: func})
           0    1
feature  age    city
N       200,000 200000
mean    300,000.54  

The short answer is: no, there is no way to "apply a style permanently to a DataFrame".

Styling is typically the last step before rendering (as HTML), although it can be composed by chaining.

The result of df.style.anyfunction() is a Style object. As such, it doesn't have the methods of DataFrame, in particular as per your question, .head():

>>> type(df.style.format('${:,.2f}'))
pandas.io.formats.style.Styler

The DataFrame doesn't know anything about any Styler. Instead, it is the Styler that has a reference to the DataFrame it was originally used for.

You can take the style itself and apply it to another DataFrame (with Styler.use() and Styler.export(), see below). However, regrettably, that doesn't seem to include .format() definitions (at least in pandas=1.2.1).

It's really too bad, because otherwise, it makes it quite easy to reuse a style for another DF (or df.head() per your example):

def neg_red(x):
    return f"color: {'red' if x < 0 else 'black'}"

df = pd.DataFrame(np.random.uniform(-4, 5, (5, 3)) * 1e4)
s = df.style.format('${:,.2f}').applymap(neg_red).highlight_max()
s

Observe that: assert vars(s)['data'] is df. So as I said above, the Styler object has a reference (data) to the DataFrame it was used on initially (so that, when it is asked to render, it knows what data to render).

Now, you can use the Styler object and apply it to another DataFrame (here: df.head(3)):

df.head(3).style.use(s.export())

As you can see, all the styling functions have been carried over, except for the formatting! I would imagine this is a bug or an oversight.