In the previous lesson, you learned the fundamentals of Pandas in Python, including what Pandas is, why it is useful for Data Analytics, how to create a DataFrame, and how to inspect a dataset. You also performed your first calculations and learned that effective data analysis begins with a clear question and a systematic understanding of the data.
In this lesson, we move deeper into one of the most fundamental Pandas data structures: the Pandas Series.
If a DataFrame is similar to a complete table, a Series can be understood as a single labeled column of that table. Learning Series properly is important because many DataFrame operations eventually work with individual Series objects. When you select one column from a DataFrame, the result is commonly a Series.
Understanding this relationship will make later topics such as filtering, indexing, sorting, statistical analysis, missing-value handling, and DataFrame manipulation much easier to understand.
At first, a Series may appear simple. It contains values and an index. But this simple structure provides many capabilities that make Pandas powerful for data analysis.
A Pandas Series is a one-dimensional labeled data structure that can store values along with an index. The values may represent numbers, text, Boolean values, dates, or other supported data types.
Consider this simple Series:
import pandas as pd
sales = pd.Series([25000, 32000, 18000, 45000])
print(sales)The output will look similar to:
0 25000
1 32000
2 18000
3 45000
dtype: int64There are three important pieces of information in this output.
The values on the left, 0, 1, 2, and 3, are the indexes.
The values on the right, 25000, 32000, 18000, and 45000, are the actual data.
The final line indicates the data type of the Series.
By default, Pandas creates a numerical index beginning at zero when you do not provide one yourself.
You can think of the structure like this:
| Index | Sales |
|---|---|
| 0 | 25000 |
| 1 | 32000 |
| 2 | 18000 |
| 3 | 45000 |
This looks similar to a single column in a spreadsheet, but there is an important difference: the Series is a Python object that can be manipulated programmatically.
You may wonder why you need to learn Series when the main focus of Data Analytics is often the DataFrame.
The answer is simple: DataFrames are built from Series-like columns.
Suppose you create this DataFrame:
data = {
"Name": ["Aman", "Priya", "Rahul"],
"Age": [21, 23, 22],
"Marks": [82, 91, 76]
}
df = pd.DataFrame(data)If you select the Marks column:
marks = df["Marks"]
print(marks)you get a Series.
The result is similar to:
0 82
1 91
2 76
Name: Marks, dtype: int64This means that when you work with an individual DataFrame column, you are frequently working with a Series.
For example, the following operation:
df["Marks"].mean()works because df["Marks"] is a Series and the Series provides the mean() method.
Therefore, learning Series gives you a better understanding of what happens when you manipulate individual DataFrame columns.
Beginners often ask an important question: if a Python list can store values, why do we need a Pandas Series?
A Python list is a general-purpose data structure:
sales = [25000, 32000, 18000, 45000]This is useful for storing values, but it does not automatically provide the same data-analysis functionality as a Series.
A Series provides labels, data-type information, alignment behavior, and many analytical operations.
| Python List | Pandas Series |
|---|---|
| General-purpose collection | Data-analysis-oriented structure |
| No built-in analytical index | Has an index |
| Basic operations | Many analytical operations |
| Less convenient for labeled data | Designed for labeled data |
| Part of core Python | Part of Pandas |
For example, calculating an average from a Python list generally requires another function or library:
sales = [25000, 32000, 18000, 45000]
average = sum(sales) / len(sales)
print(average)With a Pandas Series, you can write:
sales = pd.Series([25000, 32000, 18000, 45000])
print(sales.mean())The Series is designed specifically for this kind of analytical operation.
The simplest way to create a Series is to pass a Python list to pd.Series().
import pandas as pd
marks = pd.Series([78, 85, 92, 67, 88])
print(marks)Pandas automatically creates the index:
0 78
1 85
2 92
3 67
4 88
dtype: int64This means the first value has index 0, the second has index 1, and so on.
You can inspect the values separately:
print(marks.values)And you can inspect the index:
print(marks.index)Depending on the Pandas version, the representation of these objects may differ slightly, but conceptually the Series contains two important components: values and labels.
Another useful method is creating a Series from a Python dictionary.
sales = {
"January": 25000,
"February": 32000,
"March": 18000,
"April": 45000
}
monthly_sales = pd.Series(sales)
print(monthly_sales)The output will be:
January 25000
February 32000
March 18000
April 45000
dtype: int64Here, the dictionary keys automatically become the Series index.
This can be extremely useful for summary data where meaningful labels already exist.
For example, monthly sales naturally have labels such as January, February, March, and April. Using those labels makes the Series easier to understand than a simple sequence of numbers.
You can also provide your own index explicitly.
marks = pd.Series(
[82, 91, 76, 88],
index=["Aman", "Priya", "Rahul", "Neha"]
)
print(marks)The resulting Series is:
Aman 82
Priya 91
Rahul 76
Neha 88
dtype: int64Now the student names are labels for the corresponding marks.
This allows you to access a student’s marks using the label:
print(marks["Priya"])The result is:
91This is one of the major differences between a basic Python list and a Pandas Series. A Series can associate meaningful labels with its values.
Labels become increasingly valuable as datasets become more complex.
Imagine a monthly revenue Series:
revenue = pd.Series(
[120000, 145000, 132000, 168000],
index=["January", "February", "March", "April"]
)Now you can ask questions directly using meaningful labels.
print(revenue["March"])This returns:
132000Rather than thinking only in terms of position, you can work with the business meaning of the data.
This becomes particularly useful when you work with dates, categories, financial periods, geographical regions, or other labeled information.
The index is one of the most important concepts in Pandas.
Every Series has an index. If you do not specify one, Pandas creates a default numerical index.
sales = pd.Series([100, 200, 300])
print(sales.index)The index will represent the positions 0, 1, and 2.
You can create a custom index:
sales = pd.Series(
[100, 200, 300],
index=["A", "B", "C"]
)
print(sales.index)Now the labels are A, B, and C.
It is important to understand that an index is a set of labels, not necessarily a sequence of unique numbers. Depending on the structure of your data, indexes can contain strings, dates, and in some situations duplicate labels.
For beginners, however, the most important principle is this:
A Pandas Series stores data together with labels that identify the data.
Suppose we have:
sales = pd.Series(
[12000, 15000, 18000],
index=["North", "South", "West"]
)You can access the South value using:
print(sales["South"])The result is:
15000This type of access is intuitive because the label has business meaning.
For example, instead of remembering that South is at position 1, you can directly refer to the label South.
You can also access values according to their position.
For example:
print(sales.iloc[1])This accesses the value at position 1.
The result is:
15000The iloc accessor is based on integer position. It is particularly useful when you want to work with the first, second, third, or another positional element regardless of the actual label.
This distinction between label-based access and position-based access becomes extremely important in Pandas.
A Series generally contains values of a particular data type, although Pandas supports a wide range of data representations.
For example:
ages = pd.Series([21, 25, 30, 28])
print(ages.dtype)This may produce an integer data type.
A decimal Series may use a floating-point type:
prices = pd.Series([120.50, 450.75, 999.99])
print(prices.dtype)A text Series may have an object or string-related dtype depending on how it was created and which Pandas features are being used:
cities = pd.Series(["Delhi", "Dehradun", "Mumbai"])
print(cities.dtype)Understanding the data type is important because it influences what operations make sense.
For example, calculating the average of numerical data is meaningful:
ages.mean()But calculating the average of city names is not.
One of the advantages of Pandas Series is that you can perform operations directly on the entire Series.
Suppose:
sales = pd.Series([10000, 15000, 20000, 25000])You can add a value to every element:
print(sales + 1000)You can multiply every value:
print(sales * 2)You can divide every value:
print(sales / 2)This is called vectorized operation. Instead of writing a loop that processes each value individually, you can apply an operation directly to the Series.
This style of programming is one of the reasons Pandas is convenient for data analysis.
Series objects provide many useful statistical methods.
For example:
sales = pd.Series([10000, 15000, 20000, 25000, 30000])
print("Total:", sales.sum())
print("Average:", sales.mean())
print("Minimum:", sales.min())
print("Maximum:", sales.max())
print("Median:", sales.median())These operations can provide a quick summary of numerical data.
You can also calculate the number of values:
print(sales.count())It is important to understand that count() and len() can behave differently when missing values are present. The count() method counts non-missing values, while len() counts the total number of elements in the Series.
This distinction becomes especially important during data cleaning.
Series also support comparison operations.
Suppose:
marks = pd.Series([45, 78, 92, 61, 35])You can ask which values are greater than 60:
print(marks > 60)The result is a Boolean Series:
0 False
1 True
2 True
3 True
4 False
dtype: boolThis is an important concept because Boolean Series are the foundation of filtering data in Pandas.
The expression does not immediately return only the matching marks. Instead, it creates a True/False mask indicating which values satisfy the condition.
Later, we can use that Boolean Series to select only the values that meet the condition.
Imagine that an instructor wants to analyze the marks of a group of students.
marks = pd.Series(
[72, 88, 91, 64, 55, 79, 93, 48],
index=[
"Aman", "Priya", "Rahul", "Neha",
"Vikas", "Sonia", "Karan", "Ritu"
]
)
print(marks)The instructor can calculate the average:
print(marks.mean())Find the highest score:
print(marks.max())Find the lowest score:
print(marks.min())Find the median:
print(marks.median())And identify students whose marks are above 80:
print(marks[marks > 80])The last expression combines a Boolean condition with Series selection. This is an important pattern that you will use repeatedly throughout the Pandas course.
At this point, the Series may appear to be a simple structure, but it contains several ideas that will repeatedly appear in more advanced Pandas work:
These concepts are not isolated features. They are part of a larger data-analysis model.
When you select a DataFrame column, you generally obtain a Series. When you filter a DataFrame, you often create Boolean conditions involving Series. When you calculate statistics for a column, you are using Series methods.
Therefore, understanding Series makes the behavior of DataFrames much easier to understand.
Create a Series containing the monthly sales of a business for six months.
sales = pd.Series(
[120000, 145000, 132000, 168000, 155000, 181000],
index=[
"January", "February", "March",
"April", "May", "June"
]
)Now perform these tasks:
Do not simply copy the commands. Try to understand what each expression is asking Pandas to do.
For example, if you write:
sales.mean()you should be able to explain that the operation calculates the arithmetic mean of the values contained in the Series.
If you write:
sales[sales > 150000]you should understand that the inner expression creates a Boolean condition and the outer selection keeps only the values for which the condition is True.
That ability to explain your own code is an important part of becoming a professional Data Analyst.
In the next section, we will go deeper into Series indexing and selection. You will learn how to retrieve individual values, work with labels and positions, use loc and iloc, slice Series, and modify values safely.
In the first part of this lesson, you learned what a Pandas Series is, why it is important, how it differs from a Python list, and how to create Series using lists, dictionaries, and custom indexes. You also learned that a Series contains both values and labels, and that Series supports mathematical, statistical, and comparison operations.
Now we will focus on one of the most important practical skills in Pandas: selecting data from a Series.
Data analysis rarely requires you to use every value in a dataset at the same time. You may need one student’s marks, a particular month’s revenue, a group of customers, the first five records, or values that satisfy a specific condition.
Pandas provides several ways to perform these operations. The most important concepts in this section are indexing, label-based selection, position-based selection, loc, iloc, slicing, Boolean filtering, and updating values.
Every Pandas Series has an index. If you do not provide one, Pandas creates a default integer index starting from zero.
import pandas as pd
sales = pd.Series([12000, 18000, 15000, 22000])
print(sales)The Series looks approximately like:
0 12000
1 18000
2 15000
3 22000
dtype: int64Here, the index values are 0, 1, 2, and 3.
You can access a value using its label:
print(sales[0])This returns:
12000For a simple default index, the label and the position appear to be the same. However, this can become confusing when you use custom indexes. Understanding the distinction between label and position is therefore essential.
The loc accessor is used for label-based selection.
Consider a monthly sales Series:
sales = pd.Series(
[120000, 145000, 132000, 168000],
index=["January", "February", "March", "April"]
)You can select March using:
print(sales.loc["March"])The result is:
132000The important point is that loc works with the label.
Here:
sales.loc["March"]means:
Find the Series element whose index label is March.
This becomes particularly useful when your index contains meaningful labels such as dates, customer IDs, product codes, or region names.
The iloc accessor is used for position-based selection.
Using the same Series:
print(sales.iloc[2])This returns:
132000Why?
The positions are:
| Position | Label | Sales |
|---|---|---|
| 0 | January | 120000 |
| 1 | February | 145000 |
| 2 | March | 132000 |
| 3 | April | 168000 |
Position 2 corresponds to March.
The key distinction is:
loc → labels
iloc → integer positions
Remembering this distinction will prevent many indexing mistakes later.
You can select multiple labels using loc.
print(sales.loc[["January", "March"]])This returns a new Series containing only January and March.
Similarly, you can select multiple positions using iloc:
print(sales.iloc[[0, 2]])This returns the values at positions 0 and 2.
The double brackets are important because you are passing a list of labels or positions.
You can use slicing to select a range of positions.
print(sales.iloc[0:3])This selects positions 0, 1, and 2.
As in standard Python slicing, the ending position is excluded.
Therefore:
sales.iloc[0:3]means:
Start at position 0 and stop before position 3.
You can also select from a particular position to the end:
print(sales.iloc[2:])This returns March and April.
You can select everything before a position:
print(sales.iloc[:2])This returns January and February.
Label-based slicing behaves somewhat differently because labels are involved.
print(sales.loc["January":"March"])This selects January through March, including both endpoints when the labels are present and the index is appropriate for label slicing.
This is an important difference from ordinary Python positional slicing, where the ending position is normally excluded.
When using label-based slicing, always think in terms of the actual labels rather than their numeric positions.
One of the most powerful Series operations is Boolean filtering.
Suppose we have:
marks = pd.Series(
[72, 88, 91, 64, 55, 79, 93, 48],
index=[
"Aman", "Priya", "Rahul", "Neha",
"Vikas", "Sonia", "Karan", "Ritu"
]
)We can ask which marks are greater than 80:
print(marks > 80)The result is a Boolean Series:
Aman False
Priya True
Rahul True
Neha False
Vikas False
Sonia False
Karan True
Ritu False
dtype: boolThis tells us which values satisfy the condition.
But usually, we want the actual matching values rather than True and False.
We can use:
print(marks[marks > 80])The result contains the students whose marks are greater than 80.
This is one of the most important patterns in Pandas:
series[condition]It means:
Return the values from the Series where the condition is True.
You can combine conditions using operators.
Suppose you want marks greater than 70 and less than 90.
filtered = marks[(marks > 70) & (marks < 90)]
print(filtered)In Pandas, use & for element-wise AND and | for element-wise OR.
For example, marks below 60 or above 90:
filtered = marks[(marks < 60) | (marks > 90)]
print(filtered)Parentheses are important when combining conditions.
Do not write:
marks > 70 and marks < 90for element-wise Series filtering. Python's normal and and or operators are not designed to perform this kind of element-by-element comparison on a Series.
You can use many comparison operators with a Series:
| Operator | Meaning |
|---|---|
| > | Greater than |
| < | Less than |
| >= | Greater than or equal to |
| <= | Less than or equal to |
| == | Equal to |
| != | Not equal to |
For example:
marks[marks >= 80]returns students with marks of at least 80.
Similarly:
marks[marks != 79]returns all values except the one equal to 79.
A Series is not simply a read-only structure. You can modify values.
Suppose:
sales = pd.Series(
[12000, 15000, 18000],
index=["North", "South", "West"]
)If the South sales value should actually be 16000, you can update it:
sales.loc["South"] = 16000
print(sales)The updated Series becomes:
North 12000
South 16000
West 18000
dtype: int64Using loc makes the intention clear because we are updating the value associated with the South label.
You can also modify multiple values based on a condition.
Suppose you want to increase all sales values below 15000 by 1000.
sales.loc[sales < 15000] = sales[sales < 15000] + 1000
print(sales)This demonstrates a powerful concept: selection and assignment can work together.
The condition identifies the relevant elements, and the assignment changes those elements.
In real data cleaning, similar patterns can be used to correct values, create categories, or apply business rules.
With labeled Series, you can assign a new label:
sales.loc["East"] = 21000
print(sales)Now East becomes another index label.
However, when working with larger analytical datasets, you should think carefully before adding values manually. In a real project, new records would generally come from the source dataset or a controlled data-ingestion process rather than being entered one by one.
You can remove a label using the drop() method.
sales = sales.drop("West")
print(sales)This returns a Series without the West entry.
By default, operations such as drop() generally return a new object rather than modifying the original Series in place. You can assign the result back to the variable:
sales = sales.drop("West")This is a useful pattern to understand because many Pandas operations return modified copies or transformed objects.
Sorting is another common analytical task.
sales = pd.Series(
[45000, 18000, 32000, 25000],
index=["North", "South", "East", "West"]
)
print(sales.sort_values())This sorts the values from smallest to largest.
To sort from largest to smallest:
print(sales.sort_values(ascending=False))This is useful when you want to identify the highest-performing or lowest-performing categories.
For example, if the Series represents regional revenue, descending order immediately shows which regions generated the most revenue.
You can also sort a Series according to its index labels.
print(sales.sort_index())If the index contains region names, this will arrange the labels alphabetically.
This is different from sorting by values.
sort_values() → sorts according to the data.
sort_index() → sorts according to the labels.
This distinction is simple but useful when preparing analytical outputs.
You can check whether a label exists in the index.
print("North" in sales.index)This returns:
TrueSimilarly:
print("Delhi" in sales.index)may return:
FalseThis can be useful when writing logic that depends on whether a particular label exists.
Consider a monthly revenue Series:
revenue = pd.Series(
[120000, 145000, 132000, 168000, 155000, 181000],
index=[
"January", "February", "March",
"April", "May", "June"
]
)Suppose the management team asks:
What was the revenue in April?
You can answer:
revenue.loc["April"]If they ask:
What was the revenue in the fourth position?
You can use:
revenue.iloc[3]If they ask:
Which months had revenue above 150,000?
You can use:
revenue[revenue > 150000]If they ask:
Show the three highest revenue values.
You can use:
revenue.sort_values(ascending=False).head(3)Notice how the business question determines the operation.
This distinction deserves special attention because it is one of the most common sources of confusion for beginners.
Consider:
sales = pd.Series(
[100, 200, 300],
index=[10, 20, 30]
)The labels are 10, 20, and 30, while the positions are 0, 1, and 2.
Therefore:
sales.loc[20]returns:
200because 20 is a label.
And:
sales.iloc[1]also returns:
200because position 1 contains the second value.
But:
sales.loc[1]does not mean the second position. It looks for the label 1, which does not exist in this Series.
This example clearly demonstrates why you should not assume that an index label is the same as a positional number.
Create the following Series:
salaries = pd.Series(
[45000, 52000, 68000, 39000, 75000, 61000],
index=[
"Amit", "Priya", "Rahul",
"Neha", "Karan", "Sonia"
]
)Complete these tasks:
After completing the exercise, explain in your own words the difference between loc and iloc.
Mistake 1: Confusing labels with positions.
If your Series uses custom labels, do not assume that loc[2] means the third element. It means the element whose label is 2.
Mistake 2: Forgetting parentheses around multiple conditions.
Use:
series[(series > 50) & (series < 100)]rather than attempting to use Python's ordinary and operator.
Mistake 3: Using the wrong column or label.
Labels are case-sensitive and must match the index values.
Mistake 4: Assuming filtering changes the original Series.
An expression such as:
sales[sales > 20000]returns a filtered result. It does not automatically mean that the original Series has been permanently changed.
Mistake 5: Modifying data without understanding the source.
In real projects, changing values should be based on documented business rules or verified data-quality information rather than guesses.
At the end of this section, you should be comfortable with the idea that a Pandas Series is more than a simple list of values.
It is a labeled analytical structure that allows you to:
The next part will build on this foundation by exploring Series data types, missing values, Boolean Series, mathematical operations, comparisons, and frequency analysis. These capabilities are essential when working with imperfect real-world data.
In the previous sections, you learned how to create a Pandas Series and how to access its values using labels, positions, loc, and iloc. You also learned how to filter values with conditions, update data, sort a Series, and work with indexes.
Now we will examine another critical part of working with Series: data types, missing values, mathematical operations, comparisons, and frequency analysis.
These concepts are essential because real-world data is rarely perfect. A dataset may contain numbers, text, missing values, Boolean values, dates, and other types of information. Before performing an analysis, you need to understand what type of data you are working with and whether any values are missing.
A technically correct Pandas command can still produce a misleading analytical result if the underlying data has been misunderstood. Therefore, data types and missing-value handling are not just programming details; they are part of responsible Data Analytics.
Every Pandas Series has a data type, commonly accessed using the dtype attribute.
import pandas as pd
ages = pd.Series([21, 24, 29, 35, 42])
print(ages.dtype)Because the values are whole numbers, Pandas will generally represent the Series using an integer data type.
For decimal values:
prices = pd.Series([125.50, 299.99, 450.75])
print(prices.dtype)Pandas will generally use a floating-point data type.
For text:
cities = pd.Series(["Delhi", "Dehradun", "Mumbai"])
print(cities.dtype)The exact representation of text data can depend on how the Series is constructed and the Pandas version and options being used. Modern Pandas also provides dedicated string and nullable data types.
The important principle is simple:
Always inspect the data type rather than assuming it from the column or Series name.
Suppose a sales column contains:
sales = pd.Series([10000, 15000, 20000])Calculating the average is straightforward:
print(sales.mean())But suppose the same values have been imported as text:
sales = pd.Series(["10000", "15000", "20000"])Now the Series contains strings rather than numerical values.
Before performing numerical analysis, the data may need to be converted into an appropriate numeric representation.
This issue frequently occurs when importing data from CSV files, Excel workbooks, databases, or systems where numbers have been stored as text.
For example, a value such as:
"₹45,000"is not automatically the same as the numerical value:
45000Currency symbols, commas, spaces, or other formatting can require cleaning before numerical calculations can be performed correctly.
There are several ways to understand how many elements a Series contains.
The len() function returns the total number of elements:
sales = pd.Series([10000, 15000, 20000, 25000])
print(len(sales))The result is:
4You can also use the Series count() method:
print(sales.count())For a Series without missing values, both may produce the same result.
However, they differ when missing values exist.
Missing data is one of the most common problems in real-world datasets.
Imagine a customer dataset where some customers have not provided their age:
ages = pd.Series([21, 25, None, 32, 29])
print(ages)Pandas will represent the missing value using a missing-data representation. Depending on the dtype and construction method, this may appear as NaN or another nullable representation.
The important point is that the third record does not contain an actual age value.
Missing data can occur for many reasons:
Missing data should therefore be investigated rather than automatically treated as an error.
The isna() method identifies missing values.
ages = pd.Series([21, 25, None, 32, 29])
print(ages.isna())The result is a Boolean Series indicating where missing values occur.
A simplified representation is:
0 False
1 False
2 True
3 False
4 FalseThe True value identifies the missing observation.
You can count missing values by combining isna() with sum():
print(ages.isna().sum())The result is:
1This is a very useful pattern in Data Analytics:
series.isna().sum()It means:
Identify missing values and count them.
The opposite operation is notna().
print(ages.notna())This returns True where values are present and False where values are missing.
You can count valid values:
print(ages.notna().sum())This can be useful when calculating data completeness.
Now compare:
print(len(ages))
print(ages.count())If the Series contains five positions but one is missing, the results may be:
5
4len() counts all elements, including the missing position.
count() counts non-missing values.
This distinction is important when assessing data quality.
No.
This is one of the most important principles in data cleaning.
If a dataset contains missing values, you should first understand why they are missing and how they affect the analysis.
Possible approaches include:
For example, if age is missing for a small number of customers, replacing the missing age with the average age might be reasonable in some analytical situations but inappropriate in others.
There is no universal rule that says every missing value must be filled with the mean.
Pandas Series support vectorized mathematical operations.
Consider:
sales = pd.Series([10000, 20000, 30000, 40000])You can add 5,000 to every value:
print(sales + 5000)Multiply every value by 2:
print(sales * 2)Divide every value by 100:
print(sales / 100)Subtract 1,000:
print(sales - 1000)This allows you to perform calculations across entire columns or Series without writing explicit Python loops.
Suppose a company wants to calculate a 10% increase in sales.
sales = pd.Series([10000, 20000, 30000])
new_sales = sales * 1.10
print(new_sales)Here, multiplying by 1.10 represents the original value plus 10%.
Similarly, to calculate a 15% discount:
discounted_sales = sales * 0.85
print(discounted_sales)These operations become especially useful when creating calculated business metrics.
Series provides several common statistical methods:
sales = pd.Series([10000, 15000, 20000, 25000, 30000])
print("Sum:", sales.sum())
print("Mean:", sales.mean())
print("Median:", sales.median())
print("Minimum:", sales.min())
print("Maximum:", sales.max())
print("Standard Deviation:", sales.std())These statistics provide different perspectives on the dataset.
Sum tells you the total.
Mean tells you the arithmetic average.
Median identifies the middle value after ordering the observations.
Minimum and maximum show the range endpoints.
Standard deviation provides information about how dispersed the values are around the mean.
Later lessons will explore statistical analysis more deeply, including when different measures are more appropriate.
Series also supports useful mathematical transformations.
changes = pd.Series([-5000, 2500, -1200, 4000])
print(changes.abs())This converts negative values into their absolute magnitude.
The result represents the size of the change without considering its direction.
This can be useful when analyzing differences, deviations, or absolute errors.
Suppose a calculation produces many decimal places:
prices = pd.Series([12.3456, 25.6789, 99.8765])
print(prices.round(2))The result rounds values to two decimal places.
Rounding is useful when presenting results, but analysts should be careful not to round too early during a calculation workflow if the underlying precision matters. It is often better to retain appropriate precision during calculations and round values when displaying final results.
Series supports comparison operators that produce Boolean results.
sales = pd.Series([10000, 25000, 18000, 42000])
print(sales > 20000)The result identifies which values are above 20,000.
You can then use the condition to filter the Series:
print(sales[sales > 20000])This pattern is fundamental to data analysis.
For example:
sales[sales >= 25000]selects values of at least 25,000.
Similarly:
sales[sales < 20000]selects values below 20,000.
You can combine conditions using element-wise logical operators.
For values between 15,000 and 30,000:
filtered = sales[(sales >= 15000) & (sales <= 30000)]
print(filtered)For values below 15,000 or above 30,000:
filtered = sales[(sales < 15000) | (sales > 30000)]
print(filtered)Again, remember to use parentheses around each condition.
Not all Series analysis is numerical. When a Series contains categories, value_counts() is particularly useful.
Consider:
regions = pd.Series([
"North", "South", "North", "East",
"South", "North", "West", "East"
])
print(regions.value_counts())The result tells you how many times each category appears.
This can answer questions such as:
Frequency analysis is particularly useful for categorical data.
You can also calculate proportions instead of raw counts.
print(regions.value_counts(normalize=True))This returns the relative frequency of each category.
For example, if North appears three times in a dataset containing ten records, its relative frequency would be 0.30, representing 30%.
You can convert proportions into percentages:
print(regions.value_counts(normalize=True) * 100)This can be useful when communicating category distributions.
Suppose an academy has the following course enrollment data:
courses = pd.Series([
"Python", "Excel", "Python", "Power BI",
"SQL", "Python", "Excel", "SQL",
"Python", "Power BI"
])Count enrollments:
print(courses.value_counts())Calculate percentages:
print(courses.value_counts(normalize=True) * 100)This allows an analyst to understand the distribution of enrollments across courses.
However, frequency alone does not tell us revenue. If different courses have different fees, we would need additional information to calculate revenue by course.
Again, this illustrates an important analytical principle: choose the metric that matches the question.
A Boolean Series contains True and False values.
marks = pd.Series([45, 78, 91, 64, 35])
passed = marks >= 50
print(passed)The resulting Series tells us which students meet the pass threshold.
We can count how many passed:
print(passed.sum())Why does this work?
In Boolean calculations, True is treated numerically as 1 and False as 0 in many aggregation contexts. Therefore, summing a Boolean Series counts the number of True values.
We can also calculate the pass percentage:
pass_percentage = passed.mean() * 100
print(pass_percentage)Because the mean of Boolean values represents the proportion of True values, this provides the percentage meeting the condition.
This is a powerful analytical technique that will appear frequently in Data Analytics.
Suppose an organization has employee performance scores:
performance = pd.Series(
[82, 67, 91, 74, 55, 88, 63, 95]
)The organization defines 70 as the performance threshold.
Create a Boolean condition:
above_target = performance >= 70Count employees above the target:
print(above_target.sum())Calculate the percentage:
print(above_target.mean() * 100)Display only employees meeting the target:
print(performance[above_target])This small example demonstrates how a Series can support a complete analytical question using only a few operations.
Consider:
sales = pd.Series([10000, 20000, None, 40000])
print(sales.mean())Pandas generally handles missing observations appropriately for many descriptive statistics by excluding missing values from the calculation.
However, you should never assume that missing values have no effect on the business interpretation.
Suppose 50% of a revenue column is missing. The calculated mean of the available values may be mathematically valid for those available records but still unsuitable as a representation of the complete business population.
This is why missing-value analysis should consider both the technical calculation and the business context.
A simple workflow is:
missing_count = sales.isna().sum()
print(missing_count)You can calculate the percentage of missing values:
missing_percentage = sales.isna().mean() * 100
print(missing_percentage)This is useful because the number of missing values alone does not always communicate the severity of the problem.
For example, 100 missing values in a dataset containing one million records may have a different analytical significance from 100 missing values in a dataset containing 200 records.
Create the following Series:
ratings = pd.Series(
[4.5, 3.8, None, 4.9, 2.5, 4.2, None, 3.9, 4.7]
)Complete the following tasks:
Then answer this analytical question:
Would you remove the missing ratings immediately?
A good answer should recognize that the correct decision depends on the purpose of the analysis, the amount of missing data, and the reason those ratings are missing.
Create another Series:
categories = pd.Series([
"Laptop", "Mobile", "Laptop", "Tablet",
"Mobile", "Laptop", "Tablet", "Mobile",
"Laptop", "Mobile"
])Use Pandas to:
Then explain why the most frequent category does not automatically mean it generated the highest revenue.
That distinction between frequency and financial performance is an important part of analytical thinking.
You have now seen that a Pandas Series can be used for much more than storing values.
It can help you inspect data types, identify missing observations, perform mathematical calculations, create Boolean conditions, filter values, calculate proportions, and analyze category frequencies.
These operations form the building blocks of more advanced DataFrame analysis.
When a DataFrame contains a column such as Sales, Age, Region, Product, or Customer Type, that column can generally be treated as a Series. The skills you are developing here will therefore transfer directly to larger datasets.
In the final part of this lesson, we will bring these concepts together through practical data-analysis scenarios. You will work with real-world-style Series, combine several operations, practice interpreting results, review common mistakes, complete exercises, and prepare for Pandas interview questions.
In the previous parts of this lesson, you learned how to create a Pandas Series, understand its index and data type, select values using labels and positions, filter values with conditions, handle missing observations, perform mathematical operations, and analyze categorical data with value_counts().
Now it is time to bring those concepts together. In professional Data Analytics, you rarely use one Pandas operation in isolation. Instead, you combine several operations to answer a business question, validate the data, and communicate the result.
This final part focuses on that complete analytical mindset. You will work through practical examples involving sales, student performance, customer ratings, and business metrics. You will also review common mistakes, complete hands-on exercises, prepare for interview questions, and summarize the most important concepts from the lesson.
Consider a company that wants to understand its monthly sales performance.
import pandas as pd
sales = pd.Series(
[125000, 142000, 138000, 175000, 162000, 189000,
155000, 198000, 210000, 184000, 225000, 240000],
index=[
"January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December"
]
)
print(sales)This Series contains one year of monthly sales.
The first step is to inspect the data:
print(sales.head())
print(sales.tail())
print(sales.dtype)
print(sales.count())These operations help us confirm that the data has been loaded correctly.
Now calculate total annual sales:
annual_sales = sales.sum()
print(annual_sales)Calculate average monthly sales:
average_monthly_sales = sales.mean()
print(average_monthly_sales)Find the highest monthly value:
highest_sales = sales.max()
print(highest_sales)Find the lowest monthly value:
lowest_sales = sales.min()
print(lowest_sales)These calculations provide the basic numerical summary of the business's sales performance.
Finding the highest value is useful, but management may also want to know which month produced that value.
We can use idxmax():
best_month = sales.idxmax()
print(best_month)This returns the index label associated with the largest value.
Similarly, we can find the month with the lowest sales:
worst_month = sales.idxmin()
print(worst_month)This is a useful analytical pattern:
series.max()returns the highest value, while:
series.idxmax()returns the label associated with that highest value.
The same idea applies to minimum values:
series.min()
series.idxmin()These methods are frequently useful when identifying the best-performing product, region, month, employee, or other category.
Suppose management wants to know which months performed better than the annual average.
First calculate the average:
average_sales = sales.mean()Then filter:
above_average = sales[sales > average_sales]
print(above_average)This returns only the months whose sales exceeded the average monthly sales.
We can count how many such months exist:
print(above_average.count())We can also calculate their percentage:
percentage_above_average = (
above_average.count() / sales.count()
) * 100
print(percentage_above_average)This gives management another useful perspective on performance distribution.
A more advanced but useful Series operation is diff().
monthly_change = sales.diff()
print(monthly_change)This calculates the difference between each value and the previous value.
The first month has no previous month, so its result will normally be missing.
For example, if January sales are 125,000 and February sales are 142,000, the February difference is:
142,000 − 125,000 = 17,000
This allows an analyst to examine whether sales increased or decreased from one period to the next.
Absolute change is useful, but percentage change often communicates growth more effectively.
Pandas provides pct_change():
growth = sales.pct_change()
print(growth)The resulting values represent the proportional change from the previous observation.
To display them as percentages:
growth_percentage = sales.pct_change() * 100
print(growth_percentage)This can answer questions such as:
Again, the first period normally has no previous period for comparison, so its percentage change will be missing.
We can identify the largest percentage increase:
growth = sales.pct_change()
largest_growth_month = growth.idxmax()
print(largest_growth_month)And the corresponding growth rate:
largest_growth = growth.max() * 100
print(largest_growth)This combines several Series concepts: transformation, missing values, indexes, and statistical selection.
Now consider a different use case.
marks = pd.Series(
[72, 88, 91, 64, 55, 79, 93, 48, 85, 67],
index=[
"Aman", "Priya", "Rahul", "Neha", "Vikas",
"Sonia", "Karan", "Ritu", "Arjun", "Meena"
]
)The average marks are:
average_marks = marks.mean()
print(average_marks)Find students above average:
above_average = marks[marks > average_marks]
print(above_average)Find students below the pass threshold of 50:
failed = marks[marks < 50]
print(failed)Count students who passed:
passed = marks >= 50
print(passed.sum())Calculate the pass percentage:
pass_percentage = passed.mean() * 100
print(pass_percentage)This example demonstrates how Boolean Series can become analytical metrics.
Use:
top_student = marks.idxmax()
print(top_student)And:
top_score = marks.max()
print(top_score)This gives us both the student and their score.
Similarly, the lowest-performing student can be identified using:
lowest_student = marks.idxmin()
print(lowest_student)This pattern is widely applicable to employee performance, customer scores, product ratings, and other indexed metrics.
Consider customer ratings for a service:
ratings = pd.Series(
[4.5, 3.8, 4.9, 2.5, 4.2, 3.9, 4.7, 4.1, 2.9, 4.8]
)Calculate the average rating:
print(ratings.mean())Find the highest rating:
print(ratings.max())Find the lowest rating:
print(ratings.min())Identify ratings above 4:
high_ratings = ratings[ratings > 4]
print(high_ratings)Calculate the percentage of ratings above 4:
percentage_high = (ratings > 4).mean() * 100
print(percentage_high)This last expression is particularly useful because it converts a Boolean condition directly into a percentage.
Suppose an online store records product categories for each order:
categories = pd.Series([
"Laptop", "Mobile", "Laptop", "Tablet",
"Mobile", "Laptop", "Tablet", "Mobile",
"Laptop", "Mobile", "Tablet", "Laptop"
])Count each category:
category_counts = categories.value_counts()
print(category_counts)Find the most frequent category:
most_common = categories.value_counts().idxmax()
print(most_common)Find the least frequent category:
least_common = categories.value_counts().idxmin()
print(least_common)Calculate percentages:
category_percentage = categories.value_counts(
normalize=True
) * 100
print(category_percentage)This can help analysts understand the composition of categorical data.
There is an important analytical limitation here.
Suppose laptops appear four times while mobile phones appear five times. We cannot conclude that mobile phones generated more revenue simply because they occurred more frequently.
To answer a revenue question, we need sales values associated with those transactions.
This is a general lesson:
The metric you calculate must match the question you are trying to answer.
Frequency answers “how often?”
Sum answers “how much in total?”
Mean answers “what is the average?”
Maximum answers “what is the largest value?”
Percentage answers “what proportion?”
Good Data Analysts select the metric according to the business problem.
You can combine several Series operations into a reusable function.
def analyze_series(series):
print("Count:", series.count())
print("Missing:", series.isna().sum())
print("Mean:", series.mean())
print("Median:", series.median())
print("Minimum:", series.min())
print("Maximum:", series.max())
analyze_series(marks)This example introduces the idea of creating reusable analytical functions.
Instead of writing the same calculations repeatedly, you can create a function that accepts a Series and produces a standard summary.
As your Python skills improve, you can build more sophisticated analytical utilities.
Suppose an employee performance Series contains:
performance = pd.Series([
82, 91, 76, None, 88, 95, None, 73
])Before calculating the average, check:
print(performance.isna().sum())If there are missing values, determine how many observations are actually available:
print(performance.count())Then calculate the mean:
print(performance.mean())The calculation may work, but your interpretation should mention that the average is based on the available observations rather than assuming that the missing records had the same distribution.
This habit becomes increasingly important when working with large organizational datasets.
1. Confusing Series and DataFrames
These are related but different structures. Selecting one DataFrame column with:
df["Sales"]usually produces a Series, while:
df[["Sales"]]produces a DataFrame containing one column.
This difference will become important when you learn more advanced selection techniques.
2. Confusing loc and iloc
loc works with labels, while iloc works with integer positions.
3. Ignoring missing data
A statistical result can be technically calculated but still require careful interpretation if substantial data is missing.
4. Using the wrong metric
Do not use frequency to answer a revenue question or an average to answer a maximum-value question.
5. Overwriting the original data unnecessarily
When cleaning or transforming data, it is often useful to preserve the original dataset or maintain a clearly documented transformation workflow.
6. Treating every unusual value as an error
An unusually high value may be a genuine business event. Always investigate before deleting or changing data.
Create this Series representing monthly website visitors:
visitors = pd.Series(
[12500, 14800, 13900, 17600, 19300, 22100,
20500, 23800, 25100, 22900, 26700, 28500],
index=[
"January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December"
]
)Complete the following tasks without looking for the solution first:
After completing the calculations, write a short business interpretation.
Your interpretation should answer questions such as:
This final step turns the exercise from a programming task into a Data Analytics task.
1. What is a Pandas Series?
A Pandas Series is a one-dimensional labeled data structure that stores values together with an index.
2. What is the difference between a Series and a DataFrame?
A Series is one-dimensional, while a DataFrame is two-dimensional and generally contains multiple Series-like columns.
3. How do you create a Series?
pd.Series([10, 20, 30])4. How do you create a Series with custom labels?
pd.Series(
[10, 20, 30],
index=["A", "B", "C"]
)5. What is the difference between loc and iloc?
loc selects according to labels, while iloc selects according to integer positions.
6. How do you find missing values?
series.isna()7. How do you count missing values?
series.isna().sum()8. How do you calculate the average of a Series?
series.mean()9. How do you find the largest value?
series.max()10. How do you find the label associated with the largest value?
series.idxmax()11. What does value_counts() do?
It counts the frequency of unique values in a Series.
12. How do you calculate category percentages?
series.value_counts(normalize=True) * 10013. How do you filter values greater than 50?
series[series > 50]14. How do you combine two conditions?
series[(series > 50) & (series < 100)]15. Why are parentheses used around conditions?
They make the individual Boolean expressions explicit and ensure that Pandas evaluates the element-wise conditions correctly.
16. What does count() do?
For a Series, count() counts non-missing values.
17. What does diff() do?
It calculates the difference between consecutive values.
18. What does pct_change() do?
It calculates the proportional change between consecutive observations.
19. Can a Series contain text?
Yes. A Series can contain text and categorical information as well as numerical data.
20. Why is a Series useful in Data Analytics?
It provides labeled data and convenient operations for selection, filtering, transformation, statistics, and other analytical tasks.
Can I use a Pandas Series without creating a DataFrame?
Yes. A Series is an independent Pandas data structure and can be created and analyzed directly.
Can a Series have custom indexes?
Yes. You can provide an index when creating a Series or modify the index later.
Can a Series contain missing values?
Yes. Missing values are common in real-world datasets, and Pandas provides tools for detecting and handling them.
What is the most important Series concept for beginners?
Understanding the relationship between values and indexes is fundamental. Once you understand labels, positions, filtering, and vectorized operations, many DataFrame operations become easier.
Should I memorize every Series method?
No. Focus first on understanding commonly used operations and the analytical problems they solve. Documentation and practice can help you discover less frequently used methods when required.
Is Series knowledge useful for DataFrames?
Yes. DataFrame columns are commonly represented as Series when selected individually, so Series concepts directly support DataFrame analysis.
A Pandas Series is a fundamental building block of Pandas. It provides a one-dimensional structure containing values and labels and supports a wide range of data-analysis operations.
In this lesson, you learned how to create Series from lists and dictionaries, assign custom indexes, access values using labels and positions, and distinguish between loc and iloc.
You also learned how to filter Series using Boolean conditions, update values, sort data, detect missing values, perform mathematical operations, calculate descriptive statistics, and analyze categorical frequencies using value_counts().
More importantly, you practiced using these operations to answer real analytical questions involving sales, student performance, customer ratings, product categories, and website traffic.
The key lesson is that Pandas is not about memorizing isolated commands. A Data Analyst begins with a question, understands the available data, chooses an appropriate operation, validates the result, and then interprets the outcome in context.
loc is used for label-based selection.iloc is used for position-based selection.dtype helps identify the type of data stored in a Series.isna() and notna() help identify missing and non-missing values.count() counts non-missing observations.value_counts() is useful for categorical frequency analysis.idxmax() and idxmin() help identify labels associated with extreme values.diff() can calculate changes between consecutive observations.pct_change() can calculate relative changes.You have now completed Lesson 2: Pandas Series. You have built an important foundation for the next stage of the course because DataFrame columns are commonly represented as Series when selected individually.
In Lesson 3, we will move from the one-dimensional Series to the two-dimensional Pandas DataFrame. You will learn how DataFrames are structured, how rows and columns work together, how to create DataFrames from different sources, how to inspect their properties, and how DataFrames become the central structure for real-world tabular Data Analytics.