Python Pandas: Introduction to Data Analysis

Categories: Python Pandas Tutorial

Tags:

Python Pandas: Introduction to Data Analysis

Introduction

When you start learning Python for data analysis, you will quickly discover that writing Python code is only one part of the process. The real challenge begins when you have actual data in front of you.

Data may come from an Excel spreadsheet, CSV file, database, API, survey, website, business application, or another software system. It may contain hundreds, thousands, or even millions of records. Before you can create charts, calculate statistics, or build machine learning models, you first need to understand and organize that data.

This is where Pandas becomes extremely useful.

Pandas is a popular Python library designed specifically for working with structured data. It allows you to read datasets, inspect their contents, select specific rows and columns, filter records, perform calculations, handle missing values, sort information, group records, and prepare data for further analysis.

If you have ever worked with Microsoft Excel, you can think of a Pandas DataFrame as a programmable spreadsheet. However, instead of manually clicking through menus and cells, you can perform operations using Python code.

For example, imagine you have a dataset containing customer information:

Name       Age    City       Sales
Rahul      25     Delhi      45000
Priya      31     Mumbai     62000
Amit       28     Pune       39000
Neha       35     Jaipur     71000

With Pandas, you can quickly calculate the average sales, find the highest-selling customer, filter customers from a particular city, or group sales by city.

This makes Pandas an important foundation for anyone learning data analysis with Python.

In this introductory chapter, we will focus on the basics. We are not going to jump into advanced data manipulation or complicated analysis. The goal is to understand what Pandas is, how it works, and what you can start doing with it.

What Is Pandas?

Pandas is an open-source Python library used for data manipulation and data analysis.

It provides convenient data structures and functions that make it easier to work with structured information.

The two most important Pandas data structures are:

Series
DataFrame

You will use DataFrames much more frequently when working with datasets.

A DataFrame looks similar to a table:

Name	Age	City	Sales
Rahul	25	Delhi	45000
Priya	31	Mumbai	62000
Amit	28	Pune	39000
Neha	35	Jaipur	71000

Each vertical section is a column, while each horizontal record is a row.

Pandas allows Python to understand this table as structured data.

You can then write code to manipulate it.

Installing Pandas

If you are using Python and Pandas is not already installed, you can install it using pip.

Open your Command Prompt, Terminal, or VS Code terminal and run:

pip install pandas

Once the installation is complete, you can import Pandas into your Python program.

import pandas as pd

The pd part is an alias.

Instead of repeatedly writing:

pandas.DataFrame()

we can write:

pd.DataFrame()

This is the standard convention used in most Pandas code.

Creating Your First DataFrame

Let’s create a small dataset directly in Python.

import pandas as pd

data = {
    "Name": ["Rahul", "Priya", "Amit", "Neha"],
    "Age": [25, 31, 28, 35],
    "City": ["Delhi", "Mumbai", "Pune", "Jaipur"],
    "Sales": [45000, 62000, 39000, 71000]
}

df = pd.DataFrame(data)

print(df)

Here, we first create a Python dictionary called data.

Each key becomes a column name:

Name
Age
City
Sales

The lists contain the values for those columns.

Then:

df = pd.DataFrame(data)

converts our dictionary into a Pandas DataFrame.

The variable df now contains our table.

Understanding the DataFrame

Once you have a DataFrame, one of the first things you should do is inspect it.

The simplest approach is:

print(df)

You can also use:

df.head()

The head() function displays the first five rows by default.

print(df.head())

You can specify how many rows you want:

print(df.head(2))

This will show the first two records.

Similarly, you can use:

df.tail()

to see the last five rows.

These simple functions are extremely useful when you are working with a large dataset and want a quick look at its structure.

Checking the Shape of Your Data

Another useful property is:

df.shape

It tells you the number of rows and columns.

For example:

print(df.shape)

might return:

(4, 4)

This means the DataFrame contains:

4 rows
4 columns

If your dataset contains 50,000 records, this immediately gives you an idea of its size.

Looking at Column Names

You can view all column names using:

print(df.columns)

The output could look something like:

Index(['Name', 'Age', 'City', 'Sales'], dtype='object')

This becomes particularly useful when you are working with datasets that contain dozens or hundreds of columns.

Before analyzing data, it is often a good idea to understand what information is actually available.

Selecting a Column

Selecting a column in Pandas is simple.

For example:

print(df["Name"])

This returns the Name column.

You can also select:

print(df["Sales"])

If you want multiple columns, you can provide a list:

print(df[["Name", "Sales"]])

Now Pandas will return only the Name and Sales columns.

This is one of the first important concepts to understand because data analysis often involves working with only the columns that matter for a particular question.

Basic Calculations

Pandas can perform calculations directly on columns.

For example, to calculate total sales:

print(df["Sales"].sum())

To calculate average sales:

print(df["Sales"].mean())

To find the maximum sales value:

print(df["Sales"].max())

To find the minimum:

print(df["Sales"].min())

You can also calculate the number of records:

print(df["Sales"].count())

These functions allow you to perform basic analysis without manually calculating values.

Filtering Data

Filtering is another fundamental Pandas operation.

Suppose we only want customers whose sales are greater than 50,000.

We can write:

high_sales = df[df["Sales"] > 50000]

print(high_sales)

Pandas will return only the rows where the condition is true.

This is extremely useful when working with real-world datasets.

For example, you could filter:

df[df["Age"] > 30]

or:

df[df["City"] == "Delhi"]

The same concept can be applied to datasets containing locations, products, employees, transactions, or any other structured information.

A Simple Location-Based Example

Let’s make our dataset slightly more interesting.

Suppose we have sales information from different cities:

data = {
    "City": ["Delhi", "Mumbai", "Pune", "Jaipur", "Delhi"],
    "Sales": [45000, 62000, 39000, 71000, 55000]
}

df = pd.DataFrame(data)

print(df)

Now we can ask simple questions.

For example:

What are the sales records from Delhi?

print(df[df["City"] == "Delhi"])

Or we can calculate total sales:

print(df["Sales"].sum())

Later, Pandas gives us more powerful tools such as groupby(), which can help us calculate totals for each city.

For example:

print(df.groupby("City")["Sales"].sum())

The result might look like:

City
Delhi     100000
Jaipur     71000
Mumbai     62000
Pune       39000

This is a very simple example, but it demonstrates how structured data can quickly be converted into useful information.

Reading a CSV File

In real projects, you will usually not create your entire dataset manually.

Instead, you might receive a CSV file.

Pandas makes loading CSV files very easy:

import pandas as pd

df = pd.read_csv("sales.csv")

print(df.head())

That’s it.

Pandas reads the CSV file and converts it into a DataFrame.

This is one reason Pandas is so popular.

A CSV file containing thousands of rows can be loaded into Python with a single line of code.

For example, a dataset could contain:

Customer,City,Sales
Rahul,Delhi,45000
Priya,Mumbai,62000
Amit,Pune,39000

After loading it with read_csv(), you can immediately start exploring and analyzing it.

Reading Excel Files

Pandas can also work with Excel files.

For example:

df = pd.read_excel("sales.xlsx")

You can then use the same DataFrame operations:

print(df.head())

This means that once your data is loaded into a DataFrame, the source format becomes less important.

Whether your original data came from CSV or Excel, you can perform many of the same Pandas operations.

Understanding Data Types

Another important beginner concept is data type.

You can check the data types of your columns using:

print(df.dtypes)

You might see something like:

Name       object
Age         int64
City       object
Sales       int64

Here:

int64 generally represents integer numbers.
float64 represents decimal numbers.
object is commonly used for text data.
bool represents True/False values.

Understanding data types becomes important when you start performing calculations, filtering data, working with dates, or cleaning datasets.

Getting a Quick Statistical Summary

Pandas also provides a very convenient function:

print(df.describe())

For numerical columns, this can provide information such as:

Count
Mean
Standard deviation
Minimum
Maximum
Quartiles

For example, if your dataset contains an Age column and a Sales column, describe() can quickly give you an overview of their numerical distribution.

This is one of those functions that becomes extremely useful during the early stage of data exploration.

Sorting Data

You can also sort your DataFrame.

For example, to sort customers by sales:

df = df.sort_values("Sales")

This sorts the data from lowest to highest.

To sort from highest to lowest:

df = df.sort_values("Sales", ascending=False)

Now your highest-selling records will appear at the top.

Sorting becomes particularly useful when you want to identify top-performing products, customers, cities, employees, or other categories.

Why These Basics Matter

At this stage, you might be thinking that Pandas is simply another way to work with tables.

In one sense, that’s true.

But the real power comes from combining these simple operations.

You can:

Load a dataset.
Inspect its structure.
Select important columns.
Filter records.
Calculate statistics.
Sort the results.
Group information.
Clean the data.
Prepare it for visualization.

And all of this can be done programmatically.

For example:

df = pd.read_csv("sales.csv")

print(df.head())

high_sales = df[df["Sales"] > 50000]

print(high_sales.sort_values("Sales", ascending=False))

A few lines of Python can therefore replace a considerable amount of manual spreadsheet work.

Pandas Is More Than Just Tables

One of the biggest advantages of learning Pandas is that it becomes a foundation for other areas of data work.

Once you understand DataFrames, you can move toward:

Data cleaning
Exploratory Data Analysis
Data visualization
Statistical analysis
Machine learning
Business intelligence
Reporting
Automation
Data engineering workflows

Pandas also works extremely well with other Python libraries.

For example, you can use Matplotlib or Seaborn for visualization and libraries such as NumPy for numerical operations.

Later, depending on your area of interest, you can also combine Pandas with specialized libraries for working with geographic coordinates and maps.

But there is no need to learn everything at once.

The important thing is to first become comfortable with the DataFrame.

What We Will Learn Next

This chapter was intentionally focused on the fundamentals.

We have seen that Pandas can help us:

Create DataFrames
Load CSV and Excel files
Inspect datasets
Select columns
Filter rows
Perform calculations
Sort data
Check data types
Generate basic statistics
Group information

These may look like simple operations, but they form the foundation of much more advanced data analysis.

In the next stages, we can start working with real datasets and explore concepts such as missing data, duplicate records, data cleaning, grouping, merging datasets, handling dates, and creating more meaningful analysis.

For example, a future dataset might contain information about cities, countries, sales, population, coordinates, or other location-related attributes. We can use Pandas to organize that information before eventually visualizing it.

That is the important learning approach I recommend: start with the DataFrame, understand the data, and then gradually increase the complexity of your analysis.

Conclusion

Pandas is one of the most useful libraries to learn if you want to use Python for data analysis.

At first, concepts such as DataFrames, columns, filtering, sorting, and grouping may seem simple. However, these basic operations are used repeatedly in real-world data projects.

The biggest advantage of Pandas is that it allows you to work with data using code. Instead of manually searching through thousands of spreadsheet rows, you can tell Python exactly what information you want.

You can load a file, inspect its structure, select specific columns, filter records, calculate statistics, and organize results with relatively little code.

And this is only the beginning.

As you progress, Pandas becomes increasingly powerful. You can clean messy datasets, combine information from different sources, work with dates, perform group-based analysis, prepare data for charts, and create datasets ready for machine learning.

For beginners, however, there is no reason to rush into advanced functionality.

Start by understanding what a DataFrame is.

Learn how to load data.

Learn how to select and filter it.

Learn how to calculate simple statistics.

Then gradually introduce more powerful operations.

Once these fundamentals become comfortable, you will have a strong foundation for exploring larger and more complex datasets.

In the chapters ahead, we can move beyond these basics and start working with practical datasets where the real value of Pandas becomes much more visible.

Pandas is not the final destination in Python data analysis. It is one of the foundations that helps you get there.

— Ankit