Tkinter Treeview Row Selection & DataFrame Delete

Q: How do I detect a selected Treeview row?

Bind TreeviewSelect to a function and use tree.selection() to get the currently selected Treeview item.

Q: How are selected row values displayed?

Use tree.item(selected_iid, 'values') to read the values stored in the selected Treeview row.

This project extends our Tkinter DataFrame search tutorial. After filtering a Pandas DataFrame and displaying the matching records in Treeview, the user can select one result, display its values and delete that exact row from the working DataFrame.

Selecting a filtered Pandas DataFrame row in Tkinter Treeview

The application keeps a connection between every displayed Treeview item and the corresponding row in the source DataFrame. This is more reliable than assuming the first DataFrame column contains a unique ID.

Source DataFrame
       |
       v
Search / Filter
       |
       v
Filtered DataFrame
       |
       v
Treeview
       |
       v
Select row
       |
       v
Source DataFrame index
       |
       v
Delete row
       |
       v
Run search again
       |
       v
Updated Treeview

Deletion note: deleting a row changes the DataFrame held in memory. It does not automatically delete the row from the original Excel or CSV file.

Show Table of Contents

Search and Create the Filtered DataFrame
Display Results in Treeview
Map Treeview Items to DataFrame Rows
Detect Treeview Row Selection
Display Selected Row Details
Delete the Selected DataFrame Row
Refresh Search Results after Delete
Save the Filtered Result
Copy Result to Clipboard
Add Treeview Scrollbars
Complete Application
Video Tutorial
FAQs

Search and Create the Filtered DataFrame Top ↑

The search logic comes from Part I of the DataFrame search project.

A numeric query can perform an exact comparison against the id column:

if query.isdigit() and 'id' in df.columns:
    id_values=pd.to_numeric(
        df['id'],
        errors='coerce'
    )
    filtered_df=df[
        id_values==int(query)
    ].copy()

Text searches use case-insensitive matching:

names=df['name'].fillna('').astype(str)

mask=names.str.contains(
    word,
    case=False,
    na=False,
    regex=False
)

Multiple search words are combined with a Boolean mask rather than repeatedly appending or concatenating DataFrames.

Display Filtered Results in Treeview Top ↑

The Treeview is created once when the application starts.

Whenever the search changes, only its rows are replaced:

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

The filtered DataFrame is then inserted again.

This is better than creating another Treeview every time the user presses a key or deletes a row.

Map Treeview Items to Source DataFrame Rows Top ↑

The older application used the first value of a row as the Treeview item ID:

iid=v[0]

and later assumed that value was the DataFrame id.

This can fail when:

the first column is not an ID;
the ID is text rather than numeric;
duplicate first-column values exist;
the selected file has a completely different structure.

The revised application creates its own Treeview item IDs and stores a mapping to the actual source DataFrame index:

row_map={}

for display_no,(source_index,row) in enumerate(
    filtered_df.iterrows()
):
    iid=f'row_{display_no}'
    row_map[iid]=source_index

    tree.insert(
        '',
        tk.END,
        iid=iid,
        values=row.tolist()
    )

The Treeview ID and the business-data ID are now separate concepts.

Detect Treeview Row Selection Top ↑

The Treeview <<TreeviewSelect>> event runs a function whenever the selection changes:

tree.bind(
    '<<TreeviewSelect>>',
    collect_selection
)

The selected Treeview item is obtained with:

selection=tree.selection()

if not selection:
    return

selected_iid=selection[0]

This avoids assuming that a selection always exists.

Display Selected Row Details Top ↑

The row values can be read from the selected Treeview item:

values=tree.item(
    selected_iid,
    'values'
)

The program displays the values in a Label:

selected_var.set(
    'Selected: '+
    ' | '.join(
        map(
            str,
            values
        )
    )
)

The Delete Button remains disabled until a valid row has been selected.

Delete the Selected Row from the DataFrame Top ↑

Deleting selected Pandas DataFrame row from Tkinter Treeview

First use the Treeview item ID to find the source DataFrame index:

source_index=row_map.get(
    selected_iid
)

The selected row is then removed from the working source DataFrame using Pandas drop():

df=df.drop(
    index=source_index
).reset_index(
    drop=True
)

A confirmation dialog is shown before the deletion:

confirmed=messagebox.askyesno(
    'Delete row',
    'Delete the selected row from the working DataFrame?'
)

Why Delete from df Instead of Only filtered_df?

The older application deleted the selected row only from the filtered result:

df2.drop(...)

However, the next search rebuilt df2 from the original df. The deleted row could therefore return.

The revised flow is:

delete from df
     |
     v
run current search again
     |
     v
create new filtered_df
     |
     v
refresh Treeview

The row remains deleted throughout the current application session.

Refresh the Treeview after Deletion Top ↑

After deleting from the source DataFrame, call the search function again:

search_data()

If the current search still matches other rows, they remain visible. If the deleted row was the only match, the Treeview becomes empty and the result count becomes zero.

Save the Current Filtered Result Top ↑

The current filtered DataFrame can be saved using a Tkinter Save As dialog.

if file_path.lower().endswith(
    '.csv'
):
    filtered_df.to_csv(
        file_path,
        index=False
    )
else:
    filtered_df.to_excel(
        file_path,
        index=False
    )

This saves the records currently represented by the filtered DataFrame, including any in-memory deletion already made.

Copy the Current Result to Clipboard Top ↑

Pandas to_clipboard() copies the filtered DataFrame:

filtered_df.to_clipboard(
    index=False
)

A temporary message confirms the operation.

Add Treeview Scrollbars Top ↑

The original page added a vertical scrollbar when more than ten results were available. The revised application uses both directions.

y_scroll=ttk.Scrollbar(
    table_frame,
    orient='vertical',
    command=tree.yview
)

x_scroll=ttk.Scrollbar(
    table_frame,
    orient='horizontal',
    command=tree.xview
)

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

Complete Search, Select and Delete Application Top ↑

import os
import tkinter as tk
from tkinter import filedialog
from tkinter import messagebox
from tkinter import ttk

import pandas as pd

STOP_WORDS={
    'to',
    'and',
    'or'
}

df=None
filtered_df=None

row_map={}
column_map={}

selected_iid=None

root=tk.Tk()

root.title(
    'DataFrame Search and Delete - plus2net'
)

root.geometry(
    '980x620'
)

root.minsize(
    760,
    480
)

root.columnconfigure(
    0,
    weight=1
)

root.rowconfigure(
    4,
    weight=1
)

file_var=tk.StringVar(
    value='No data file selected'
)

search_var=tk.StringVar()

result_var=tk.StringVar(
    value='Matching records: 0'
)

selected_var=tk.StringVar(
    value='No row selected'
)

status_var=tk.StringVar(
    value='Select an Excel or CSV file.'
)

def clear_tree():

global selected_iid

for item in tree.get_children():

tree.delete(
            item
        )

row_map.clear()

selected_iid=None

selected_var.set(
        'No row selected'
    )

delete_button.config(
        state=tk.DISABLED
    )

def configure_columns():

global column_map

if df is None:

tree[
            'columns'
        ]=()

column_map={}

return

column_ids=[
        f'c{i}'
        for i in range(
            len(df.columns)
        )
    ]

column_map=dict(
        zip(
            column_ids,
            df.columns
        )
    )

tree[
        'columns'
    ]=column_ids

for column_id,column_name in column_map.items():

tree.column(
            column_id,
            width=120,
            minwidth=80,
            anchor='w',
            stretch=False
        )

tree.heading(
            column_id,
            text=str(
                column_name
            )
        )

def refresh_rows():

clear_tree()

if filtered_df is None:

result_var.set(
            'Matching records: 0'
        )

return

for display_no,(
        source_index,
        row
    ) in enumerate(
        filtered_df.iterrows()
    ):

iid=f'row_{display_no}'

row_map[
            iid
        ]=source_index

values=[]

for value in row.tolist():

if pd.isna(value):

values.append(
                    ''
                )

else:

values.append(
                    value
                )

tree.insert(
            '',
            tk.END,
            iid=iid,
            values=values
        )

result_var.set(
        f'Matching records: '
        f'{len(filtered_df)}'
    )

def browse_file():

global df
    global filtered_df

file_path=filedialog.askopenfilename(
        title='Select Excel or CSV file',
        filetypes=[
            (
                'Excel files',
                '*.xlsx *.xls'
            ),
            (
                'CSV files',
                '*.csv'
            ),
            (
                'All files',
                '*.*'
            )
        ]
    )

if not file_path:

status_var.set(
            'No file selected.'
        )

return

extension=os.path.splitext(
        file_path
    )[1].lower()

try:

if extension=='.csv':

new_df=pd.read_csv(
                file_path
            )

elif extension in (
            '.xlsx',
            '.xls'
        ):

new_df=pd.read_excel(
                file_path
            )

else:

status_var.set(
                'Select an Excel or CSV file.'
            )

return

except (
        OSError,
        UnicodeDecodeError,
        ValueError,
        ImportError,
        pd.errors.ParserError,
        pd.errors.EmptyDataError
    ) as e:

status_var.set(
            f'Unable to read file: {e}'
        )

return

df=new_df.reset_index(
        drop=True
    )

filtered_df=df.copy()

file_var.set(
        file_path
    )

search_var.set(
        ''
    )

configure_columns()

refresh_rows()

save_button.config(
        state=tk.NORMAL
    )

copy_button.config(
        state=tk.NORMAL
    )

status_var.set(
        f'Loaded {df.shape[0]} rows and '
        f'{df.shape[1]} columns.'
    )

def search_data(event=None):

global filtered_df

if df is None:

status_var.set(
            'Select a data file first.'
        )

return

query=search_var.get().strip()

if not query:

filtered_df=df.copy()

refresh_rows()

status_var.set(
            'Showing all records.'
        )

return

if (
        query.isdigit()
        and 'id' in df.columns
    ):

id_values=pd.to_numeric(
            df['id'],
            errors='coerce'
        )

filtered_df=df[
            id_values==int(
                query
            )
        ].copy()

else:

words=[
            word
            for word in query.split()
            if word.lower()
            not in STOP_WORDS
        ]

if not words:

filtered_df=df.copy()

else:

if 'name' in df.columns:

search_columns=[
                    'name'
                ]

else:

search_columns=list(
                    df.columns
                )

mask=pd.Series(
                False,
                index=df.index
            )

for word in words:

word_mask=pd.Series(
                    False,
                    index=df.index
                )

for column in search_columns:

values=df[
                        column
                    ].fillna(
                        ''
                    ).astype(
                        str
                    )

word_mask |= values.str.contains(
                        word,
                        case=False,
                        na=False,
                        regex=False
                    )

mask |= word_mask

filtered_df=df[
                mask
            ].copy()

refresh_rows()

status_var.set(
        f'Found {len(filtered_df)} '
        f'matching record(s).'
    )

def collect_selection(event=None):

global selected_iid

selection=tree.selection()

if not selection:

selected_iid=None

selected_var.set(
            'No row selected'
        )

delete_button.config(
            state=tk.DISABLED
        )

return

selected_iid=selection[0]

values=tree.item(
        selected_iid,
        'values'
    )

selected_var.set(
        'Selected: '+
        ' | '.join(
            map(
                str,
                values
            )
        )
    )

delete_button.config(
        state=tk.NORMAL
    )

def delete_selected():

global df
    global selected_iid

if df is None:

status_var.set(
            'No DataFrame is loaded.'
        )

return

if selected_iid is None:

status_var.set(
            'Select a row to delete.'
        )

return

source_index=row_map.get(
        selected_iid
    )

if source_index is None:

status_var.set(
            'Unable to identify the selected row.'
        )

return

values=tree.item(
        selected_iid,
        'values'
    )

preview=' | '.join(
        map(
            str,
            values
        )
    )

confirmed=messagebox.askyesno(
        'Delete row',
        'Delete this row from the working '
        'DataFrame?\n\n'+preview
    )

if not confirmed:

status_var.set(
            'Delete cancelled.'
        )

return

df=df.drop(
        index=source_index
    ).reset_index(
        drop=True
    )

selected_iid=None

search_data()

status_var.set(
        'Selected row deleted from the '
        'working DataFrame. '
        'The original file has not been changed.'
    )

def save_result():

if filtered_df is None:

status_var.set(
            'There is no result to save.'
        )

return

file_path=filedialog.asksaveasfilename(
        title='Save filtered DataFrame',
        filetypes=[
            (
                'Excel file',
                '*.xlsx'
            ),
            (
                'CSV file',
                '*.csv'
            )
        ],
        defaultextension='.xlsx'
    )

if not file_path:

status_var.set(
            'Save cancelled.'
        )

return

try:

if file_path.lower().endswith(
            '.csv'
        ):

filtered_df.to_csv(
                file_path,
                index=False
            )

else:

filtered_df.to_excel(
                file_path,
                index=False
            )

except (
        OSError,
        ValueError,
        ImportError
    ) as e:

status_var.set(
            f'Unable to save result: {e}'
        )

return

status_var.set(
        f'Saved {len(filtered_df)} '
        f'record(s) to '
        f'{os.path.basename(file_path)}'
    )

def clear_copy_message():

status_var.set(
        ''
    )

def copy_result():

if filtered_df is None:

status_var.set(
            'There is no result to copy.'
        )

return

try:

filtered_df.to_clipboard(
            index=False
        )

except Exception as e:

status_var.set(
            f'Unable to copy DataFrame: {e}'
        )

return

status_var.set(
        'Filtered DataFrame copied to clipboard.'
    )

root.after(
        3000,
        clear_copy_message
    )

top_frame=ttk.Frame(
    root,
    padding=10
)

top_frame.grid(
    row=0,
    column=0,
    sticky='ew'
)

top_frame.columnconfigure(
    1,
    weight=1
)

browse_button=ttk.Button(
    top_frame,
    text='Select Data File',
    command=browse_file
)

browse_button.grid(
    row=0,
    column=0,
    padx=(0,10)
)

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

search_frame=ttk.Frame(
    root,
    padding=(10,5)
)

search_frame.grid(
    row=1,
    column=0,
    sticky='ew'
)

ttk.Label(
    search_frame,
    text='Search:'
).grid(
    row=0,
    column=0,
    padx=(0,5)
)

search_entry=ttk.Entry(
    search_frame,
    textvariable=search_var,
    width=30
)

search_entry.grid(
    row=0,
    column=1,
    padx=5
)

search_button=ttk.Button(
    search_frame,
    text='Search',
    command=search_data
)

search_button.grid(
    row=0,
    column=2,
    padx=5
)

save_button=ttk.Button(
    search_frame,
    text='Save Result',
    command=save_result,
    state=tk.DISABLED
)

save_button.grid(
    row=0,
    column=3,
    padx=5
)

copy_button=ttk.Button(
    search_frame,
    text='Copy',
    command=copy_result,
    state=tk.DISABLED
)

copy_button.grid(
    row=0,
    column=4,
    padx=5
)

delete_button=ttk.Button(
    search_frame,
    text='Delete Selected',
    command=delete_selected,
    state=tk.DISABLED
)

delete_button.grid(
    row=0,
    column=5,
    padx=5
)

info_frame=ttk.Frame(
    root,
    padding=(10,3)
)

info_frame.grid(
    row=2,
    column=0,
    sticky='ew'
)

ttk.Label(
    info_frame,
    textvariable=result_var,
    font=('Arial',10,'bold')
).grid(
    row=0,
    column=0,
    sticky='w'
)

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

table_frame=ttk.Frame(
    root,
    padding=(10,5)
)

table_frame.grid(
    row=4,
    column=0,
    sticky='nsew'
)

table_frame.columnconfigure(
    0,
    weight=1
)

table_frame.rowconfigure(
    0,
    weight=1
)

tree=ttk.Treeview(
    table_frame,
    show='headings',
    selectmode='browse'
)

tree.grid(
    row=0,
    column=0,
    sticky='nsew'
)

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=920
).grid(
    row=5,
    column=0,
    sticky='w',
    padx=10,
    pady=(5,10)
)

tree.bind(
    '<<TreeviewSelect>>',
    collect_selection
)

search_entry.bind(
    '<KeyRelease>',
    search_data
)

root.mainloop()

Video: Select and Delete a DataFrame Row Top ↑

Selecting and Deleting Row from DataFrame and Showing Result in Treeview

Why We Do Not Use the DataFrame ID as Treeview iid Top ↑

For the sample student data, the id column happens to contain unique values. That made code such as this appear to work:

trv.insert(
    '',
    'end',
    iid=v[0],
    values=v
)

However, Treeview is a display widget and the DataFrame may come from many different sources. The first column should not automatically become the widget's identity.

The revised version maintains:

Treeview iid
     |
     v
row_map
     |
     v
source DataFrame index

This lets the program delete the exact selected row regardless of the actual CSV or Excel column structure.

What Happens after a Row Is Deleted? Top ↑

Suppose the source DataFrame contains:

1  John Deo
2  Max Ruin
3  Arnold
4  Krish Star

A search for:

Max

displays one row. After selecting that row and clicking Delete Selected:

df
 |
 +-- John Deo
 +-- Arnold
 +-- Krish Star

The current search is run again and now finds zero matching records.

Clearing the search displays all remaining working DataFrame rows. The deleted Max row does not return.

The source Excel or CSV file is still unchanged. To create a new file containing the modified result, use the Save Result option.

Frequently Asked Questions Top ↑

Q1: How do I detect a selected Treeview row?

Bind <<TreeviewSelect>> to a function and use tree.selection() to get the currently selected Treeview item.

Q2: How are selected row values displayed?

Use tree.item(selected_iid, 'values') to read the values stored in the selected Treeview row.

Q3: Why not use the first DataFrame column as Treeview iid?

The first column may not be unique or may not be an ID. The revised application creates its own Treeview identifiers and maps them to DataFrame indexes.

Q4: Why delete the row from the source DataFrame instead of only the filtered DataFrame?

The filtered DataFrame is recreated whenever the search changes. Deleting from the source working DataFrame prevents the deleted row from returning during the same application session.

Q5: Does Delete Selected modify the original Excel or CSV file?

No. It modifies only the DataFrame in memory. The original file remains unchanged unless the user explicitly saves modified data to a file.

Q6: Why confirm before deleting?

A confirmation dialog prevents an accidental row-selection click followed by an unintended deletion.

Q7: Can the remaining search result be saved after deletion?

Yes. The current filtered DataFrame can be saved as Excel or CSV or copied to the clipboard.

DataFrame Search Select DataFrame Columns

Insert MySQL Row and Add to Treeview MySQL Records MySQL Pagination Delete MySQL Records

Tkinter Projects Tkinter Pandas Projects

Python Tkinter Pandas Treeview drop() Label 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: