Tkinter Directory Browser with Pandas Sorting

Q: How do I select a directory in Tkinter?

Use filedialog.askdirectory(). It returns the selected directory path or an empty value when the user cancels the dialog.

Q: How are file details added to a Pandas DataFrame?

The application reads each directory entry with os.scandir(), creates a dictionary containing its name, type, modification time and size, and then creates a DataFrame from the list of dictionaries.

Q: How are Treeview columns sorted?

Each heading calls a function that sorts the DataFrame with sort_values() and then refreshes the Treeview rows.

Q: Why is file size stored as bytes?

Numeric byte values sort correctly. Human-readable KB, MB and GB strings are generated only when the values are displayed in Treeview.

Q: Why is directory size left blank?

The size stored on a directory entry is not the total size of all files inside that folder. Calculating complete folder size would require recursively scanning its contents.

Q: Why store modification time as datetime?

A datetime value preserves both the date and time and allows Pandas to perform chronological sorting correctly.

Q: Does selecting another directory create another Treeview?

No. The existing Treeview and Scrollbars are reused. Only the DataFrame and displayed rows are replaced.

Tkinter directory browser displaying file details with Pandas sorting

This project creates a directory browser using Tkinter, Pandas and Treeview. After selecting a directory, the application collects the name, file type, modification date and file size of each item and stores the details in a Pandas DataFrame.

Clicking a Treeview heading sorts the DataFrame using sort_values(). Clicking the same heading again reverses that column between ascending and descending order.

Select directory
       |
       v
os.scandir()
       |
       v
File metadata
       |
       v
Pandas DataFrame
       |
       v
Tkinter Treeview
       |
       v
Click heading
       |
       v
sort_values()
       |
       v
Refresh rows

Show Table of Contents

Directory Browser Layout
Select a Directory
Read File and Folder Details
Create the DataFrame
Display Data in Treeview
Display File Sizes
Sort Treeview Columns
Sort Modification Dates Correctly
Files and Folders
Complete Directory Browser
Continue the Project
FAQs

Directory Browser Layout Top ↑

The GUI contains:

a Button to select a directory;
a Label showing the selected path;
a Treeview displaying file details;
vertical and horizontal Scrollbars;
a status Label showing the number of directory items.

The Treeview columns are:

Name
Type
Date Modified
Size

Select a Directory Top ↑

Tkinter askdirectory() lets the user choose a folder:

directory=filedialog.askdirectory(
    title='Select directory'
)

if not directory:
    return

When the user cancels the dialog, the current directory listing remains unchanged.

Read File and Folder Details with os.scandir() Top ↑

The older program used:

files=os.listdir(path)
f_path=path+'\\'+f

The backslash makes this path construction Windows-specific.

The revised application uses:

with os.scandir(directory) as entries:
    for entry in entries:
        stat=entry.stat(
            follow_symlinks=False
        )

os.scandir() provides directory entries containing the name and access to file metadata without manually joining a directory string and filename.

Create a Pandas DataFrame Top ↑

Each directory entry becomes one dictionary:

rows.append({
    'Name':entry.name,
    'Type':file_type,
    'Date Modified':modified,
    'Size':size
})

The complete list creates the DataFrame:

df=pd.DataFrame(
    rows,
    columns=[
        'Name',
        'Type',
        'Date Modified',
        'Size'
    ]
)

The DataFrame contains the actual values used for sorting. Formatting for display is handled separately.

Create the Treeview Only Once Top ↑

The older program created another Treeview every time a directory was selected.

The revised application creates one Treeview when the program starts:

tree=ttk.Treeview(
    table_frame,
    columns=(
        'Name',
        'Type',
        'Date Modified',
        'Size'
    ),
    show='headings'
)

Loading or sorting data only replaces its rows.

for item in tree.get_children():
    tree.delete(item)

Keep File Size Numeric but Display KB or MB Top ↑

File size is stored in the DataFrame as bytes:

size=stat.st_size

This means numeric sorting remains correct.

The display function converts the byte count into a readable value:

def format_size(size):
    if pd.isna(size):
        return ''

    value=float(size)

    for unit in (
        'B','KB','MB','GB','TB'
    ):
        if value<1024 or unit=='TB':
            return f'{value:.1f} {unit}'
        value/=1024

This avoids sorting text values such as:

1 KB
20 MB
950 KB

which would not produce a correct numeric size order.

Sort Each Column Independently Top ↑

The original program used one Boolean variable:

order=True

so clicking one column changed the next sorting direction for every other column.

The revised application uses a dictionary:

sort_state={}

Get the next direction for the clicked column:

ascending=sort_state.get(
    column_name,
    True
)

Sort the DataFrame:

df=df.sort_values(
    by=column_name,
    ascending=ascending,
    na_position='last',
    kind='stable'
).reset_index(
    drop=True
)

Store the opposite direction for the next click:

sort_state[column_name]=not ascending

This follows the same pattern used in our Tkinter Pandas column sorting tutorial.

Store Modification Time as datetime Top ↑

The old program converted the modification time immediately to:

2026-09-07

This loses the time of day.

The revised DataFrame stores:

modified=datetime.fromtimestamp(
    stat.st_mtime
)

Treeview displays a formatted version:

modified.strftime(
    '%Y-%m-%d %H:%M'
)

The DataFrame still contains a real datetime value, so sorting is based on the complete timestamp rather than display text.

Handle Files and Folders Differently Top ↑

For a directory:

Type = Folder
Size = blank

For a normal file:

report.pdf
    |
    +--> Type = .pdf
    +--> Size = actual file bytes

A file without an extension is displayed as:

Type = File

The application does not attempt to calculate the complete recursive size of folders. Doing that would require scanning all nested files and can make directory browsing much slower.

Complete Tkinter Pandas Directory Browser Top ↑

import os
import tkinter as tk
from datetime import datetime
from tkinter import filedialog,ttk

import pandas as pd

COLUMNS=['Name','Type','Date Modified','Size']

df=pd.DataFrame(columns=COLUMNS)
sort_state={}

root=tk.Tk()
root.title('Directory Browser - plus2net')
root.geometry('850x520')
root.minsize(650,420)
root.columnconfigure(0,weight=1)
root.rowconfigure(2,weight=1)

path_var=tk.StringVar(value='No directory selected')
status_var=tk.StringVar(value='Select a directory.')

def format_size(size):
    if pd.isna(size):
        return ''

value=float(size)

for unit in ('B','KB','MB','GB','TB'):
        if value<1024 or unit=='TB':
            return f'{value:.1f} {unit}'
        value/=1024

def reset_headings():
    for column in COLUMNS:
        tree.heading(
            column,
            text=column,
            command=lambda name=column:sort_column(name)
        )

def refresh_tree():
    for item in tree.get_children():
        tree.delete(item)

for name,file_type,modified,size in df.itertuples(index=False,name=None):
        modified_text=(
            modified.strftime('%Y-%m-%d %H:%M')
            if pd.notna(modified)
            else ''
        )

tree.insert(
            '',
            tk.END,
            values=(
                name,
                file_type,
                modified_text,
                format_size(size)
            )
        )

def load_directory(directory):
    global df,sort_state

rows=[]
    skipped=0

try:
        with os.scandir(directory) as entries:
            for entry in entries:
                try:
                    stat=entry.stat(follow_symlinks=False)

if entry.is_dir(follow_symlinks=False):
                        file_type='Folder'
                        size=None
                    elif entry.is_file(follow_symlinks=False):
                        extension=os.path.splitext(entry.name)[1].lower()
                        file_type=extension if extension else 'File'
                        size=stat.st_size
                    else:
                        file_type='Other'
                        size=stat.st_size

rows.append({
                        'Name':entry.name,
                        'Type':file_type,
                        'Date Modified':datetime.fromtimestamp(stat.st_mtime),
                        'Size':size
                    })

except OSError:
                    skipped+=1

except OSError as e:
        status_var.set(f'Unable to read directory: {e}')
        return

df=pd.DataFrame(rows,columns=COLUMNS)
    sort_state={}

reset_headings()
    refresh_tree()

status_var.set(
        f'Items: {len(df)}'
        +(f' | Skipped: {skipped}' if skipped else '')
    )

def select_directory():
    directory=filedialog.askdirectory(title='Select directory')

if not directory:
        status_var.set('Directory selection cancelled.')
        return

path_var.set(directory)
    load_directory(directory)

def sort_column(column_name):
    global df

if df.empty:
        return

ascending=sort_state.get(column_name,True)

try:
        df=df.sort_values(
            by=column_name,
            ascending=ascending,
            na_position='last',
            kind='stable'
        ).reset_index(drop=True)
    except (TypeError,ValueError) as e:
        status_var.set(f'Unable to sort {column_name}: {e}')
        return

sort_state[column_name]=not ascending

refresh_tree()
    reset_headings()

direction='ASC' if ascending else 'DESC'

tree.heading(
        column_name,
        text=f'{column_name} ({direction})',
        command=lambda name=column_name:sort_column(name)
    )

status_var.set(
        f'Sorted {column_name} '
        f'{"ascending" if ascending else "descending"}.'
    )

top_frame=ttk.Frame(root,padding=10)
top_frame.grid(row=0,column=0,sticky='ew')
top_frame.columnconfigure(1,weight=1)

ttk.Button(
    top_frame,
    text='Select Directory',
    command=select_directory
).grid(row=0,column=0,padx=(0,10))

ttk.Label(
    top_frame,
    textvariable=path_var,
    wraplength=680
).grid(row=0,column=1,sticky='w')

ttk.Label(
    root,
    text='Click a column heading to sort.',
    font=('Arial',10,'bold')
).grid(row=1,column=0,sticky='w',padx=10,pady=(0,5))

table_frame=ttk.Frame(root,padding=(10,5))
table_frame.grid(row=2,column=0,sticky='nsew')
table_frame.columnconfigure(0,weight=1)
table_frame.rowconfigure(0,weight=1)

tree=ttk.Treeview(
    table_frame,
    columns=COLUMNS,
    show='headings',
    selectmode='browse'
)
tree.grid(row=0,column=0,sticky='nsew')

tree.column('Name',width=260,minwidth=150,anchor='w')
tree.column('Type',width=100,minwidth=70,anchor='w')
tree.column('Date Modified',width=160,minwidth=130,anchor='center')
tree.column('Size',width=110,minwidth=80,anchor='e')

reset_headings()

y_scroll=ttk.Scrollbar(
    table_frame,
    orient='vertical',
    command=tree.yview
)
y_scroll.grid(row=0,column=1,sticky='ns')

x_scroll=ttk.Scrollbar(
    table_frame,
    orient='horizontal',
    command=tree.xview
)
x_scroll.grid(row=1,column=0,sticky='ew')

tree.configure(
    yscrollcommand=y_scroll.set,
    xscrollcommand=x_scroll.set
)

ttk.Label(
    root,
    textvariable=status_var,
    wraplength=800
).grid(row=3,column=0,sticky='w',padx=10,pady=(5,10))

root.mainloop()

Why os.scandir() Is Better for This Project Top ↑

The older workflow required several operations:

os.listdir()
      |
      v
filename
      |
      v
manually build path
      |
      v
os.path.getmtime()
os.path.getsize()
os.path.splitext()

The revised program works with a directory entry:

os.scandir()
      |
      v
entry
      |
      +--> entry.name
      +--> entry.stat()
      +--> entry.is_dir()
      +--> entry.is_file()

This also removes the Windows-specific:

path + '\\' + filename

Why Size Is Formatted Only for Display Top ↑

Consider:

950 KB
1.2 MB
80 KB

If those strings are stored directly in the DataFrame, sorting is textual rather than numeric.

Instead:

DataFrame Size
--------------
972800
1258291
81920

Treeview can display:

950.0 KB
1.2 MB
80.0 KB

The user gets readable output while Pandas retains the correct numeric values for sorting.

Independent Sorting for Each Heading Top ↑

Each column begins with ascending sorting independently:

Name          ASC -> DESC -> ASC
Type          ASC -> DESC -> ASC
Date Modified ASC -> DESC -> ASC
Size          ASC -> DESC -> ASC

This avoids the old behaviour where sorting Name could unexpectedly determine the first sorting direction of Size.

Continue the Tkinter Pandas Projects Top ↑

Use the same heading-click sorting pattern with regular DataFrame records:

Treeview Column Sorting

Add DataFrame searching:

Search DataFrame Records

Let the user choose which DataFrame columns are visible:

Select DataFrame Columns

Frequently Asked Questions Top ↑

Q1: How do I select a directory in Tkinter?

Use filedialog.askdirectory(). It returns the selected directory path or an empty value when the user cancels the dialog.

Q2: How are file details added to a Pandas DataFrame?

The application reads each directory entry with os.scandir(), creates a dictionary containing its name, type, modification time and size, and then creates a DataFrame from the list of dictionaries.

Q3: How are Treeview columns sorted?

Each heading calls a function that sorts the DataFrame with sort_values() and then refreshes the Treeview rows.

Q4: Why is file size stored as bytes?

Numeric byte values sort correctly. Human-readable KB, MB and GB strings are generated only when the values are displayed in Treeview.

Q5: Why is directory size left blank?

The size stored on a directory entry is not the total size of all files inside that folder. Calculating complete folder size would require recursively scanning its contents.

Q6: Why store modification time as datetime?

A datetime value preserves both the date and time and allows Pandas to perform chronological sorting correctly.

Q7: Does selecting another directory create another Treeview?

No. The existing Treeview and Scrollbars are reused. Only the DataFrame and displayed rows are replaced.

DataFrame Sorting DataFrame Search Select Columns

Tkinter Projects Tkinter Pandas Projects

Python Tkinter Pandas Treeview sort_values() Scrollbar Dictionary Python Tutorials

Subhendu Mohapatra

Author & Instructor at plus2net

I write and maintain practical tutorials on Python, PHP, SQL, JavaScript, HTML, jQuery, and web development at plus2net. The tutorials focus on clear explanations, working examples, and code that readers can test and adapt while learning.

About the author Watch on YouTube

Connect: