Python Pandas: How to Drop All Rows from a DataFrame (Emptying Data)
There are situations in data manipulation with Pandas where you might need to remove all rows from a DataFrame, effectively emptying it of its data while potentially keeping its column structure intact. This could be for resetting a DataFrame for new data, clearing intermediate results, or initializing an empty structure.
This guide explains several common and effective methods to drop all rows from a Pandas DataFrame.
The Goal: Emptying a DataFrame of Rows
Our objective is to take an existing Pandas DataFrame and remove all of its rows, leaving behind an empty DataFrame that (usually) retains the original column names and their data types, but has no data records.
Example DataFrame
import pandas as pd
data = {
'ProductID': ['A101', 'B202', 'C303', 'D404'],
'ProductName': ['Laptop', 'Mouse', 'Keyboard', 'Monitor'],
'Category': ['Electronics', 'Accessory', 'Accessory', 'Electronics'],
'Price': [1200, 25, 75, 300]
}
df_original = pd.DataFrame(data)
print("Original DataFrame:")
print(df_original)
Output:
Original DataFrame:
ProductID ProductName Category Price
0 A101 Laptop Electronics 1200
1 B202 Mouse Accessory 25
2 C303 Keyboard Accessory 75
3 D404 Monitor Electronics 300
Method 1: Using DataFrame.drop(df.index) (Recommended)
The DataFrame.drop() method is primarily used to remove specified labels from rows or columns. By passing the DataFrame's entire index to it, you instruct Pandas to drop all rows.
Explanation
import pandas as pd
df = pd.DataFrame({
'ProductID': ['A101', 'B202', 'C303', 'D404'],
'ProductName': ['Laptop', 'Mouse', 'Keyboard', 'Monitor'],
'Category': ['Electronics', 'Accessory', 'Accessory', 'Electronics'],
'Price': [1200, 25, 75, 300]
})
# df.index contains all row labels (e.g., RangeIndex(start=0, stop=4, step=1))
print(f"DataFrame index: {df.index.tolist()}\n")
# ✅ Drop all rows by passing the DataFrame's index
df_emptied_drop = df.drop(df.index) # By default, drop operates on rows (axis=0)
print("DataFrame after df.drop(df.index):")
print(df_emptied_drop)
Output:
DataFrame index: [0, 1, 2, 3]
DataFrame after df.drop(df.index):
Empty DataFrame
Columns: [ProductID, ProductName, Category, Price]
Index: []
df.index: Returns an Index object containing all the row labels of the DataFrame.df.drop(labels, axis=0): Whenaxis=0(the default),labelsrefers to row labels to be dropped. Passingdf.indexmeans "drop all rows identified by these labels."- By default,
drop()returns a new DataFrame with the rows removed. The originaldfis unchanged unlessinplace=Trueis used or the result is reassigned.
Using inplace=True
To modify the DataFrame directly without creating a new one:
import pandas as pd
df_inplace_example = pd.DataFrame({
'ProductID': ['A101', 'B202', 'C303', 'D404'],
'ProductName': ['Laptop', 'Mouse', 'Keyboard', 'Monitor'],
'Category': ['Electronics', 'Accessory', 'Accessory', 'Electronics'],
'Price': [1200, 25, 75, 300]
})
print("DataFrame before inplace drop:")
print(df_inplace_example)
print()
# ✅ Drop all rows in-place
df_inplace_example.drop(df_inplace_example.index, inplace=True)
print("DataFrame after df.drop(df.index, inplace=True):")
print(df_inplace_example)
Output:
DataFrame before inplace drop:
ProductID ProductName Category Price
0 A101 Laptop Electronics 1200
1 B202 Mouse Accessory 25
2 C303 Keyboard Accessory 75
3 D404 Monitor Electronics 300
DataFrame after df.drop(df.index, inplace=True):
Empty DataFrame
Columns: [ProductID, ProductName, Category, Price]
Index: []
Now df_inplace_example itself is empty.
Method 2: Using Slicing (df.iloc[0:0] or df[0:0])
You can select an empty slice of rows. This effectively creates a new DataFrame with the same columns but no rows.
import pandas as pd
df = pd.DataFrame({
'ProductID': ['A101', 'B202', 'C303', 'D404'],
'ProductName': ['Laptop', 'Mouse', 'Keyboard', 'Monitor'],
'Category': ['Electronics', 'Accessory', 'Accessory', 'Electronics'],
'Price': [1200, 25, 75, 300]
})
# ✅ Select an empty slice using .iloc
df_emptied_iloc = df.iloc[0:0]
# Or, more concisely using direct slicing (which often implies .iloc for integer slices)
# df_emptied_slice = df[0:0]
print("DataFrame after df.iloc[0:0]:")
print(df_emptied_iloc)
Output:
DataFrame after df.iloc[0:0]:
Empty DataFrame
Columns: [ProductID, ProductName, Category, Price]
Index: []
df.iloc[0:0](ordf[0:0]) selects rows starting at position 0 up to (but not including) position 0, resulting in an empty selection of rows while preserving the column structure.- This method creates a new empty DataFrame; assign it back if you want to modify the original variable (e.g.,
df = df.iloc[0:0]).
Method 3: Re-instantiating with Same Columns (pd.DataFrame(columns=df.columns))
You can create a brand new, empty DataFrame that has the same column names and dtypes as the original.
import pandas as pd
df = pd.DataFrame({
'ProductID': ['A101', 'B202', 'C303', 'D404'],
'ProductName': ['Laptop', 'Mouse', 'Keyboard', 'Monitor'],
'Category': ['Electronics', 'Accessory', 'Accessory', 'Electronics'],
'Price': [1200, 25, 75, 300]
})
print(f"Original columns: {df.columns}\n")
# ✅ Create a new empty DataFrame with the same columns
df_emptied_recreate = pd.DataFrame(columns=df.columns)
print("DataFrame after pd.DataFrame(columns=df.columns):")
print(df_emptied_recreate)
print()
print("Dtypes of new empty DataFrame:")
print(df_emptied_recreate.dtypes) # Dtypes are preserved (as object initially if no data)
Output:
Original columns: Index(['ProductID', 'ProductName', 'Category', 'Price'], dtype='object')
DataFrame after pd.DataFrame(columns=df.columns):
Empty DataFrame
Columns: [ProductID, ProductName, Category, Price]
Index: []
Dtypes of new empty DataFrame:
ProductID object
ProductName object
Category object
Price object
dtype: object
df.columns: Returns an Index object containing the column names of the original DataFrame.pd.DataFrame(columns=...): Creates a new DataFrame with the specified column names and an empty index (no rows). The dtypes will beobjectif no data is provided to infer them, but the structure matches.
If you also want to completely remove the columns and have a truly empty DataFrame (no rows, no columns):
df_completely_empty = pd.DataFrame() # Or pd.DataFrame(None)
print("Completely empty DataFrame:")
print(df_completely_empty)
Consideration: Dropping Rows vs. Creating an Empty DataFrame
df.drop(df.index)and slicing (df.iloc[0:0]): These methods operate on an existing DataFrame to remove its rows.dropcan modify in-place. Slicing always creates a new view/copy which then needs to be reassigned. They generally preserve column dtypes accurately because they start from an existing populated structure.pd.DataFrame(columns=df.columns): This creates a new empty DataFrame. If you reassigndf = pd.DataFrame(columns=df.columns), the original DataFrame object is replaced. The dtypes of the columns in the new empty DataFrame will beobjectuntil data is added, unless dtypes are explicitly provided during creation (which is more complex).
For simply clearing rows while keeping the column structure and their original dtypes as best as possible, df.drop(df.index, inplace=True) or df = df.iloc[0:0] are often preferred.
Conclusion
To drop all rows from a Pandas DataFrame, effectively emptying its data content:
df.drop(df.index, inplace=True): This is a common and explicit way to remove all rows by targeting their index labels. Useinplace=Trueto modify the DataFrame directly.df = df.iloc[0:0](ordf = df[0:0]): Slicing to select an empty range of rows is a concise way to get an empty DataFrame with the same columns. This creates a new DataFrame.df = pd.DataFrame(columns=df.columns): Re-instantiating a new DataFrame with the original column names creates an empty structure. This also creates a new DataFrame.
Choose the method that best suits your workflow, considering whether you need to modify the DataFrame in-place or create a new empty one. df.drop(df.index) is often favored for its explicit intent.