How To Delete Columns In R

8 min read

Deleting columns is one of the most fundamental data manipulation tasks in R. Which means r offers several approaches to achieve this, ranging from base R syntax that requires no dependencies to the expressive, pipe-friendly verbs of the tidyverse. Whether you are cleaning a messy dataset, removing sensitive information before sharing a file, or simply dropping irrelevant features before modeling, knowing the efficient ways to drop columns saves significant time and prevents frustration. Mastering these techniques allows you to shape your data frames precisely to fit your analytical needs Practical, not theoretical..

Understanding the Basics of Column Removal

Before diving into specific syntax, it helps to understand what "deleting" a column actually does in R. Because R is a functional language, most operations do not modify the original object in place unless explicitly told to do so. This leads to when you drop a column, you are typically creating a new data frame object that excludes the specified variables, leaving the original data frame untouched in the global environment. Think about it: this immutability is a safety feature; it prevents accidental data loss. In real terms, to make the change permanent, you must assign the result back to a variable (e. g., df <- df[ , -1]).

Not the most exciting part, but easily the most useful.

Columns can be identified for removal in three primary ways:

  1. In practice, By Index Position: Using the integer location (e. g., the 1st, 3rd, and 5th columns).
  2. Now, By Name: Using the exact character string of the column header (e. Worth adding: g. , "Age", "Salary"). Consider this: 3. By Condition/Pattern: Using helper functions to match patterns (e.Because of that, g. , all columns starting with "temp_" or ending with "_id").

Method 1: Base R Syntax (No Packages Required)

Base R provides strong tools for subsetting data frames using bracket notation [rows, columns]. This is the fastest method for small to medium datasets and requires zero external dependencies.

Dropping by Index Position

To remove columns by their numeric position, use negative integers inside the column slot of the bracket notation Most people skip this — try not to..

# Sample data frame
df <- data.frame(
  ID = 1:5,
  Name = c("Alice", "Bob", "Charlie", "David", "Eve"),
  Age = c(25, 30, 35, 40, 45),
  Salary = c(50000, 60000, 70000, 80000, 90000),
  Department = c("HR", "IT", "Finance", "IT", "HR")
)

# Delete the 1st column (ID) and 3rd column (Age)
# Note the comma before the negative vector: [rows, columns]
df_new <- df[ , -c(1, 3)]

# View result
print(df_new)

Critical Detail: The comma inside the brackets is mandatory. df[-c(1, 3)] without a comma attempts to subset rows (treating the data frame as a list), which often returns an error or unexpected results. Always use df[ , -c(indices)] It's one of those things that adds up..

Dropping by Name

Removing columns by name is often safer than by index because column order can change during analysis pipelines. In base R, you use the %in% operator combined with the negation operator ! (logical NOT) and the names() function Simple as that..

# Define columns to drop
cols_to_drop <- c("Salary", "Department")

# Subset: Keep columns where names are NOT in the drop list
df_new <- df[ , !names(df) %in% cols_to_drop]

print(df_new)

This reads logically: "Select all rows, and select columns where the name is not in the cols_to_drop vector."

The subset() Function Alternative

Base R also includes the subset() function, which many find more readable for column selection because it allows non-standard evaluation (using bare column names without quotes).

# Keep everything EXCEPT Salary and Department
# Note the minus sign before the c() vector
df_new <- subset(df, select = -c(Salary, Department))

While convenient, subset() is generally discouraged for programming inside functions or packages due to its non-standard evaluation, but it is perfectly fine for interactive scripting.

Method 2: The dplyr Approach (The Tidyverse Standard)

If you work within the tidyverse ecosystem, the dplyr package provides the select() verb. But this is widely considered the most readable and expressive way to manipulate columns. It integrates easily with the pipe operator (|> or %>%).

Basic Dropping with select()

The syntax is intuitive: select(data, -columns_to_remove).

library(dplyr)

# Drop specific columns by name
df_new <- df |>
  select(-Salary, -Department)

# Or using a vector of names
cols_to_drop <- c("Salary", "Department")
df_new <- df |>
  select(-all_of(cols_to_drop))

Using all_of() is a best practice when passing a character vector of column names; it throws a clear error if a column doesn't exist, preventing silent failures.

Dropping by Position with dplyr

You can also drop by index position using the minus sign.

# Drop 1st and 3rd columns
df_new <- df |>
  select(-1, -3)

Advanced Selection Helpers (The Real Power)

The true strength of dplyr::select() lies in its selection helpers (tidyselect syntax). These allow you to drop columns based on patterns without knowing exact names or positions.

Helper Function Description Example Usage
starts_with() Matches columns beginning with a prefix. select(-ends_with("_id"))
contains() Matches columns containing a literal string. select(-starts_with("temp_"))
ends_with() Matches columns ending with a suffix. , type). select(-num_range("col", 1:5))
where() Selects columns based on a function (e.In practice, select(-contains("backup"))
matches() Matches columns using a regular expression. Which means select(-matches("^X\\d+${content}quot;))
num_range() Matches numerical ranges like x1, x2, x3. g. `select(-where(is.

Practical Example: Imagine a dataset with 50 columns where 10 are calculated "flag" columns ending in _flag. You can drop them all in one line:

df_clean <- df |>
  select(-ends_with("_flag"))

Dropping by Data Type: A common preprocessing step is removing all character columns before feeding data into a matrix-based algorithm (like xgboost or PCA), or conversely, dropping all numeric IDs.

# Drop all character columns
df_numeric_only <- df |>
  select(-where(is.character))

# Drop all factor columns
df_no_factors <- df |>
  select(-where(is.factor))

Method 3: data.table for High-Performance Needs

For large datasets (millions of rows), data.table is the gold standard for speed and memory efficiency. Its syntax for column deletion is distinct because it modifies the object by reference (in place), meaning no copy is made and no assignment is strictly required (though assignment is good practice for chaining) Small thing, real impact. No workaround needed..

The := Operator

The := operator is the key to modifying columns by reference.

library(data.table)

# Convert to data.table
setDT(df)

# Drop columns by name (modifies 'df' instantly in memory)
df[, c("Salary", "Department") := NULL]

# Drop by index
# df[, c(1, 3) := NULL] # Deletes

```r
# Drop by index
df[, c(1, 3) := NULL] # Deletes 1st and 3rd columns instantly

Dropping by Pattern in data.table

While data.table doesn't have the exact same helper verbs as tidyselect, it offers powerful pattern matching via the patterns() function (which uses grep internally) or standard regex on the column names vector.

# Drop columns starting with "temp_" using patterns()
df[, grep("^temp_", names(df)) := NULL]

# Drop columns ending with "_flag" using patterns() helper
# Note: patterns() is a convenience wrapper for grep
df[, patterns("^temp_|_flag$") := NULL]

# Drop by type (e.g., all character columns)
char_cols <- names(df)[vapply(df, is.character, logical(1))]
df[, (char_cols) := NULL]

Critical Note on Reference Semantics: Because := modifies by reference, df is changed in place. If you need to preserve the original data, you must explicitly copy it first: dt_copy <- copy(df).


Method 4: Base R (Zero Dependencies)

For scripts where minimizing dependencies is essential, or for understanding what happens "under the hood," Base R remains perfectly capable.

The Negative Index / Name Approach

The most idiomatic Base R method uses negative indexing inside the [ extractor.

# Drop by name (returns new object, original unchanged)
df_new <- df[, !names(df) %in% c("Salary", "Department")]

# Drop by index
df_new <- df[, -c(1, 3)]

# Drop using subset() (often more readable)
df_new <- subset(df, select = -c(Salary, Department))

Pattern Matching with grep/grepl

Base R relies on grep (indices) or grepl (logical vector) for pattern-based dropping Worth keeping that in mind..

# Drop columns ending with "_flag"
df_new <- df[, !grepl("_flag$", names(df))]

# Drop columns starting with "temp_"
df_new <- df[, -grep("^temp_", names(df))]

Summary: Choosing the Right Tool

Scenario Recommended Method Why?
Interactive Analysis / Readability dplyr::select() Expressive helpers (where(), ends_with()), pipe-friendly, clear intent.
Production Pipelines / Large Data (>1M rows) data.table Reference semantics (:=) avoid memory duplication; fastest execution speed. That's why
Minimal Dependencies / Portability Base R ([, subset, grep) Zero imports; runs on any R installation; good for simple scripts. Practically speaking,
Programmatic Column Lists dplyr::select(all_of()) or data. table with ..cols Safely handles character vectors stored in variables.

Conclusion

Dropping columns is rarely just about deletion—it is an act of curation. Whether you are stripping personally identifiable information (PII) for compliance, removing high-cardinality categorical variables before modeling, or simply decluttering a wide dataset for exploration, the method you choose signals the context of your work Not complicated — just consistent..

dplyr makes the intent readable for collaborators; data.Which means mastery isn't memorizing every helper function—it's knowing which philosophy fits your current constraint. table makes the execution efficient for the machine; Base R ensures the code runs everywhere. Clean data isn't just about what you keep; it's about confidently letting go of what you don't Nothing fancy..

Just Hit the Blog

Just In

People Also Read

More to Discover

Thank you for reading about How To Delete Columns In R. We hope the information has been useful. Feel free to contact us if you have any questions. See you next time — don't forget to bookmark!
⌂ Back to Home