Data Cleaning Exercises

Data Wrangling, Data Cleaning and Data Munging: What's the Difference?

Data wrangling and data munging mean the same thing; data cleaning is one part of both. See where the terms came from and how each step looks in pandas.

By Tnas · Published · 7 min read

Diagram showing data wrangling as an umbrella over three steps: cleaning values, restructuring the table and enriching it with a lookup

Data wrangling and data munging are two names for the same job: turning raw data into a form you can analyze. Data cleaning is one part of that job, the part concerned with making values correct. Wrangling also covers restructuring tables, such as reshaping wide data to long, and enriching them, such as joining in a lookup table. In short, all cleaning is wrangling, but not all wrangling is cleaning.

Key Takeaways

  • Data wrangling and data munging are synonyms. "Munging" is the older, more informal word, from 1960s hacker slang; "wrangling" is the term used in data analysis research and textbooks.
  • Data cleaning is a subset of wrangling: it fixes values without changing what a row means.
  • Wrangling adds two more kinds of work: structuring (reshaping, splitting, combining columns) and enriching (joining other data in).
  • The distinction matters in practice because each kind of step fails differently. Cleaning mostly fails by keeping wrong values (or, with deduplication, by dropping rows that were not true duplicates); structuring and enriching fail by losing or duplicating rows.
  • Data preparation is the broadest term of all. It usually includes wrangling plus steps for a specific model, such as encoding and scaling.

Are data wrangling and data munging the same thing?

Yes. Data wrangling and data munging describe the same activity, and common definitions, such as IBM's, treat them as interchangeable. IBM's explainer defines data wrangling as "the process of cleaning, structuring and enriching raw data" and notes that it is "also known as data munging or data preparation" (IBM, "What is data wrangling?").

The two words have different histories:

  • Munging comes from programmer slang. The Jargon File, a long-running dictionary of hacker vocabulary, traces "mung" to MIT in 1960 as "Mash Until No Good", later read as the recursive "Mung Until No Good" (The Jargon File, "mung"). Its entry for "munge" includes the sense "to imperfectly transform information" and marks it as derogatory (The Jargon File, "munge"). The word carries a hint of hacky, one-off scripting.
  • Wrangling became the standard term in data analysis research and teaching. A 2011 paper introducing the Wrangler tool described data wrangling as work that "regularly involves reformatting data values or layout, correcting erroneous or missing values, and integrating multiple data sources" (Kandel, Paepcke, Hellerstein and Heer, CHI 2011).

If someone asks you to "munge" a file, they mean the same thing as "wrangle". In formal writing, "wrangling" avoids the slang connotation.

How is data cleaning different from data wrangling?

Data cleaning is the part of wrangling that makes values correct, while wrangling as a whole also changes the structure of the data and combines it with other sources. The Kandel et al. definition above contains both: "correcting erroneous or missing values" is cleaning, while "reformatting … layout" and "integrating multiple data sources" are structuring and enriching.

R for Data Science uses a different split that still puts structure inside wrangling. It describes tidying (putting data into a consistent structure) and transforming (filtering, creating variables, summarizing) and says that "together, tidying and transforming are called wrangling" (Wickham, Çetinkaya-Rundel and Grolemund, R for Data Science, 2nd ed.).

Data cleaning Structuring Enriching
Question it answers Is each value correct? Is the table in the right shape? Does the table have the columns the analysis needs?
Typical steps Trim, fix types, standardize categories, handle missing values, deduplicate, validate Reshape wide to long, split or combine columns, rename, pivot Join lookup tables, add attributes from another source
Changes row meaning? No (deduplication removes rows but not their meaning) Often (one row per region and month instead of one per region) No, if the join is many-to-one; yes, if it fans out
Typical failure Wrong or placeholder values kept Gaps turned into zeros, values lost in reshaping Rows dropped or duplicated by the join
Part of wrangling? Yes Yes Yes

The same boundary, seen from the pipeline side, is the subject of data cleaning vs data transformation. Some writers use "data cleaning" loosely to mean all of wrangling, and that is common in casual speech. When you plan or review work, the narrower meaning is more useful, because it tells you what to test.

What does each step look like in practice?

Here is a small wrangling task done in pandas 3.0, split into its three kinds of step. The input is a wide spreadsheet of units sold per region per month, plus a lookup table of regional managers:

import pandas as pd

sales = pd.DataFrame({
    "region": [" North", "south", "East ", "west"],
    "jan": ["1200", "950", "n/a", "780"],
    "feb": ["1310", "", "640", "805"],
}, dtype="string")

regions = pd.DataFrame({
    "region": ["north", "south", "east"],
    "manager": ["Ana", "Ben", "Chloé"],
}, dtype="string")

Every output below comes from running this code with pandas 3.0.2.

Step 1: Clean the values

Cleaning trims and lowercases the region names, and turns the empty string and n/a into real missing values before converting to integers:

sales["region"] = sales["region"].str.strip().str.lower()
for col in ["jan", "feb"]:
    sales[col] = pd.to_numeric(sales[col].replace(["", "n/a"], pd.NA), errors="coerce").astype("Int64")
print(sales.to_string(index=False))

region  jan  feb
 north 1200 1310
 south  950 <NA>
  east <NA>  640
  west  780  805

The table still has one row per region. Only the values changed.

Step 2: Restructure the table

Structuring reshapes the table from wide (one column per month) to long (one row per region and month), which is the shape most analysis and plotting tools expect:

long = sales.melt(id_vars="region", var_name="month", value_name="units")
print(long.to_string(index=False))

region month  units
 north   jan   1200
 south   jan    950
  east   jan   <NA>
  west   jan    780
 north   feb   1310
 south   feb   <NA>
  east   feb    640
  west   feb    805

The row grain changed: four rows became eight. The two missing values stayed missing rather than turning into zeros, which is the main thing to check after any reshape. The guide to pivoting and unpivoting without inventing data covers the other traps, and the glossary entry on wide and long format defines the two shapes.

Step 3: Enrich with a lookup

Enriching joins the manager for each region. Two arguments make the join safe: validate="many_to_one" raises an error if the lookup table has duplicate regions, and indicator=True adds a column showing which rows found a match:

enriched = long.merge(regions, on="region", how="left", validate="many_to_one", indicator=True)
print(enriched["_merge"].value_counts().to_string())

_merge
both          6
left_only     2
right_only    0

Two rows found no manager: west is missing from the lookup table. A left join keeps them, with a missing manager, so the units still count toward totals. An inner join would have dropped 1,585 units without any error. The lesson on merge with validate and indicator explains both arguments, and report orphans, don't drop them covers what to do with the unmatched rows. Other join traps are collected in pandas merge pitfalls.

Notice that step 1 had to come first. Without trimming and lowercasing, " North" would not have matched "north" in the lookup, and neither would "East ", so the join would have reported false orphans.

Where does data preparation fit?

Data preparation is the broadest of these terms. IBM uses it as a synonym for wrangling, but in machine learning it usually also includes steps that only make sense for a particular model, such as one-hot encoding categories, scaling numbers and splitting training and test sets.

A practical way to nest the terms:

  1. Data cleaning: make values correct.
  2. Data wrangling (or munging): cleaning plus structuring and enriching, to get an analysis-ready table.
  3. Data preparation: wrangling plus model-specific steps, to get a model-ready dataset.

Not every author uses this nesting, so check what a team means when the terms appear in a job description or a project plan.

Which term should you use?

Use the term that describes what you actually did. "Cleaned the customer file" tells a reader that values were fixed and only true duplicates were removed. "Wrangled the sales exports" tells them the structure changed too, which means they should ask how you checked that no rows were lost or duplicated. In an interview, being precise here signals that you know which checks each kind of step needs.

Frequently asked questions

Is data munging a negative term?

It can be. The Jargon File marks "munge" as derogatory in its "imperfectly transform" sense, and the word still suggests quick, unrepeatable scripting to some people. In everyday data work it is mostly used neutrally, as a synonym for wrangling.

Is data wrangling the same as ETL?

They overlap but are not the same. ETL (extract, transform, load) describes an automated pipeline that moves data between systems, and its transform step includes wrangling. Wrangling also happens interactively, in a notebook or spreadsheet, with no pipeline at all.

What tools are used for data wrangling?

SQL engines such as DuckDB, Python with pandas, R with the tidyverse, spreadsheet tools such as Power Query, and visual pipeline builders. The steps are the same in each: clean values, restructure, enrich, and check row counts after every structural change.

Practice each kind of step

A good way to feel the difference is to practice each kind of step on its own. For cleaning, try cleaning an order-line export. For structuring, unpivot quarterly sales, keeping zeros. For enriching, enrich without dropping rows, which checks exactly the inner-join problem shown above.

Sources