Pandas for Absolute Beginners (with Real Data)#

• Pandas is the most popular Python library for working with tables of data, similar to a spreadsheet or a database table.
• This lesson runs entirely inside a Jupyter Notebook in VS Code, one cell at a time.
• We start from the very basics, so no prior pandas experience is required.
• We then build up to intermediate skills like grouping, merging, and cleaning messy data, using a real dataset of cars called mtcars.csv.
• By the end, you will be comfortable loading, exploring, filtering, grouping, and summarizing real-world data with pandas.

Before You Start#

• Make sure Python, VS Code, and the Python and Jupyter extensions are already installed.
• Open a new Jupyter Notebook in VS Code and select your Python interpreter as the kernel.
• Place mtcars.csv in the same folder as your notebook so pandas can find it with just its file name.
• If pandas is not installed yet, open a terminal in VS Code and run: pip install pandas

Beginner: The Series A Single Labelled Column#

• A Series is a one-dimensional, labelled array think of it as a single column in a spreadsheet.
• Every value in a Series has a label, called its index, even if you never set one yourself.
• Series are the building block that DataFrames (full tables) are made of.

Building a Series From a Dictionary#

• Python dictionaries map naturally onto a Series: keys become the index, and values become the data.

Automatic Index Alignment#

• When you combine two Series with math operators, pandas lines up the values by their labels first, not by position.
• Labels that only exist in one of the two Series become missing values, shown as NaN (Not a Number).

Beginner: The DataFrame A Full Table#

• A DataFrame is a two-dimensional table made up of rows and columns, exactly like a spreadsheet.
• Every column in a DataFrame is really a Series, and all the columns share the same row index.
• Most real-world pandas work happens on DataFrames rather than single Series.

Selecting Columns#

Selecting Rows With loc and iloc#

Adding, Changing, and Removing Columns#

Dropping Rows and Columns With .drop()#

Beginner: Building a DataFrame From a Nested Dictionary#

Intermediate: Combining Tables With merge()#

• pd.merge() joins two DataFrames together based on a shared column, exactly like a SQL JOIN.
• The 'how' argument controls which rows survive when keys do not perfectly match on both sides.

Intermediate: Stacking Tables With concat()#

• pd.concat() stacks DataFrames together, either on top of each other or side by side.
• Unlike merge, concat does not match on a key column it simply lines things up by position or by index.

Beginner: Working With a Real Dataset mtcars.csv#

• mtcars is a classic dataset listing specifications for 32 different car models.
• mpg: Miles per US gallon (fuel efficiency)
• cyl: Number of cylinders in the engine
• disp: Engine displacement in cubic inches
• hp: Gross horsepower
• drat: Rear axle ratio
• wt: Weight, in thousands of pounds
• qsec: Quarter-mile time in seconds
• vs: Engine shape, 0 means V-shaped, 1 means straight
• am: Transmission, 0 means automatic, 1 means manual
• gear: Number of forward gears
• carb: Number of carburetors

Intermediate: Grouping Data With groupby()#

• .groupby() splits a DataFrame into groups based on the values in one or more columns, then lets you summarize each group separately.
• This is one of the single most useful tools in all of pandas, often described as 'split, apply, combine'.

Try It Yourself: Search by Car Model#

• We can combine string methods with boolean filtering to search for cars by name.

Intermediate: Arithmetic Between DataFrames and Series (Broadcasting)#

• When you subtract a Series from a DataFrame, pandas 'broadcasts' the Series across every row automatically.
• This avoids writing manual loops to repeat an operation across many rows or columns.

Intermediate: A Closer Look at Indexing#

• We have already used square brackets, .loc, and .iloc a little now let's understand exactly how each one behaves.

Series Indexing and Slicing#

DataFrame Indexing and Boolean Filtering#

loc and iloc, Side by Side#

• .loc[label] selects by label; .loc[[label1, label2]] selects a list of labels; .loc[start:end] selects an inclusive label slice.
• .iloc[index] selects by integer position; .iloc[[i, j]] selects a list of positions; .iloc[start:end] selects an exclusive position slice, just like normal Python.
• Both .loc and .iloc also accept a boolean condition to filter rows.

Advanced (Optional): Hierarchical Indexing#

• Hierarchical indexing lets a Series or DataFrame have more than one level of row or column labels at once.
• This section is optional for absolute beginners feel free to skip ahead to Missing Data if you prefer, and come back later.

Intermediate: Applying Your Own Functions#

• Built-in pandas methods cover a lot, but sooner or later you will need a calculation pandas does not already provide.
• .apply() runs your own function once per column (or per row), while .map() runs it on every individual value.

Beginner: Handling Missing Data#

• Real datasets almost always have gaps. Pandas represents a missing value as NaN.
• Knowing how to detect, fill, and drop missing values is an essential, everyday pandas skill.

Missing Data in a Full DataFrame#

A Common Beginner Mistake: Index Objects Cannot Be Edited#

• Unlike a list, a pandas Index is immutable once created, individual labels inside it cannot be changed directly.
• The next cell deliberately triggers this error on purpose, so you recognize it immediately if you ever see it in your own code.

Intermediate: Catching Errors Gracefully#

• Sometimes you want to detect a problem and handle it in your code, rather than letting the whole notebook stop.
• Python's try/except lets you catch a specific error type and respond to it instead of crashing.

Best Practice: Wrapping Repeated Work in a Function#

• If you find yourself writing the same few lines of pandas code repeatedly, turn them into a function.
• This avoids copy-paste mistakes and makes your analysis easy to reuse on a different column or dataset.

End-to-End Mini Project: Which Cars Are Most Fuel-Efficient?#

• Let's combine everything from this lesson loading, filtering, grouping, and sorting into one small real analysis.
• Question: is a manual or automatic transmission more fuel-efficient in this dataset, and how does cylinder count affect the answer?

Wrap-Up: What You Learned#

• Series and DataFrames, pandas' core building blocks for labelled, one- and two-dimensional data.
• Selecting, filtering, adding, and dropping rows and columns using square brackets, .loc, and .iloc.
• Combining tables with merge() and concat(), and grouping and summarizing data with groupby() and .agg().
• Reshaping data with hierarchical indexes, unstack(), and stack().
• Detecting, filling, and dropping missing data with isnull(), fillna(), ffill(), bfill(), and dropna().
• Applying your own custom functions with .apply() and .map().
• Loading and saving real data with read_csv() and to_csv(), applied to the real mtcars dataset.
• Practice prompt: pick a dataset of your own even a simple CSV export from a spreadsheet you already have and try repeating the mini project's question-and-answer approach on it.

Enjoyed This Lesson?#

• If this pandas walkthrough helped you, consider subscribing it is free, and it is the best way to support more real-data tutorials like this one.
• Drop a comment below with what you would like to see covered next: NumPy, data visualization, or something else entirely.
• If you made it all the way to the end, give the video a like you just leveled up your pandas skills!