Lesson 3 — Sorting, Ranking and Ordering Data in Pandas

Sorting and Ranking Data for Practical Data Analytics

Sorting and ranking are fundamental operations in Pandas because raw datasets are rarely arranged in the order needed for analysis. A DataFrame may contain thousands of customer records, transactions, employees, products, hotels, students, or other observations. The analyst often needs to transform that unordered information into a meaningful sequence so that high-performing, low-performing, recent, expensive, inexpensive, or otherwise important records can be identified quickly.

Sorting and ranking are related, but they solve different analytical problems. Sorting changes the order in which records are displayed. Ranking assigns a relative position to records based on a numerical or comparable value. For example, sorting employees by salary places the highest salary at the top, while ranking employees by salary creates a separate rank value that can be used for further analysis.

These operations are especially useful in reports and dashboards. A manager may want the Top 10 products by revenue, the five lowest-performing branches, the highest-rated hotels in a district, or the best-performing employees within every department. Pandas provides efficient methods for these tasks, particularly sort_values(), sort_index(), rank(), nlargest(), and nsmallest().

In professional Data Analytics, however, knowing the syntax is only part of the task. Before sorting or ranking, an analyst should define the metric, the population, the direction, the treatment of ties, and the handling of missing values. A report saying “Top 10” is incomplete unless it explains Top 10 by what metric and among which records.

We will use practical datasets throughout this lesson.

import pandas as pd

employees = pd.DataFrame({
    "Employee_ID": [101, 102, 103, 104, 105, 106, 107, 108, 109, 110],
    "Name": [
        "Amit", "Priya", "Rahul", "Neha", "Karan",
        "Sonia", "Arjun", "Meena", "Ravi", "Pooja"
    ],
    "Department": [
        "Analytics", "HR", "Analytics", "Finance", "IT",
        "Analytics", "HR", "Finance", "Analytics", "IT"
    ],
    "City": [
        "Dehradun", "Delhi", "Dehradun", "Delhi", "Haridwar",
        "Dehradun", "Delhi", "Dehradun", "Haridwar", "Delhi"
    ],
    "Experience": [2, 5, 4, 8, 6, 3, 7, 5, 4, 9],
    "Salary": [
        45000, 65000, 72000, 95000, 82000,
        58000, 78000, 70000, 68000, 105000
    ],
    "Performance": [72, 91, 85, 94, 87, 76, 89, 82, 90, 96]
})

print(employees)

Start by inspecting the data:

print(employees.head())
print(employees.shape)
print(employees.dtypes)

This confirms the columns and data types before you begin analytical transformations.

The most common sorting method in Pandas is sort_values(). It sorts rows according to values in one or more columns.

To sort employees by salary from the lowest salary to the highest:

result = employees.sort_values(
    by="Salary"
)

print(result)

The default is ascending order. Therefore, the smallest salary appears first.

To sort from the highest salary to the lowest:

result = employees.sort_values(
    by="Salary",
    ascending=False
)

print(result)

This is one of the most useful patterns in business reporting. If management asks for the highest-paid employees, descending salary order immediately provides the desired view.

You can sort by performance in exactly the same way:

result = employees.sort_values(
    by="Performance",
    ascending=False
)

print(result)

Now the employee with the highest performance score appears first.

Sorting does not have to be limited to one column. Suppose performance is the primary criterion and salary is the secondary criterion:

result = employees.sort_values(
    by=["Performance", "Salary"],
    ascending=[False, False]
)

print(result)

The first column is the primary sorting key. When two or more rows have the same performance value, Pandas uses salary to determine their relative order.

You can use different directions for different columns:

result = employees.sort_values(
    by=["Department", "Salary"],
    ascending=[True, False]
)

print(result)

This means departments are ordered alphabetically, while employees within each department are ordered from highest salary to lowest salary.

Multiple-column sorting is extremely useful for reports because it creates a logical hierarchy. For example, a sales report can be sorted by Region first and Sales second. A student report can be sorted by Class first and Marks second. A hotel report can be sorted by City first and Rating second.

Consider a sales dataset:

sales = pd.DataFrame({
    "Region": [
        "North", "North", "South",
        "South", "East", "East",
        "West", "West"
    ],
    "Product": [
        "Laptop", "Mobile", "Laptop", "Mobile",
        "Laptop", "Tablet", "Laptop", "Tablet"
    ],
    "Sales": [
        130000, 85000, 120000, 95000,
        110000, 70000, 90000, 60000
    ]
})

Sort by Region and then Sales descending:

result = sales.sort_values(
    by=["Region", "Sales"],
    ascending=[True, False]
)

print(result)

Within every region, the largest sales value appears first.

This type of ordering is much more useful than simply sorting the entire dataset by sales because it preserves the regional structure of the report.

Sorting can also be combined with filtering. Suppose you want only Analytics employees with performance above 80, ordered from highest to lowest performance:

result = (
    employees.loc[
        (employees["Department"] == "Analytics") &
        (employees["Performance"] > 80)
    ]
    .sort_values(
        by="Performance",
        ascending=False
    )
)

print(result)

The workflow is:

Filter
   ↓
Sort
   ↓
Analyze

This pattern appears constantly in practical Data Analytics.

If management asks for the five highest-performing Analytics employees, you can add head():

top_5 = (
    employees.loc[
        employees["Department"] == "Analytics"
    ]
    .sort_values(
        by="Performance",
        ascending=False
    )
    .head(5)
)

print(top_5)

The head() method returns the first N rows after sorting.

For example, the general pattern for a Top-N report is:

df.sort_values(
    by="Metric",
    ascending=False
).head(N)

This can be used for Top 5 customers, Top 10 products, Top 20 hotels, Top 10 districts, or any other ranking-based report.

For numerical columns, Pandas also provides nlargest():

top_5 = employees.nlargest(
    5,
    "Salary"
)

print(top_5)

This directly returns the five rows with the largest salary values.

Similarly, nsmallest() returns the lowest values:

bottom_5 = employees.nsmallest(
    5,
    "Salary"
)

print(bottom_5)

For performance:

top_performers = employees.nlargest(
    5,
    "Performance"
)

bottom_performers = employees.nsmallest(
    5,
    "Performance"
)

The choice between sort_values().head() and nlargest() depends on the task. Sorting provides more control over multiple columns and final ordering, while nlargest() is concise for a simple numerical Top-N operation.

Suppose the business wants the Top 5 employees by performance and, among tied performance values, wants the higher salary first. A multi-column sort is more appropriate:

top_5 = (
    employees
    .sort_values(
        by=["Performance", "Salary"],
        ascending=[False, False]
    )
    .head(5)
)

This gives you an explicit tie-breaking rule.

Sorting by index is another useful operation. Pandas uses an index to label rows. To sort according to those labels, use sort_index().

result = employees.sort_index()

print(result)

To reverse the index order:

result = employees.sort_index(
    ascending=False
)

print(result)

Consider a DataFrame with a deliberately shuffled index:

subset = employees.loc[
    [105, 101, 109, 103]
]

print(subset)

Now restore index order:

result = subset.sort_index()

print(result)

sort_index() and sort_values() answer different questions. The first orders by labels, while the second orders by actual values in one or more columns.

Sorting can also be used on columns rather than rows when the axis is changed. For example:

result = employees.sort_index(
    axis=1
)

print(result)

This sorts column labels alphabetically. Although less frequently required in day-to-day analysis, it can be useful when standardizing the presentation of a DataFrame.

Ranking introduces a different concept. Instead of changing the row order, you create a numerical position for each observation.

For example:

employees["Salary_Rank"] = employees["Salary"].rank(
    ascending=False
)

print(employees)

With descending ranking, the highest salary receives the strongest rank position.

For a clearer first-place ranking, you can use:

employees["Salary_Rank"] = employees["Salary"].rank(
    ascending=False,
    method="min"
)

print(employees)

The method parameter becomes important when values are tied.

Consider this student dataset:

scores = pd.DataFrame({
    "Student": [
        "Aman", "Priya", "Rahul",
        "Neha", "Karan", "Sonia"
    ],
    "Score": [
        90, 85, 90, 80, 85, 75
    ]
})

Two students have 90 and two students have 85.

Using the default ranking method:

scores["Rank_Average"] = scores["Score"].rank(
    ascending=False
)

print(scores)

Pandas uses average ranking for ties by default. The tied observations receive the average of the positions they occupy.

For example, if two observations occupy positions 1 and 2, the average rank is 1.5.

With method="min":

scores["Rank_Min"] = scores["Score"].rank(
    ascending=False,
    method="min"
)

Both tied records receive the minimum rank in their tied group.

With method="max":

scores["Rank_Max"] = scores["Score"].rank(
    ascending=False,
    method="max"
)

Both tied records receive the maximum rank position occupied by that group.

With method="dense":

scores["Rank_Dense"] = scores["Score"].rank(
    ascending=False,
    method="dense"
)

Dense ranking does not leave gaps after tied values.

With method="first":

scores["Rank_First"] = scores["Score"].rank(
    ascending=False,
    method="first"
)

Ties are resolved according to the order in which they occur in the DataFrame.

The choice of method should follow the business definition. If the report must show competition-style ranking, one method may be appropriate. If the report requires consecutive ranking numbers, dense ranking may be preferable. If ties should be explicitly represented, average, minimum, or maximum methods may be appropriate depending on the requirement.

One of the most important ranking concepts is the difference between global ranking and group-wise ranking.

A global ranking compares every employee with every other employee:

employees["Global_Rank"] = (
    employees["Performance"]
    .rank(
        ascending=False,
        method="dense"
    )
)

print(employees)

A group-wise ranking compares employees only with others in the same department:

employees["Department_Rank"] = (
    employees
    .groupby("Department")["Performance"]
    .rank(
        ascending=False,
        method="dense"
    )
)

print(employees)

This distinction is essential in business analysis.

A global rank answers:

Who performs best across the organization?

A department rank answers:

Who performs best within each department?

An employee can be ranked eighth globally but first within their department. Both statements can be correct because the comparison populations are different.

You can identify the top performer in each department:

top_by_department = employees.loc[
    employees["Department_Rank"] == 1
]

print(top_by_department)

This is one of the most useful patterns for group-wise ranking.

It can be applied to sales as well:

sales["Region_Rank"] = (
    sales
    .groupby("Region")["Sales"]
    .rank(
        ascending=False,
        method="dense"
    )
)

top_by_region = sales.loc[
    sales["Region_Rank"] == 1
]

print(top_by_region)

This returns the highest-selling product or transaction in each region.

You can extend this to Top 3 per region:

top_3_by_region = sales.loc[
    sales["Region_Rank"] <= 3
]

print(top_3_by_region)

However, be careful with ties. If several records share the same third rank, filtering by rank may return more than three records for a group. That is different from requesting exactly three rows.

If the business specifically requires exactly three rows per group, a different approach may be necessary, usually involving sorting and group-wise selection with an explicit tie-breaking rule.

For example:

top_3_exact = (
    sales
    .sort_values(
        by=["Region", "Sales"],
        ascending=[True, False]
    )
    .groupby("Region")
    .head(3)
)

print(top_3_exact)

This returns exactly three rows per region, assuming each group contains at least three rows.

The difference is important:

Rank <= 3
```
means top three rank positions, including ties.

groupby().head(3)

means exactly three rows after the chosen sorting order.
Therefore, analysts must understand the business meaning of “Top 3.”
Sorting and ranking can also be applied after aggregation. Suppose a company has transaction-level sales and wants to rank regions by total revenue:
regional_summary = (
    sales
    .groupby("Region", as_index=False)["Sales"]
    .sum()
)

regional_summary = regional_summary.sort_values(
    by="Sales",
    ascending=False
)

print(regional_summary)
Now the highest total-sales region appears first.
You can add a ranking column:
regional_summary["Rank"] = (
    regional_summary["Sales"]
    .rank(
        ascending=False,
        method="dense"
    )
)

print(regional_summary)
This creates a management-ready summary containing both the metric and its rank.
A similar approach can be used for products:
product_summary = (
    sales
    .groupby("Product", as_index=False)["Sales"]
    .sum()
    .sort_values(
        by="Sales",
        ascending=False
    )
)

print(product_summary)
This workflow is often more meaningful than ranking individual transactions because management may be interested in product-level performance rather than individual orders.
The analytical sequence becomes:
Transaction Data
      ↓
Group by Business Entity
      ↓
Aggregate Metric
      ↓
Sort
      ↓
Rank
      ↓
Top or Bottom Analysis
This sequence is widely applicable to dashboards and management reports.
Sorting can also be applied to calculated metrics such as profit.
products = pd.DataFrame({
    "Product": [
        "Laptop", "Mobile", "Tablet",
        "Monitor", "Keyboard"
    ],
    "Sales": [
        150000, 100000, 70000,
        50000, 30000
    ],
    "Cost": [
        110000, 70000, 50000,
        42000, 20000
    ]
})

products["Profit"] = (
    products["Sales"] -
    products["Cost"]
)

products["Profit_Margin"] = (
    products["Profit"] /
    products["Sales"] * 100
)
Sort by absolute profit:
profit_rank = products.sort_values(
    by="Profit",
    ascending=False
)

print(profit_rank)
Sort by profit margin:
margin_rank = products.sort_values(
    by="Profit_Margin",
    ascending=False
)

print(margin_rank)
The two lists may be different. A product can generate the highest absolute profit without having the highest profit margin.
This is an important Data Analytics lesson: the ranking metric must be explicitly defined.
“Best product” could mean highest sales, highest profit, highest margin, highest growth, highest customer rating, or another metric. Pandas can sort or rank any of these, but the analyst must decide which definition is appropriate.
Sorting also becomes useful when comparing dates.
orders = pd.DataFrame({
    "Order_ID": [1001,1002,1003,1004,1005],
    "Order_Date": [
        "2026-05-10",
        "2026-01-15",
        "2026-08-01",
        "2026-03-20",
        "2026-06-05"
    ],
    "Sales": [
        85000,
        45000,
        125000,
        70000,
        95000
    ]
})

orders["Order_Date"] = pd.to_datetime(
    orders["Order_Date"]
)
Sort chronologically:
orders = orders.sort_values(
    by="Order_Date"
)

print(orders)
Sort from newest to oldest:
orders = orders.sort_values(
    by="Order_Date",
    ascending=False
)

print(orders)
Date sorting is useful for identifying the latest transaction, recent customers, monthly records, newest applications, or the most recent activity in a dataset.
Missing values require special consideration during sorting.
employees.loc[2, "Salary"] = None

result = employees.sort_values(
    by="Salary",
    ascending=False
)

print(result)
The na_position parameter controls where missing values appear:
result = employees.sort_values(
    by="Salary",
    ascending=False,
    na_position="last"
)
To place missing values first:
result = employees.sort_values(
    by="Salary",
    ascending=False,
    na_position="first"
)
In a management report, placing missing salary records at the end may make the report easier to interpret because missing information is clearly separated from valid salary values.
Ranking and missing values also need careful consideration. If a value is missing, it generally should not be treated as though it were zero unless the business definition explicitly says so. Missing salary and zero salary represent different situations.
For example, if an employee's salary is missing:
employees["Salary"].isna()
you should investigate whether the value is unavailable, incorrectly recorded, or intentionally missing before ranking or comparing it.
Another important concept is tie-breaking. Suppose two employees have identical performance scores:
result = employees.sort_values(
    by=["Performance", "Salary"],
    ascending=[False, False]
)
The performance score is the primary criterion. Salary is the secondary criterion.
You can add Employee_ID as a final tie-breaker:
result = employees.sort_values(
    by=[
        "Performance",
        "Salary",
        "Employee_ID"
    ],
    ascending=[
        False,
        False,
        True
    ]
)
This creates a deterministic ordering even when multiple employees have the same performance and salary.
Deterministic ordering is valuable for recurring reports because the same data and rules produce a consistent output.
Sorting can also be used to prepare data for visualization. For example, when creating a bar chart of the Top 10 products, it is usually easier to interpret the chart when the data has already been sorted.
top_products = (
    product_summary
    .sort_values(
        by="Sales",
        ascending=False
    )
    .head(10)
)
The same principle applies to Power BI, Tableau, Excel exports, and other reporting environments. Even if the visualization tool can perform its own sorting, preparing a clean analytical table in Pandas can make the workflow easier to validate.
Ranking can also be expressed as a percentage position:
employees["Performance_Percentile"] = (
    employees["Performance"]
    .rank(pct=True)
)

print(employees)
This provides relative standing rather than only an absolute rank number.
For example, an employee's raw performance score may be 85, but the percentile position provides information about how that employee compares with the rest of the selected population.
However, percentile interpretation depends on the population. If you filter to Analytics employees first and calculate the percentile, it represents standing within Analytics. If you calculate it across the entire organization, it represents organizational standing.
This leads to one of the most important principles in ranking:
The population determines the meaning of the rank.
For example:
employees["Global_Rank"] = (
    employees["Performance"]
    .rank(
        ascending=False,
        method="dense"
    )
)
Now compare it with department ranking:
analytics = employees.loc[
    employees["Department"] == "Analytics"
].copy()

analytics["Department_Rank"] = (
    analytics["Performance"]
    .rank(
        ascending=False,
        method="dense"
    )
)
An employee can have a lower global rank but a first-place department rank. This is not contradictory because the comparison groups are different.
Always document the population when publishing rankings.
Another useful technique is combining sorting and ranking with filters. For example, find the highest-performing employees in Dehradun:
dehradun = employees.loc[
    employees["City"] == "Dehradun"
].copy()

dehradun["Performance_Rank"] = (
    dehradun["Performance"]
    .rank(
        ascending=False,
        method="dense"
    )
)

dehradun = dehradun.sort_values(
    by="Performance",
    ascending=False
)

print(dehradun)
This workflow makes the population explicit before calculating the ranking.
For a Top 3 result:
top_3_dehradun = (
    dehradun
    .sort_values(
        by=["Performance", "Salary"],
        ascending=[False, False]
    )
    .head(3)
)

print(top_3_dehradun)
The secondary salary criterion creates a clear tie-breaking rule.
Sorting and ranking can also support quality checks. For example, after sorting a report by descending Sales, verify the first and last values:
sorted_sales = sales.sort_values(
    by="Sales",
    ascending=False
)

print(sorted_sales["Sales"].iloc[0])
print(sorted_sales["Sales"].iloc[-1])
The first value should be the maximum and the last should be the minimum, assuming missing values have been handled appropriately.
You can compare this with:
print(sales["Sales"].max())
print(sales["Sales"].min())
This is a simple validation technique.
You can also check whether a ranking is behaving as expected:
ranked = employees.copy()

ranked["Rank"] = (
    ranked["Performance"]
    .rank(
        ascending=False,
        method="dense"
    )
)

print(
    ranked.sort_values(
        by="Rank"
    )
)
The smallest rank should correspond to the highest performance.
In practical data projects, avoid unnecessary manual loops for sorting and ranking. Pandas provides optimized methods for these operations.
For example, do not manually compare every employee against every other employee to determine who is first, second, or third. Use:
employees["Rank"] = (
    employees["Performance"]
    .rank(
        ascending=False,
        method="dense"
    )
)
Likewise, use sort_values() rather than writing custom loops to arrange records.
This makes the code shorter, clearer, and easier to maintain.
A complete analytical example can combine filtering, calculated metrics, sorting, and ranking.
products = pd.DataFrame({
    "Product": [
        "Laptop", "Mobile", "Tablet",
        "Monitor", "Keyboard", "Mouse"
    ],
    "Region": [
        "North", "North", "South",
        "South", "North", "South"
    ],
    "Sales": [
        150000, 110000, 95000,
        70000, 45000, 30000
    ],
    "Cost": [
        110000, 80000, 70000,
        55000, 32000, 22000
    ]
})

products["Profit"] = (
    products["Sales"] -
    products["Cost"]
)

products["Profit_Margin"] = (
    products["Profit"] /
    products["Sales"] * 100
)

result = products.loc[
    products["Profit"] > 20000
].copy()

result["Profit_Rank"] = (
    result["Profit"]
    .rank(
        ascending=False,
        method="dense"
    )
)

result = result.sort_values(
    by=["Profit_Rank", "Profit_Margin"],
    ascending=[True, False]
)

print(result)
This example demonstrates a complete analytical sequence:
Load Data
   ↓
Create Profit
   ↓
Create Profit Margin
   ↓
Filter Profitable Products
   ↓
Create Profit Rank
   ↓
Sort Final Result
   ↓
Review Output
This type of workflow is much closer to how Pandas is used in actual Data Analytics projects.
Another practical example is hotel analysis. Suppose a hotel dataset contains rating, price, and reviews:
hotels = pd.DataFrame({
    "Hotel": [
        "Hotel A", "Hotel B", "Hotel C",
        "Hotel D", "Hotel E", "Hotel F"
    ],
    "Rating": [
        8.2, 9.1, 7.8, 8.8, 9.1, 8.5
    ],
    "Price": [
        2200, 4500, 1800, 3200, 5000, 2600
    ],
    "Reviews": [
        120, 350, 80, 240, 410, 180
    ]
})
Find the highest-rated hotels:
top_rated = hotels.sort_values(
    by="Rating",
    ascending=False
)

print(top_rated)
When two hotels have the same rating, reviews can be used as a secondary criterion:
top_rated = hotels.sort_values(
    by=["Rating", "Reviews"],
    ascending=[False, False]
)

print(top_rated)
This means that equal ratings are resolved by the number of reviews.
However, reviews should not automatically be interpreted as a measure of quality. They provide additional context, but the analytical meaning should be stated clearly.
You can create a ranking column:
hotels["Rating_Rank"] = (
    hotels["Rating"]
    .rank(
        ascending=False,
        method="dense"
    )
)
Then select the top rank:
best_rating = hotels.loc[
    hotels["Rating_Rank"] == 1
]

print(best_rating)
If several hotels share the highest rating, all of them may receive rank 1 under dense ranking.
If a report requires exactly one hotel, you need an explicit tie-breaking rule, such as the greatest number of reviews:
best_one = (
    hotels
    .sort_values(
        by=["Rating", "Reviews"],
        ascending=[False, False]
    )
    .head(1)
)

print(best_one)
This is a better analytical approach than arbitrarily selecting one of the tied records.
For interview preparation, you should understand the following concepts clearly.
What does sort_values() do?
It sorts rows according to values in one or more columns.
How do you sort descending?
df.sort_values(
    by="Sales",
    ascending=False
)
How do you sort using multiple columns?
df.sort_values(
    by=["Region", "Sales"],
    ascending=[True, False]
)
What is sort_index()?
It orders rows or columns according to their index labels.
How do you get the Top 5?
df.sort_values(
    by="Sales",
    ascending=False
).head(5)
or:
df.nlargest(
    5,
    "Sales"
)
How do you get the Bottom 5?
df.nsmallest(
    5,
    "Sales"
)
How do you create a rank?
df["Rank"] = df["Sales"].rank(
    ascending=False
)
How do you rank within groups?
df["Rank"] = (
    df.groupby("Region")["Sales"]
    .rank(
        ascending=False,
        method="dense"
    )
)
Why are ranking methods important?
Because ties can occur. The methods average, min, max, dense, and first handle tied values differently.
What is the difference between sorting and ranking?
Sorting changes row order. Ranking assigns a relative position and can create a new column without changing the original order.
A strong interview answer should also mention the importance of defining the population and metric before ranking.
For example, “Top 10 employees” is not a complete analytical requirement. The analyst should ask whether Top 10 means salary, performance, sales generated, customer satisfaction, or another metric.
Similarly, “best product” could mean highest revenue, highest profit, highest profit margin, highest growth, or highest rating.
These definitions can lead to different rankings.
For practice, create a DataFrame containing Product, Region, Sales, Cost, Quantity, and Rating. Complete the following tasks:

Sort products by Sales descending.
Sort products by Sales ascending.
Return the Top 5 products.
Return the Bottom 5 products.
Sort by Region and Sales descending.
Create a Profit column.
Create a Profit Margin column.
Sort by Profit descending.
Sort by Profit Margin descending.
Create a Profit rank.
Create a regional sales rank.
Return the top three products in every region.
Investigate what happens when two products have the same sales.
Compare method="min" and method="dense".
Introduce a missing value and test na_position.
Compare global ranking with group-wise ranking.

For an additional challenge, create a management report with:
Product
Region
Sales
Profit
Profit_Margin
Global_Rank
Regional_Rank
Then sort the report by Region and Regional_Rank.
Another useful exercise is to create a customer dataset with Customer_ID, City, Orders, Revenue, and Profit. Find the Top 10 customers by revenue, then compare their ranking by profit. You may discover that the customer generating the most revenue is not necessarily the customer generating the most profit.
This is an important analytical lesson. Rankings can change dramatically when the metric changes.
You can also calculate multiple ranks:
customers["Revenue_Rank"] = (
    customers["Revenue"]
    .rank(
        ascending=False,
        method="dense"
    )
)

customers["Profit_Rank"] = (
    customers["Profit"]
    .rank(
        ascending=False,
        method="dense"
    )
)
Now compare the two rankings:
customers = customers.sort_values(
    by="Revenue_Rank"
)

print(customers)
This allows an analyst to identify customers who rank highly in revenue but lower in profit.
Such comparisons can support more sophisticated customer segmentation and business decisions.
Sorting and ranking also become valuable when preparing data for dashboards. A dashboard may contain a Top 10 chart, a bottom-performing table, a regional ranking, or a leaderboard. Preparing the underlying DataFrame carefully helps ensure that the visualization reflects the intended analytical logic.
For recurring reports, document the ranking definition. A report specification might say:
Metric:
Total Sales

Population:
Completed Orders

Ranking:
Descending

Tie Breaker:
Profit descending

Top N:
10
This simple documentation prevents ambiguity and makes the analysis easier to reproduce.
It also helps other analysts understand why the report may differ from another report using a different metric or population.
A final validation step is always recommended. If you sort sales descending, verify that the first value equals the maximum:
sorted_sales = sales.sort_values(
    by="Sales",
    ascending=False
)

assert (
    sorted_sales["Sales"].iloc[0]
    == sales["Sales"].max()
)
For a Top-N report, verify the number of rows:
top_10 = (
    sales
    .sort_values(
        by="Sales",
        ascending=False
    )
    .head(10)
)

print(len(top_10))
For group-wise ranking, inspect the rank distribution:
print(
    sales["Region_Rank"].value_counts()
)
Validation is particularly important when the dataset is large or when the code is part of an automated reporting process.
The most important takeaway from this lesson is that sorting and ranking are analytical tools, not merely presentation features. Sorting helps organize records so that patterns and priorities become visible. Ranking provides relative context and allows observations to be compared systematically.
However, neither operation can define what “best” means. That decision comes from the analytical question and business context.
A reliable workflow therefore follows this sequence:
Define the Business Question
        ↓
Define the Population
        ↓
Define the Metric
        ↓
Choose Sorting or Ranking
        ↓
Define Tie Handling
        ↓
Handle Missing Values
        ↓
Validate the Result
        ↓
Create the Report
If you remember this workflow, you will avoid many common analytical mistakes.
For example, if a manager asks for the Top 10 products, do not immediately write head(10). First determine whether the ranking is based on revenue, profit, margin, quantity, growth, or another measure. Then determine whether cancelled transactions should be included, how ties should be handled, and whether missing values need investigation.
Only after these questions are answered should the Pandas code be written.
By the end of this lesson, you should be able to sort DataFrames using one or multiple columns, sort indexes, retrieve Top-N and Bottom-N observations, create ranks, handle tied values using different ranking methods, perform group-wise ranking, combine filtering with sorting, handle missing values during ordering, and build practical ranking tables for Data Analytics.
These skills provide a foundation for later Pandas topics such as grouping and aggregation, pivot tables, time-series analysis, advanced data transformation, visualization preparation, and analytical reporting.
Final lesson takeaway: A good ranking is not simply a list from highest to lowest. It is a transparent analytical result based on a clearly defined metric, population, ranking rule, tie-breaking method, and data-quality process.
When these decisions are clear, Pandas provides the tools needed to turn raw DataFrames into useful, reproducible, and decision-ready analytical results.
Suggested revision task: Take any real or practice dataset you have worked with and create three different Top-10 reports using three different metrics. Compare the results and explain why the ranking changes. This exercise will help you understand that the ranking itself is only as meaningful as the metric behind it.
Key functions from this lesson:
sort_values()
sort_index()
rank()
nlargest()
nsmallest()
head()
groupby()
copy()
These methods should become familiar tools in your Pandas Data Analytics workflow.
Applied Case Study: Regional Sales Leaderboard
Imagine that a retail company operates across North, South, East, and West regions. The management team wants a monthly leaderboard showing which products performed best in each region. The raw dataset contains individual transactions, so the first step is to understand what should be ranked.
transactions = pd.DataFrame({
    "Order_ID": range(2001, 2013),
    "Region": [
        "North", "North", "North",
        "South", "South", "South",
        "East", "East", "East",
        "West", "West", "West"
    ],
    "Product": [
        "Laptop", "Mobile", "Laptop",
        "Laptop", "Tablet", "Mobile",
        "Mobile", "Laptop", "Tablet",
        "Laptop", "Mobile", "Tablet"
    ],
    "Sales": [
        120000, 85000, 95000,
        110000, 65000, 90000,
        100000, 115000, 70000,
        90000, 75000, 55000
    ]
})
If the objective is to identify the best product in each region, ranking individual transactions may not be the correct first step. A product can appear several times in the same region. Therefore, aggregate the sales by Region and Product first.
product_region_summary = (
    transactions
    .groupby(
        ["Region", "Product"],
        as_index=False
    )["Sales"]
    .sum()
)

print(product_region_summary)
Now rank products within each region:
product_region_summary["Regional_Rank"] = (
    product_region_summary
    .groupby("Region")["Sales"]
    .rank(
        ascending=False,
        method="dense"
    )
)

print(product_region_summary)
Select the best product in every region:
regional_winners = product_region_summary.loc[
    product_region_summary["Regional_Rank"] == 1
]

print(regional_winners)
This example illustrates an important analytical distinction. The ranking should be applied at the level of the business entity that management wants to compare. If management wants product performance, aggregate transactions to Product level before ranking. If management wants transaction performance, rank transactions directly.
This concept can be generalized:
Question
   ↓
What entity is being compared?
   ↓
Aggregate to that entity if required
   ↓
Calculate the metric
   ↓
Rank or sort
   ↓
Select the required records
Suppose the company now wants the Top 2 products in each region. You can use the same regional rank:
top_2 = product_region_summary.loc[
    product_region_summary["Regional_Rank"] <= 2
]

print(top_2)
But if ties exist, the number of products returned for a region may be greater than two. This is often desirable when the business wants all products sharing a qualifying rank.
If exactly two products are required, sort within each region and take two rows:
top_2_exact = (
    product_region_summary
    .sort_values(
        by=["Region", "Sales", "Product"],
        ascending=[True, False, True]
    )
    .groupby("Region")
    .head(2)
)

print(top_2_exact)
The Product column acts as a deterministic tie-breaker.
Now imagine the company wants to compare the Top product in each region by its share of regional sales. Calculate the regional total:
regional_total = (
    product_region_summary
    .groupby("Region")["Sales"]
    .transform("sum")
)

product_region_summary["Regional_Share"] = (
    product_region_summary["Sales"] /
    regional_total * 100
)
Now the leaderboard contains both absolute sales and relative regional contribution.
print(
    product_region_summary.sort_values(
        by=["Region", "Regional_Rank"]
    )
)
This is a more informative analytical result because a product with ₹100,000 sales means something different in a region generating ₹1,000,000 than in a region generating ₹150,000.
Relative metrics can therefore complement absolute rankings.
Another case study involves employee performance. Suppose the HR department wants to identify employees who are above their department's average performance.
employees["Department_Average"] = (
    employees
    .groupby("Department")["Performance"]
    .transform("mean")
)

above_department_average = employees.loc[
    employees["Performance"] >
    employees["Department_Average"]
]

print(above_department_average)
Now rank those employees within their department:
above_department_average["Rank"] = (
    above_department_average
    .groupby("Department")["Performance"]
    .rank(
        ascending=False,
        method="dense"
    )
)
When creating a new DataFrame from a filtered subset, using copy() is safer:
above_department_average = employees.loc[
    employees["Performance"] >
    employees["Department_Average"]
].copy()

above_department_average["Rank"] = (
    above_department_average
    .groupby("Department")["Performance"]
    .rank(
        ascending=False,
        method="dense"
    )
)
This creates an independent analytical object and avoids ambiguity about whether a modification is being applied to a view or the original data.
Now sort the final result:
above_department_average = (
    above_department_average
    .sort_values(
        by=["Department", "Rank", "Performance"],
        ascending=[True, True, False]
    )
)

print(above_department_average)
This produces a structured departmental leaderboard.
A similar process can be used for student analytics. Suppose a school wants to identify the top students within each class:
students = pd.DataFrame({
    "Student": [
        "Aman", "Priya", "Rahul", "Neha",
        "Karan", "Sonia", "Arjun", "Meena"
    ],
    "Class": [
        "10A", "10A", "10A", "10A",
        "10B", "10B", "10B", "10B"
    ],
    "Marks": [
        88, 94, 82, 94,
        91, 85, 91, 78
    ]
})
Rank students within each class:
students["Class_Rank"] = (
    students
    .groupby("Class")["Marks"]
    .rank(
        ascending=False,
        method="dense"
    )
)

print(students)
Find the class toppers:
class_toppers = students.loc[
    students["Class_Rank"] == 1
]

print(class_toppers)
If two students have the same highest marks, both may receive rank 1. That may be exactly what the school wants if the purpose is to identify all students sharing the top score.
Alternatively, if the school must select one student for an award, it needs a documented tie-breaker such as attendance, project score, or another approved criterion. The analyst should not invent such a rule.
This principle applies across domains. Whenever ties matter, the ranking methodology should reflect the business or organizational rule rather than a hidden technical choice.
Another useful technique is ranking by percentage contribution. Suppose a set of products has total revenue:
products = pd.DataFrame({
    "Product": [
        "Laptop", "Mobile", "Tablet",
        "Monitor", "Keyboard"
    ],
    "Revenue": [
        300000, 220000, 150000,
        90000, 40000
    ]
})

products["Revenue_Share"] = (
    products["Revenue"] /
    products["Revenue"].sum() * 100
)

products = products.sort_values(
    by="Revenue_Share",
    ascending=False
)

print(products)
You can then calculate cumulative contribution:
products["Cumulative_Share"] = (
    products["Revenue_Share"].cumsum()
)

print(products)
This can support Pareto-style analysis. For example, you may discover that a relatively small number of products contribute a large proportion of total revenue.
Ranking is therefore not limited to simply creating a “Rank” column. It can support deeper analytical questions about concentration, contribution, segmentation, and priority.
Another important consideration is whether the ranking should be calculated before or after filtering.
Suppose you calculate a global rank first:
employees["Global_Rank"] = (
    employees["Performance"]
    .rank(
        ascending=False,
        method="dense"
    )
)
Then filter Analytics employees:
analytics = employees.loc[
    employees["Department"] == "Analytics"
]
The Global_Rank still reflects the entire organization.
If you instead filter first and rank second:
analytics = employees.loc[
    employees["Department"] == "Analytics"
].copy()

analytics["Analytics_Rank"] = (
    analytics["Performance"]
    .rank(
        ascending=False,
        method="dense"
    )
)
The new rank reflects only Analytics employees.
These results answer different questions. This distinction is easy to miss and can lead to incorrect conclusions in real projects.
When documenting a ranking, state whether it is global, regional, departmental, category-level, or based on another population.
Sorting and ranking also interact with indexes. After filtering and sorting, the original index labels may remain in their previous order.
result = (
    employees
    .sort_values(
        by="Performance",
        ascending=False
    )
)

print(result.index)
If you need a clean sequential index for presentation:
result = result.reset_index(
    drop=True
)

print(result)
Resetting the index is useful when exporting a final report or preparing a clean table for visualization. However, do not reset the index automatically if the existing index contains meaningful identifiers that you still need.
For example, if the index represents a unique record ID, removing it may discard useful information. Always understand the role of the index before changing it.
A complete report-preparation workflow might therefore be:
report = (
    employees.loc[
        employees["Performance"] >= 80,
        [
            "Employee_ID",
            "Name",
            "Department",
            "Salary",
            "Performance"
        ]
    ]
    .copy()
)

report["Rank"] = (
    report["Performance"]
    .rank(
        ascending=False,
        method="dense"
    )
)

report = (
    report
    .sort_values(
        by=["Rank", "Salary"],
        ascending=[True, False]
    )
    .reset_index(drop=True)
)

print(report)
This creates a clean report containing only employees meeting the threshold, assigns a rank, sorts the result, applies a tie-breaker, and resets the presentation index.
This is a strong practical example because it combines several skills into one readable workflow.
For SEO and AI-search-friendly learning, the core concepts can be summarized clearly: Pandas sort_values() sorts rows by one or more column values; sort_index() sorts by index labels; rank() assigns relative positions; nlargest() and nsmallest() retrieve extreme values efficiently; group-wise ranking is created with groupby() followed by rank(); and tie handling should be selected according to the analytical requirement.
These definitions are useful because they connect the function name directly to its purpose. When learning Pandas, understanding what a function accomplishes is more valuable than memorizing syntax without context.
A professional analyst should also be able to explain the result in plain language. For example:
“The Top 10 products were identified by total completed-order revenue, sorted in descending order. Products tied at the cutoff were resolved using profit as the secondary criterion.”
This explanation is much more useful to a stakeholder than simply saying that sort_values() was used.
Similarly:
“Employees were ranked within their departments based on performance score, with dense ranking used for tied scores.”
This tells the stakeholder exactly how the ranking was produced.
When building AI-assisted analytics workflows, clear definitions are equally important. An AI system can generate Pandas syntax, but the analyst still needs to provide the correct business definition, population, metric, and tie-handling rule. Technical code generation cannot replace analytical judgment.
For this reason, treat Pandas functions as implementation tools rather than substitutes for reasoning.
Before using a ranking in a business decision, ask:

What exactly is being ranked?
Which population is included?
What metric determines the rank?
Should high or low values receive rank 1?
How should ties be handled?
How should missing values be treated?
Does the ranking need to be global or group-specific?
Does the stakeholder want exactly N rows or all observations within the top N ranks?

Answering these questions prevents many common mistakes.
For example, a Top 10 report may accidentally include cancelled transactions if the analyst does not filter them first. A salary ranking may place missing values in an unexpected location. A regional Top 3 report may return more than three records because of ties. A department ranking may accidentally be calculated globally.
All of these problems are technically possible even when the Python code runs without an error.
Therefore, successful Data Analytics requires both correct syntax and correct analytical interpretation.
A final practical challenge is to build a reusable function:
def top_n_by_metric(
    df,
    metric,
    n=10
):
    return (
        df
        .sort_values(
            by=metric,
            ascending=False
        )
        .head(n)
    )
Now you can use it with different metrics:
top_salary = top_n_by_metric(
    employees,
    "Salary",
    5
)

top_performance = top_n_by_metric(
    employees,
    "Performance",
    5
)

print(top_salary)
print(top_performance)
This demonstrates how analytical logic can be converted into reusable components.
You can make the function more flexible by adding multiple sorting columns and directions, but always keep the function understandable. Reusable code is valuable when the same analytical operation is performed repeatedly across datasets or reporting periods.
Another useful function can create a group-wise ranking:
def rank_within_group(
    df,
    group_column,
    metric_column
):
    result = df.copy()

    result["Rank"] = (
        result
        .groupby(group_column)[metric_column]
        .rank(
            ascending=False,
            method="dense"
        )
    )

    return result
Use it like this:
ranked = rank_within_group(
    employees,
    "Department",
    "Performance"
)

print(ranked)
This example shows how a commonly repeated analytical operation can be encapsulated in a function.
When creating reusable functions, validate inputs and document assumptions in production projects. For learning purposes, the function above is enough to demonstrate the concept.
Finally, remember that sorting is often a presentation step, while ranking can become an analytical feature in its own right. A sorted DataFrame tells you which rows appear first according to a criterion. A rank column allows you to compare relative positions, filter by rank, calculate group-wise leaders, and build leaderboard-style reports.
Both are essential in modern Data Analytics workflows.
Lesson recap: In Pandas, use sort_values() when you need to order records by column values, sort_index() when you need to order by index labels, rank() when you need relative positions, nlargest() and nsmallest() for straightforward extreme-value selection, and groupby() with rank() for within-group comparisons. Combine these operations with filtering, aggregation, calculated metrics, and validation to create reliable analytical reports.
The strongest habit to develop is to define the business question before writing the sorting or ranking code. Once the metric, population, direction, tie rule, and missing-value treatment are clear, Pandas provides a straightforward way to implement the analysis.