I have to admit that my question and its title were incorrectly set and I have to close this topic:

pt.style.format({'percent_on_rent': '{:.0%}'})

code line in my code snippet returns pandas Styler object instance linked to its parent pandas DataFrame object instance. AFAIU when Jupiter Notebook code cell with such a code is run then Jupiter Notebook captures pandas Styler object instance and immediately formats it for output under the running cell while

print(pt)

prints pandas DataFrame object instance and how this object instance string(?) representation is obtained by the print(...) Python method and sent to standard(?) output and this standard output captured by Jupiter Notebook and rendered under the cell where the code is running can be probably found only in the Jupiter Notebook sources. Writing and running in a Jupiter Notebook cell the following code:

my_styler = pt.style.format({'percent_on_rent': '{:.0%}'})
my_styler

would be equivalent to just

pt.style.format({'percent_on_rent': '{:.0%}'})

while

my_styler = pt.style.format({'percent_on_rent': '{:.0%}'})
print(my_styler)

would output

<pandas.io.formats.style.Styler object at 0x...>

Here is a link on a topic of using pandas Styler object in Jupiter Notebook. More information could be googled.

Please correct me if I'm still wrong in this explanation.

Thanks!

[Update]

Here is a sample code, which demonstrates how to return pandas Styler object instance from Python methods and then output them in Jupiter Notebook using display(...) method:

import numpy as np
import pandas as pd

def rc1():
    return np.random.choice(['benzine', 'diesel', 'electro'])

def rc2():
    return 1 if np.random.choice([True, False]) else 0

def test_pandas_styler(caption):
    # fill list
    data = []
    for i in range(21): data.append([rc1(), rc2()])
       
    # make data frame
    df = pd.DataFrame(data, columns = ['engine_type', 'rented']) 
    
    # make pivot table
    pt = df.pivot_table(index=['engine_type'], values= ['rented'], aggfunc=[np.mean]).reset_index()
    pt.set_axis(['engine type', 'percent on rent'], axis = 'columns', inplace = True)
    
    # style pivot table
    st = pt.style.format({'percent on rent': '{:.0%}'}).hide_index()    
    st.set_table_styles([
           dict(selector="th", props=[('color', 'darkblue'), 
                                      ('vertical-align', 'top')]),
           dict(selector="th:first-child", props=[('max-width', '70px'), ('text-align', 'left')]),
           dict(selector="th:last-child", props=[('max-width', '50px')]),
           dict(selector="td:first-child", props=[('text-align', 'left')])
            ])    
    st.caption = caption
    
    return st

for f in [test_pandas_styler('Test {}'.format(i)) for i in range(1,4)]:
    display(f)

dfResults.style.format(currency_format) has indeed no effect on your original dfResults simply because it returns a complete different object. Not to mention that it is a Styler (not a DataFrame). Also, by switching to the former, you won't have access to the latter's API anymore. Another point, from what I understand through your code, you're running two expressions in the same Jupyter cell and since, by default, only the last one is displayed, you're seeing your original dataframe and thus, with it's default float formatting representation.

---------------------------------------- 
|def currency_format(x):                |
|    return "${:,.0f}".format(x/1000000)|
|                                       | 
|dfResults.style.format(currency_format)|
|dfResults                              | # << only this one is displayed
----------------------------------------

So if you're adjusting the format only for visual purposes, just remove dfResults in the end of the cell or store the styler in a separate variable and display it. Otherwise, if you still need to benefit from the DataFrame's API, setting a custom float format is your only option (which you already did apparently).

pd.set_option("display.float_format", lambda x: "${:,.0f}".format(x/1e6))

You may also be interested by this Q/A : Pandas : Set format for a single DataFrame.

The .style gives back a Styler object (reference). The Styler object can be formatted in different ways. This has not happened in your DD column; you are only halfway through.

You can format the dataframe with

df.style.format({'Quantity': "{:.2%}"})

as explained in this SO post.

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.