Tkinter Checkbuttons to Select Pandas DataFrame Columns

Q: How can Tkinter display one Checkbutton for each DataFrame column?

Loop through df.columns, create one BooleanVar for each column and connect that variable to a dynamically created Checkbutton.

Q: How do I create a DataFrame containing only selected columns?

Pass the selected column list to the DataFrame as df[selected_columns].

Q: Why preserve the original DataFrame column order?

Using df.columns while collecting checked values ensures selected columns remain in the same order as the source data.

Selecting Pandas DataFrame columns using Tkinter Checkbuttons

This project uses dynamic Tkinter Checkbuttons to let the user choose which columns of a Pandas DataFrame should be used or displayed.

The user first selects a CSV or Excel file. Pandas creates the DataFrame, one Checkbutton is created for each column, and the checked column names are collected into a Python list.

The revised version also uses that list to create a smaller DataFrame containing only the selected columns and displays the result in Treeview.

CSV / Excel
     |
     v
Pandas DataFrame
     |
     v
DataFrame columns
     |
     v
Tkinter Checkbuttons
     |
     v
Selected column list
     |
     v
df[selected_columns]
     |
     v
Treeview preview

Show Table of Contents

Main Functions
Select CSV or Excel File
Create Dynamic Checkbuttons
Create the Selected Column List
Create a DataFrame with Selected Columns
Preview Selected Columns in Treeview
Select All and Clear All
Complete Program
Video Tutorial
Continue the DataFrame Project
FAQs

Main Functions in the Project Top ↑

The application is divided into a few clear tasks:

select_file(): select a CSV or Excel file and create the DataFrame.
create_checkbuttons(): create one Checkbutton for each DataFrame column.
update_selection(): collect the checked column names and create the selected DataFrame.
configure_treeview(): create Treeview headings for the selected columns.
refresh_treeview(): display the selected DataFrame rows.
select_all(): check all available DataFrame columns.
clear_all(): clear all selected columns.

Select a CSV or Excel File Top ↑

Use the Tkinter file browser to select CSV or Excel data.

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

The file extension determines whether Pandas read_csv() or read_excel() is used.

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

if extension=='.csv':
    df=pd.read_csv(file_path)
elif extension in ('.xlsx','.xls'):
    df=pd.read_excel(file_path)

If the file dialog is cancelled or the file cannot be read, the application displays a status message instead of continuing with an invalid DataFrame.

Create Dynamic Checkbuttons for DataFrame Columns Top ↑

After the DataFrame is loaded, its column names are available through:

list(df.columns)

A dictionary stores one BooleanVar for each column:

column_vars={}

for column_name in df.columns:
    column_vars[column_name]=tk.BooleanVar(
        value=False
    )

The BooleanVar is connected to a Checkbutton:

check=ttk.Checkbutton(
    columns_frame,
    text=str(column_name),
    variable=column_vars[column_name],
    command=update_selection
)

Whenever a Checkbutton changes, update_selection() runs.

Remove Previous Checkbuttons

If another file is selected, the previous file may contain completely different columns. All old Checkbuttons are removed first:

for widget in columns_frame.winfo_children():
    widget.destroy()

Using a dedicated frame is cleaner than searching for widgets by a specific grid row.

Create a List of Selected Columns Top ↑

The checked columns can be collected with a list comprehension:

selected_columns=[
    column_name
    for column_name in df.columns
    if column_vars[column_name].get()
]

Iterating through df.columns preserves the original DataFrame column order.

For a DataFrame containing:

id
name
class
mark
gender

if the user selects:

name
mark
gender

the resulting Python list is:

[
    'name',
    'mark',
    'gender'
]

The selected names are also shown in a Tkinter Label.

Create a DataFrame with Selected Columns Top ↑

The selected list can be passed directly to the source DataFrame:

selected_df=df[
    selected_columns
].copy()

If the source DataFrame has:

id | name | class | mark | gender

and the user selects:

name
mark

then selected_df contains only:

name | mark

This is the practical purpose of collecting the selected column list. It can later be used for filtering, exporting, plotting or database operations.

Preview Selected Columns in Treeview Top ↑

The Treeview is created once. Its column structure changes whenever the Checkbutton selection changes.

Safe internal Treeview column IDs are generated:

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

The original DataFrame column names remain visible as headings.

for column_id,column_name in zip(
    column_ids,
    selected_columns
):
    tree.heading(
        column_id,
        text=str(column_name)
    )

Rows are then added from the selected DataFrame:

for row in selected_df.itertuples(
    index=False,
    name=None
):
    tree.insert(
        '',
        tk.END,
        values=row
    )

Select All and Clear All Columns Top ↑

For DataFrames with several columns, selecting every Checkbutton individually is unnecessary.

Select All sets every BooleanVar to True:

for variable in column_vars.values():
    variable.set(
        True
    )

update_selection()

Clear All performs the opposite:

for variable in column_vars.values():
    variable.set(
        False
    )

update_selection()

The Treeview preview is cleared when no columns are selected.

Complete Tkinter Column Selection Program Top ↑

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

import pandas as pd

CHECKS_PER_ROW=4

df=None
selected_df=None

column_vars={}

root=tk.Tk()

root.title(
    'Select DataFrame Columns - plus2net'
)

root.geometry(
    '900x620'
)

root.minsize(
    720,
    500
)

root.columnconfigure(
    0,
    weight=1
)

root.rowconfigure(
    4,
    weight=1
)

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

selected_var=tk.StringVar(
    value='Selected columns: none'
)

details_var=tk.StringVar(
    value='Rows: 0   Selected columns: 0'
)

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

def clear_tree():

for item in tree.get_children():

tree.delete(
            item
        )

def configure_treeview(
    selected_columns
):

clear_tree()

if not selected_columns:

tree[
            'columns'
        ]=()

return

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

tree[
        'columns'
    ]=column_ids

for column_id,column_name in zip(
        column_ids,
        selected_columns
    ):

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

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

def refresh_treeview():

clear_tree()

if selected_df is None:

return

for row in selected_df.itertuples(
        index=False,
        name=None
    ):

values=[]

for value in row:

if pd.isna(value):

values.append(
                    ''
                )

else:

values.append(
                    value
                )

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

def update_selection():

global selected_df

if df is None:

selected_df=None

selected_var.set(
            'Selected columns: none'
        )

details_var.set(
            'Rows: 0   Selected columns: 0'
        )

configure_treeview(
            []
        )

return

selected_columns=[
        column_name
        for column_name in df.columns
        if column_vars[
            column_name
        ].get()
    ]

if not selected_columns:

selected_df=None

selected_var.set(
            'Selected columns: none'
        )

details_var.set(
            f'Rows: {df.shape[0]}   '
            'Selected columns: 0'
        )

configure_treeview(
            []
        )

status_var.set(
            'Select one or more columns.'
        )

return

selected_df=df[
        selected_columns
    ].copy()

selected_var.set(
        'Selected columns: '+
        ', '.join(
            map(
                str,
                selected_columns
            )
        )
    )

details_var.set(
        f'Rows: {selected_df.shape[0]}   '
        f'Selected columns: '
        f'{selected_df.shape[1]}'
    )

configure_treeview(
        selected_columns
    )

refresh_treeview()

status_var.set(
        f'{len(selected_columns)} '
        'column(s) selected.'
    )

def create_checkbuttons():

global column_vars

for widget in columns_frame.winfo_children():

widget.destroy()

column_vars={}

if df is None:

return

for index,column_name in enumerate(
        df.columns
    ):

variable=tk.BooleanVar(
            value=False
        )

column_vars[
            column_name
        ]=variable

row=index//CHECKS_PER_ROW

column=index%CHECKS_PER_ROW

check=ttk.Checkbutton(
            columns_frame,
            text=str(
                column_name
            ),
            variable=variable,
            command=update_selection
        )

check.grid(
            row=row,
            column=column,
            sticky='w',
            padx=8,
            pady=4
        )

def select_all():

if df is None:
        return

for variable in column_vars.values():

variable.set(
            True
        )

update_selection()

def clear_all():

if df is None:
        return

for variable in column_vars.values():

variable.set(
            False
        )

update_selection()

def select_file():

global df
    global selected_df

file_path=filedialog.askopenfilename(
        title='Select CSV or Excel file',
        filetypes=[
            (
                'CSV files',
                '*.csv'
            ),
            (
                'Excel files',
                '*.xlsx *.xls'
            ),
            (
                '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 a CSV or Excel 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

selected_df=None

file_var.set(
        file_path
    )

create_checkbuttons()

selected_var.set(
        'Selected columns: none'
    )

details_var.set(
        f'Rows: {df.shape[0]}   '
        'Selected columns: 0'
    )

configure_treeview(
        []
    )

all_button.config(
        state=tk.NORMAL
    )

clear_button.config(
        state=tk.NORMAL
    )

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

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='Browse File',
    command=select_file
)

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

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

button_frame=ttk.Frame(
    root,
    padding=(10,2)
)

button_frame.grid(
    row=1,
    column=0,
    sticky='w'
)

all_button=ttk.Button(
    button_frame,
    text='Select All',
    command=select_all,
    state=tk.DISABLED
)

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

clear_button=ttk.Button(
    button_frame,
    text='Clear All',
    command=clear_all,
    state=tk.DISABLED
)

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

columns_frame=ttk.LabelFrame(
    root,
    text='DataFrame Columns',
    padding=8
)

columns_frame.grid(
    row=2,
    column=0,
    sticky='ew',
    padx=10,
    pady=5
)

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

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
)

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

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

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

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

root.mainloop()

Video: Select DataFrame Columns using Checkbuttons Top ↑

Listing Columns of DataFrame in Tkinter for User Selection

Why Use a Dictionary of BooleanVar Objects? Top ↑

Each column needs its own Tkinter variable:

column_vars[
    column_name
]=tk.BooleanVar()

The dictionary connects:

column name
     |
     v
BooleanVar
     |
     v
Checkbutton state

For example:

{
    'id': BooleanVar,
    'name': BooleanVar,
    'class': BooleanVar,
    'mark': BooleanVar
}

This makes it easy to identify which DataFrame columns are selected.

Why Not Use grid_slaves() to Find Old Checkbuttons? Top ↑

The original program used:

my_w.grid_slaves(3)

This depends on the dynamic widgets always being placed in a specific grid row.

The revised version places all dynamic Checkbuttons inside one dedicated frame:

columns_frame

Removing them is then straightforward:

for widget in columns_frame.winfo_children():
    widget.destroy()

Using the Selected Column List elsewhere Top ↑

The important output of this project is the Python list:

selected_columns

It can be used for many DataFrame operations.

Select Columns

df2=df[
    selected_columns
]

Save Only Selected Columns

df[
    selected_columns
].to_csv(
    'output.csv',
    index=False
)

Search Only Selected Columns

The list can also be integrated with our DataFrame search project so user searches are limited to the checked columns.

Display Only Selected Columns

The complete program on this page demonstrates this directly by rebuilding the Treeview view from:

selected_df=df[
    selected_columns
].copy()

Continue the Tkinter Pandas Project Top ↑

Combine column selection with DataFrame searching:

Search and Filter a DataFrame

Select and delete a matching Treeview row:

Select and Delete DataFrame Rows

Use the same DataFrame concepts with analytics CSV files:

Read Analytics CSV Data with Tkinter

Or apply DataFrame column sorting to directory information:

Directory Browser with Treeview Sorting

Frequently Asked Questions Top ↑

Q1: How can Tkinter display one Checkbutton for each DataFrame column?

Loop through df.columns, create one BooleanVar for each column and connect that variable to a dynamically created Checkbutton.

Q2: How do I get the names of all checked DataFrame columns?

Loop through the original DataFrame columns and include each column whose associated BooleanVar returns True.

Q3: How do I create a DataFrame containing only selected columns?

Pass the selected column list to the DataFrame as df[selected_columns].

Q4: Why preserve the original DataFrame column order?

Using df.columns while collecting checked values ensures selected columns remain in the same order as the source data.

Q5: What happens when another CSV or Excel file is opened?

The previous Checkbuttons are destroyed, the DataFrame is replaced, and a new set of Checkbuttons is generated from the new file's columns.

Q6: Can selected columns be displayed in Treeview?

Yes. The selected column list can create a smaller DataFrame, and its headings and rows can be displayed dynamically in Treeview.

Q7: Can the selected columns be exported?

Yes. Use the selected list with the DataFrame and then call methods such as to_csv() or other Pandas output methods.

DataFrame Search Select and Delete Rows Analytics CSV Project

Tkinter Projects Tkinter Pandas Projects

Python Tkinter Pandas Checkbutton DataFrame Treeview 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: