# How to Use Pandas Drop Columns with an Integer Index: A Complete Guide > Learn how to use pandas drop columns with an integer index. Convert positional indices to labels for effective column removal in your DataFrames. Get the complete guide. - Repository: [pandas/pandas](https://github.com/pandas-dev/pandas) - Tags: how-to-guide - Published: 2026-02-14 --- **To drop a column by integer position in pandas, convert the position to a label using `df.columns[pos]` before passing it to `df.drop()`, as the `drop()` method expects column labels rather than positional indices.** When working with the `pandas-dev/pandas` repository, you’ll often need to remove specific columns from a DataFrame using their numerical position. While `pandas drop columns` operations are straightforward with label names, removing columns by integer index requires understanding how the underlying `drop()` method resolves its arguments. ## Why Pandas Drop Columns Requires Labels, Not Positions The `DataFrame.drop` method is implemented in [`pandas/core/generic.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/generic.py) as part of the shared `NDFrame` base class. When you call `df.drop(labels, axis=1)`, the method forwards to `NDFrame.drop` at line 4566, which handles the generic logic for all pandas data structures. The critical detail is that `drop()` performs **label-based** resolution, not positional indexing. When you pass an integer to `drop()`, pandas searches for a column whose actual label equals that integer value, not the column occupying that ordinal position. This behavior is defined in the label resolution logic within [`pandas/core/indexes/base.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/indexes/base.py) around line 7112, where `Index.drop` removes specified labels from the axis. ## How to Drop a Column by Integer Index in Pandas To correctly use `pandas drop columns` with an integer position, you must first translate the position into its corresponding label using the `.columns` accessor. ### Step 1: Convert Position to Label Access the column label at your desired integer position: ```python col_label = df.columns[1] # Gets the label of the second column ``` ### Step 2: Call Drop with the Label Pass the retrieved label to `drop()` with `axis=1`: ```python df = df.drop(col_label, axis=1) ``` You can also chain these operations for concise code: ```python df = df.drop(df.columns[1], axis=1) ``` ## Dropping Multiple Columns by Integer Index To remove several columns at specific positions, pass a list of positions to the columns indexer: ```python positions = [0, 2, 3] cols_to_drop = df.columns[positions] df = df.drop(cols_to_drop, axis=1) ``` This approach works because `df.columns[positions]` returns an `Index` object containing the labels at those positions, which `drop()` can then process correctly. ## Under the Hood: How Pandas Drop Columns Works The implementation spans three critical files in the `pandas-dev/pandas` repository: 1. **[`pandas/core/frame.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/frame.py)** (lines 5917-5955): The concrete `DataFrame` class defines its specific `drop` method, which handles column-specific validation before delegating to the generic implementation. 2. **[`pandas/core/generic.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/generic.py)** (lines 4566-4604): The `NDFrame.drop` method contains the core logic for axis determination and label resolution. This is where `axis=1` is interpreted as "columns" and the method prepares the labels for removal. 3. **[`pandas/core/indexes/base.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/indexes/base.py)** (lines 7112-7125): The `Index.drop` method performs the actual label removal from the column index. It validates that the labels exist and constructs the new index excluding those labels. Understanding this flow explains why integer positions must be converted to labels before reaching the `Index.drop` stage, as the index operations are strictly label-based. ## Common Mistakes to Avoid - **Passing integers directly**: `df.drop(0, axis=1)` attempts to drop a column literally named `0`, not the first column. - **Confusing `axis` values**: Remember that `axis=1` refers to columns, while `axis=0` refers to rows. - **Modifying in-place unexpectedly**: Unless using `inplace=True`, `drop()` returns a new DataFrame. Always assign the result back to your variable. ## Summary - **`pandas drop columns`** operations require **labels**, not integer positions. - Convert positions to labels using `df.columns[pos]` before calling `drop()`. - The `drop()` method is implemented in [`pandas/core/generic.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/generic.py) with label resolution handled in [`pandas/core/indexes/base.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/indexes/base.py). - For multiple columns, pass a list of positions to `df.columns[]` to retrieve all labels at once. ## Frequently Asked Questions ### Can I pass an integer directly to df.drop() to remove a column by position? No. When you pass an integer to `df.drop()`, pandas searches for a column whose **label** equals that integer value, not the column at that ordinal position. To drop by position, you must first convert the integer to a label using `df.columns[pos]`. ### What happens if my column labels are themselves integers? If your DataFrame has integer column labels (e.g., columns named `0`, `1`, `2`), then passing an integer to `drop()` will match those labels. However, this is distinct from positional indexing. If you want the third column regardless of its name, you still need to use `df.columns[2]` to ensure you're accessing by position. ### Is there a performance difference between dropping by label vs position? No significant performance difference exists because dropping by position requires converting the position to a label first (via `df.columns[pos]`), which is an O(1) indexing operation. The actual `drop()` operation in [`pandas/core/indexes/base.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/indexes/base.py) performs label-based filtering regardless of how you obtained the label. ### How do I drop the last column using an integer index? Use negative indexing to access the last position, then pass it to `drop()`: ```python df = df.drop(df.columns[-1], axis=1) ``` This works because `df.columns` supports standard Python negative indexing, where `-1` refers to the final element.