DEV Community: Punitha

Python OOP

Punitha — Thu, 24 Sep 2026 08:41:20 +0000

What is OOP?

OOP stands for Object-Oriented Programming.
It is a programming approach where we organize programs using classes and objects.

Why Do We Use OOP?

Organize code

Reuse code

Reduce code duplication

Maintain large programs easily

Represent real-world entities

Improve code structure

What is a Class?

A class is a blueprint or template used to create objects.

class Student:
    pass

Student → Class

What is an Object?

An object is an instance of a class.

class Student:
    pass
student1 = Student()

Student → Class
student1 → Object

Class vs Object

Class                             Object

Blueprint                     Real instance
Defines structure             Uses that structure
Logical entity                    Physical/runtime entity
Example: Student              Example: student1

Creating a Class

We use the class keyword.

class Student:
    name = "Punitha"
    age = 22

Student → Class
name → Attribute
age → Attribute

Creating an Object

We create an object by calling the class.

class Student:
    name = "Punitha"
    age = 22
student1 = Student()
print(student1.name)
print(student1.age)

Output:
Punitha 22

Python Dictionary

Punitha — Wed, 23 Sep 2026 08:52:50 +0000

What is a Dictionary?

A Dictionary is a Python data structure used to store data in key-value pairs.

student = {
    "name": "Punitha",
    "age": 22,
    "course": "Data Analytics"
}
print(student)

Output
{'name': 'Punitha', 'age': 22, 'course': 'Data Analytics'}

Why Do We Use Dictionary?

Student information

Employee information

Product details

Customer details

JSON data

API data

Configuration data

Creating a Dictionary

We normally create a Dictionary using {}.

student = {
    "name": "Punitha",
    "age": 22,
    "course": "Python"
}
print(student)

Output
{'name': 'Punitha', 'age': 22, 'course': 'Python'}

Empty Dictionary

We can create an empty Dictionary using {}.

student = {}
student = dict()
print(student)

Output
{}

Accessing Dictionary Values

We can access a value using its key.

student = {
    "name": "Punitha",
    "age": 22,
    "course": "Python"
}
print(student["name"])
print(student["age"])
print(student["course"])

Output:
Punitha 22 Python

Using get()

We can also use get() to access a value.

student = {
    "name": "Punitha",
    "age": 22
}
print(student.get("name"))

Output:
Punitha

Adding New Items

We can add a new key-value pair.

student = {
    "name": "Punitha",
    "age": 22
}
student["city"] = "Chennai"
print(student)

Output:
{'name': 'Punitha', 'age': 22, 'city': 'Chennai'}

Updating Existing Values

If the key already exists, assigning a new value will update it.

student = {
    "name": "Punitha",
    "age": 22
}
student["age"] = 23
print(student)

Output
{'name': 'Punitha', 'age': 23}

Removing Items

There are different ways to remove dictionary items.

pop()

student = {
    "name": "Punitha",
    "age": 22,
    "city": "Chennai"
}
student.pop("age")
print(student)

Output:
{'name': 'Punitha', 'city': 'Chennai'}

pop() removes the specified key-value pair.

popitem()

popitem() removes the last inserted key-value pair.

student = {
    "name": "Punitha",
    "age": 22,
    "city": "Chennai"
}
student.popitem()
print(student)

Output:
{'name': 'Punitha', 'age': 22}

del

We can use del to remove a specific item.

student = {
    "name": "Punitha",
    "age": 22,
    "city": "Chennai"
}
del student["age"]
print(student)

Output:
{'name': 'Punitha', 'city': 'Chennai'}

clear()

clear() removes all items.

student = {
    "name": "Punitha",
    "age": 22
}
student.clear()
print(student)

Output:
{}

Dictionary Length

We can use len() to find the number of key-value pairs.

student = {
    "name": "Punitha",
    "age": 22,
    "city": "Chennai"
}
print(len(student))

Output:
3

Checking Keys

We can use in to check whether a key exists.

student = {
    "name": "Punitha",
    "age": 22
}
print("name" in student)
print("city" in student)

Output:
True False

Important Dictionary Methods

Method                       Purpose

keys()                       Returns all keys
values()                 Returns all values
items()                      Returns key-value pairs
get()                        Gets a value using a key
update()                 Adds or updates items
pop()                        Removes a specified item
popitem()                Removes the last item
clear()                      Removes all items
copy()                       Creates a copy

Nested Dictionary

A dictionary can contain another dictionary.

students = {
    "student1": {
        "name": "Punitha",
        "age": 22
    },
    "student2": {
        "name": "Anu",
        "age": 21
    }
}
print(students)

print(students["student1"]["name"])

Output:
Punitha

Dictionary with Different Data Types

Dictionary values can have different data types.

student = {
    "name": "Punitha",
    "age": 22,
    "marks": 85.5,
    "passed": True
}
print(student)

Dictionary Comprehension

Dictionary comprehension provides a short way to create a dictionary.

numbers = [1, 2, 3, 4, 5]
squares = {num: num ** 2 for num in numbers}
print(squares)

Output:
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Converting List to Dictionary

We can use dict() with pairs.

data = [
    ("name", "Punitha"),
    ("age", 22),
    ("city", "Chennai")
]
student = dict(data)
print(student)

Output:
{'name': 'Punitha', 'age': 22, 'city': 'Chennai'}

Dictionary vs List

List                        Dictionary

Stores values               Stores key-value pairs
Uses []                     Uses {}
Access using index      Access using key
Example students[0]     Example student["name"]
Ordered                     Ordered by insertion in modern Python
Duplicates allowed      Keys must be unique

Dictionary vs Set

Dictionary                Set

Stores key-value pairs        Stores values
{key: value}                  {value}
Access using key          No indexing
Keys must be unique       Values must be unique
Used for structured data      Used for unique data

Python Tuple

Punitha — Tue, 22 Sep 2026 11:53:33 +0000

What is a Tuple?

A Tuple is a collection of multiple values stored in a single variable.
A tuple is written using parentheses ().

numbers = (10, 20, 30, 40, 50)
print(numbers)

Output:
(10, 20, 30, 40, 50)

Why Do We Use Tuples?

Stores multiple values

Allows duplicate values

Maintains order

Supports indexing

Supports slicing

Cannot be modified after creation

Creating a Tuple

We can create a tuple using parentheses.

numbers = (1, 2, 3, 4, 5)
print(numbers)

Output:
(1, 2, 3, 4, 5)

Creating an Empty Tuple

We can create an empty tuple using ().

numbers = ()
print(numbers)

Output:
()

Tuple with Different Data Types

Integer

Float

String

Boolean

Tuple Indexing

Tuple elements can be accessed using indexes.
Python uses zero-based indexing.

numbers = (10, 20, 30, 40, 50)
print(numbers[0])

Output:
10

Negative Indexing

Python also supports negative indexes.

Value:       10    20    30    40    50
Positive:     0     1     2     3     4
Negative:    -5    -4    -3    -2    -1

numbers = (10, 20, 30, 40, 50)
print(numbers[-1])

Output:
50

Tuple Slicing

Slicing is used to get a portion of a tuple.

The syntax is:

tuple[start:stop:step]

numbers = (10, 20, 30, 40, 50)
print(numbers[1:4])

Output:
(20, 30, 40)

Looping Through a Tuple

We can use a for loop to access every element.

numbers = (10, 20, 30, 40)
for number in numbers:
    print(number)

Output:
10 20 30 40

Checking Whether an Element Exists

We can use the in operator.

numbers = (10, 20, 30, 40)
print(20 in numbers)

Output:
True

Finding Tuple Length

We can use the len() function to find the number of elements.

numbers = (10, 20, 30, 40, 50)
length = len(numbers)
print(length)

Output:
5

Tuple Methods

Tuples have fewer methods than lists because tuples cannot be modified.

count()
index()

count() Method

count() tells us how many times a value occurs in a tuple.

numbers = (10, 20, 20, 30, 20)
print(numbers.count(20))

Output:
3

index() Method

index() returns the position of the first occurrence of a value.

numbers = (10, 20, 30, 40)
print(numbers.index(30))

Output:
2

Tuple Packing

Tuple packing means putting multiple values into a tuple without explicitly using parentheses.

numbers = 10, 20, 30
print(numbers)

Output:
(10, 20, 30)

Tuple Unpacking

Tuple unpacking means assigning tuple elements to multiple variables.

numbers = (10, 20, 30)
a, b, c = numbers
print(a)
print(b)
print(c)

Output:
10 20 30

Nested Tuples

A tuple can contain another tuple.
This is called a nested tuple.

numbers = ((1, 2), (3, 4), (5, 6))
print(numbers)
print(numbers[0])

Output:
(1, 2)

Tuple Immutability

One of the most important features of a tuple is immutability.
Immutable means that after creating a tuple, we cannot change its elements.

numbers = (10, 20, 30)
numbers[0] = 100

This produces an error because tuple elements cannot be changed.

Converting List to Tuple

We can convert a list into a tuple using tuple().

numbers = [10, 20, 30, 40]
numbers_tuple = tuple(numbers)
print(numbers_tuple)

Output:
(10, 20, 30, 40)

Converting Tuple to List

We can convert a tuple into a list using list().

numbers = (10, 20, 30, 40)
numbers_list = list(numbers)
print(numbers_list)

Output:
[10, 20, 30, 40]

Tuple Concatenation

We can combine two tuples using the + operator.

a = (1, 2, 3)
b = (4, 5, 6)
result = a + b
print(result)

Output:
(1, 2, 3, 4, 5, 6)

Tuple Repetition

We can repeat tuple elements using the * operator.

numbers = (1, 2)
result = numbers * 3
print(result)

Output:
(1, 2, 1, 2, 1, 2)

Finding Minimum, Maximum and Sum

For tuples containing numbers, we can use min() and max().

numbers = (10, 20, 5, 40, 30)
print(min(numbers))
print(max(numbers))
print(sum(numbers))

Output:
5 40 105

Tuple vs List

List                     Tuple

Uses []                  Uses ()
Mutable                  Immutable
Can be changed           Cannot be changed
Supports indexing    Supports indexing
Supports slicing     Supports slicing
More methods             Fewer methods
Allows duplicates    Allows duplicates
Good for changing data   Good for fixed data

Tuple vs Set

Tuple                         Set

Uses ()                       Uses {}
Ordered                       Unordered
Supports indexing         Does not support indexing
Allows duplicates         Does not allow duplicates
Immutable                 Mutable
Supports slicing          No normal indexing/slicing
Good for fixed ordered data   Good for unique data

Important Tuple Functions and Methods

Function / Method    Purpose

tuple()                  Creates/converts to a tuple
len()                    Finds number of elements
count()                  Counts occurrences
index()                  Finds the first index
min()                    Finds minimum value
max()                    Finds maximum value
sum()                    Calculates total

Python Set

Punitha — Mon, 21 Sep 2026 10:07:32 +0000

What is a Set?

A Set is a collection of values in Python that:

Stores unique elements

Does not allow duplicate values

Is unordered

Can be modified

Is written using {}

Example

numbers = {1, 2, 3, 4, 5}
print(numbers)

Output:
{1, 2, 3, 4, 5}

Why Do We Use Sets?

remove duplicate values
find unique items
compare two collections
find common values
find differences between collections
perform mathematical set operations

Creating a Set

create a set using curly brackets {}.

numbers = {10, 20, 30, 40}
print(numbers)

Output:
{10, 20, 30, 40}

Creating an Empty Set

x = set()

print(x)

Output:
set()

Set with Different Data Types

A set can contain different data types.

data = {10, "Python", 20.5, True}

print(data)

A set can contain values such as:

Integer

Float

String

Boolean

Duplicate Values in a Set

The most important feature of a set is that it does not keep duplicate values.

numbers = {1, 2, 2, 3, 3, 4, 4}
print(numbers)

Output:
{1, 2, 3, 4}

Set Indexing

Sets are unordered, so we cannot access elements using indexes like a list.

numbers = {10, 20, 30, 40}
print(numbers[0])

This will result in an error because sets do not support indexing.

Adding Elements to a Set

There are two important methods for adding elements: >
add()
update()

add()

add() adds one element to a set.

numbers = {1, 2, 3}
numbers.add(4)
print(numbers)

Output:
{1, 2, 3, 4}

update()

update() adds multiple elements.

numbers = {1, 2, 3}
numbers.update([4, 5, 6])
print(numbers)

Result:
{1, 2, 3, 4, 5, 6}

Removing Elements from a Set

Python provides several methods for removing elements: >
remove()
discard()
pop()
clear()

remove()

remove() removes a specific element.

numbers = {1, 2, 3, 4}
numbers.remove(3)
print(numbers)

Output:
{1, 2, 4}

discard()

discard() also removes a specific element.

numbers = {1, 2, 3, 4}
numbers.discard(3)
print(numbers)

Output:
{1, 2, 4}

pop()

pop() removes and returns an arbitrary element from the set.

numbers = {10, 20, 30, 40}
x = numbers.pop()
print(x)
print(numbers)

clear()

clear() removes all elements from the set.

numbers = {1, 2, 3, 4}
numbers.clear()
print(numbers)

Output:
set()

Checking Elements in a Set

We can use the in operator to check whether an element exists.

numbers = {10, 20, 30, 40}
print(20 in numbers)

Output:
True

Looping Through a Set

We can use a for loop to access the elements of a set.

numbers = {10, 20, 30, 40}
for number in numbers:
    print(number)

Set Operations

Set operations are one of the most important parts of Sets.

The main operations are:

Union

Intersection

Difference

Symmetric Difference

Union

Union combines all unique elements from both sets. A = {1, 2, 3, 4} B = {3, 4, 5, 6}

Using union()

result = A.union(B)
print(result)

Output:
{1, 2, 3, 4, 5, 6}

Using | - All unique elements from both sets

result = A | B
print(result)

Intersection

Intersection returns the elements that are common to both sets.

Using intersection()

result = A.intersection(B)
print(result)

Output:
{3, 4}

Using & - Common elements

result = A & B

Difference

Difference returns elements that are present in the first set but not in the second set.

result = A.difference(B)
print(result)

Output:
{1, 2}

Using the '-' operator:

result = A - B

Symmetric Difference

Symmetric difference returns elements that are present in either set, but not in both.

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}
result = A.symmetric_difference(B)
print(result)

Output:
{1, 2, 5, 6}

Using ^:

result = A ^ B

Set Operations – Quick Table

Operation             Meaning              Operator

Union                     All unique elements            |
Intersection              Common elements            &
Difference            Elements only in first set     -
Symmetric Difference      Non-common elements            ^

Subset

A set is a subset if all its elements are present in another set.

A = {1, 2, 3, 4}
B = {1, 2}
print(B.issubset(A))

Output:
True

Superset

A set is a superset if it contains all elements of another set.

A = {1, 2, 3, 4}
B = {1, 2}
print(A.issuperset(B))

Output:
True

Disjoint Sets

Two sets are disjoint if they have no common elements.

A = {1, 2, 3}
B = {4, 5, 6}
print(A.isdisjoint(B))

Output:
True

Set Comprehension

Set comprehension is a short way to create a set using a loop-like expression.

Using Set Comprehension

numbers = [1, 2, 3, 4, 5]
squares = {number ** 2 for number in numbers}
print(squares)

Output:
{1, 4, 9, 16, 25}

Converting List to Set

One common use of sets is removing duplicates from a list.

numbers = [1, 2, 2, 3, 3, 4, 4]
unique_numbers = set(numbers)
print(unique_numbers)

Output:
{1, 2, 3, 4}

Converting Set to List

We can convert a set back into a list using list().

numbers = {1, 2, 3, 4}
numbers_list = list(numbers)
print(numbers_list)

Important Set Methods

Method                  Purpose

add()                   Adds one element
update()            Adds multiple elements
remove()            Removes an element; error if absent
discard()           Removes an element; no error if absent
pop()                   Removes an arbitrary element
clear()                 Removes all elements
union()                 Combines unique elements
intersection()          Finds common elements
difference()            Finds elements only in the first set
symmetric_difference()  Finds non-common elements
issubset()          Checks subset
issuperset()            Checks superset
isdisjoint()            Checks whether there are no common elements

Set vs List

List                       Set

Uses []                    Uses {}
Allows duplicates      Stores unique elements
Ordered                    Unordered
Supports indexing      Does not support indexing
Supports slicing       Does not support normal indexing/slicing
Good for sequence data     Good for unique data
Example [1,2,3]            Example {1,2,3}

Python List

Punitha — Fri, 18 Sep 2026 12:26:35 +0000

What is a List?

A List is a collection of multiple elements stored in a single variable.
Lists are written using square brackets [].

numbers = [1, 2, 3, 4, 5]

print(numbers)

Output:
[1, 2, 3, 4, 5]

Creating a List

There are different ways to create a list.

Creating an Empty List

We can create an empty list using [].

numbers = []

print(numbers)

numbers = list()

print(numbers)

Output:
[]

Creating a List with Values

We can directly provide values inside square brackets.

numbers = [1, 2, 3, 4, 5]

print(numbers)

Output:
[1, 2, 3, 4, 5]

List with Different Data Types

A Python list can contain different types of values.

numbers = [1, 2, 3, "a", "b", "c"]

print(numbers)

Output:
[1, 2, 3, 'a', 'b', 'c']

List Indexing

Indexing is used to access individual elements from a list.
Python uses zero-based indexing.

numbers = [10, 20, 30, 40, 50]

Output:
Value: 10 20 30 40 50 Index: 0 1 2 3 4

Access the first element

print(numbers[0])

Output:
10

Looping Through a List

We can use a for loop to access every element in a list.

numbers = [1, 2, 3, 4, 5]

for i in numbers:
    print(i)

Output:
1 2 3 4 5

List Slicing

Slicing is used to get a portion of a list.

Syntax

list[start:stop:step]

Example
numbers = [1, 2, 3, 4, 5]

Basic Slicing

print(numbers[1:4])

Output:
[2, 3, 4]

Start = 1

Stop = 4

Index 4 is not included

Slicing with Step

print(numbers[1:4:1])

Output:
[2, 3, 4]

Slicing from the Beginning

print(numbers[:4])

Output:
[1, 2, 3, 4]

Finding List Methods

Python provides many built-in methods for lists.

dir()

append()

insert()

extend()

pop()

clear()

reverse()

sort()

append() – Add an Element

append() adds one element to the end of a list.

numbers = [1, 2, 3, 4]

numbers.append(5)

print(numbers)

Output:
[1, 2, 3, 4, 5]

insert() – Add at a Specific Position

insert() adds an element at a specific index.

Syntax:

list.insert(index, value)

numbers = [1, 2, 3, 4]

numbers.insert(0, 10)

print(numbers)

Output:
[10, 1, 2, 3, 4]

extend() – Add Multiple Elements

extend() adds multiple elements to the end of a list.

numbers = [1, 2, 3, 4]

numbers.extend([6, 7, 8, 9])

print(numbers)

Output:
[1, 2, 3, 4, 6, 7, 8, 9]

pop() – Remove an Element

pop() removes an element from a list.

numbers = [1, 2, 3, 4]

numbers.pop()

print(numbers)

Output:
[1, 2, 3]

pop(index)

numbers = [1, 2, 3, 4]

numbers.pop(0)

print(numbers)

Output:
[2, 3, 4]

clear() – Remove All Elements

clear() removes all elements from the list.

numbers = [1, 2, 3, 4]

numbers.clear()

print(numbers)

Output:
[]

reverse() – Reverse a List

reverse() changes the order of elements.

numbers = [1, 2, 3, 4]

numbers.reverse()

print(numbers)

Output:

[4, 3, 2, 1]

sort() – Sort a List

sort() arranges the elements in ascending order.

numbers = [5, 2, 8, 1, 3]

numbers.sort()

print(numbers)

Output:

[1, 2, 3, 5, 8]

Descending Order

numbers.sort(reverse=True)

Example:

numbers = [5, 2, 8, 1, 3]

numbers.sort(reverse=True)

print(numbers)

Output:

[8, 5, 3, 2, 1]

Finding the Sum of a List

Python provides the sum() function to calculate the total of numeric values.

numbers = [1, 2, 3, 4]

total = sum(numbers)

print(total)

Output:

10

Updating List Elements

Lists are modifiable, so we can change individual elements.

Example:

numbers = [1, 2, 3, 4, 5]

numbers[0] = 0

print(numbers)

Output:

[0, 2, 3, 4, 5]

Finding the Length of a List

The len() function returns the number of elements in a list.

numbers = [1, 2, 3, 4, 5]

length = len(numbers)

print(length)

Output:

5

Performing Calculations on List Elements

We can use a loop to perform calculations on every element.

numbers = [1, 2, 3, 4, 5]

length = len(numbers)

for i in range(length):
    numbers[i] = numbers[i] ** 2

print(numbers)

Output:

[1, 4, 9, 16, 25]

Important List Methods

Method / Function   Purpose

append()            Adds an element at the end
insert()            Adds an element at a specific position
extend()            Adds multiple elements
pop()                   Removes an element
clear()                 Removes all elements
reverse()           Reverses the list
sort()                  Sorts the list
sum()                   Calculates the total
len()                   Finds the number of elements
dir()                   Shows available attributes/methods

String Operations

Punitha — Thu, 17 Sep 2026 08:28:49 +0000

Pandas provides string functions using .str.

Convert to lowercase

df["Name"] = df["Name"].str.lower()

Convert to uppercase

df["Name"] = df["Name"].str.upper()

Remove extra spaces

df["Name"] = df["Name"].str.strip()

Search text

result = df[df["Name"].str.contains("Arun")]

GroupBy

groupby() is one of the most important Pandas functions for data analysis.
It groups data based on a column.

result = df.groupby("Grade")["Marks"].mean()

print(result)

Aggregation

We can use multiple calculations with agg(), min() and max().

result = df["Marks"].agg(
    ["mean", "min", "max"]
)

print(result)

Combining Data with concat()

concat() is used to combine DataFrames.

df1 = pd.DataFrame({
    "Name": ["Arun", "Priya"]
})

df2 = pd.DataFrame({
    "Name": ["Ravi", "Kumar"]
})

result = pd.concat([df1, df2])

print(result)

Combining Data with merge()

merge() is similar to a SQL JOIN.

result = pd.merge(
    students,
    marks,
    on="Student_ID"
)

print(result)

join()

join() can also be used to combine DataFrames, commonly based on their indexes.

result = df1.join(df2)

Pivot Table

A pivot table is used to summarize data.

result = pd.pivot_table(
    df,
    values="Marks",
    index="Grade",
    aggfunc="mean"
)

print(result)

Apply Function

apply() is used to apply a function to DataFrame values.

df["Marks"] = df["Marks"].apply(lambda x: x + 5)

Selecting Rows, Missing Values and Duplicate Values

Punitha — Wed, 16 Sep 2026 09:41:13 +0000

loc[] is used to select rows and columns using labels.

print(df.loc[0])

print(df.loc[0, "Name"])

iloc[] selects data using integer positions.

print(df.iloc[0])

print(df.iloc[0, 0])

isin() checks whether values belong to a given list.

result = df[df["Name"].isin(["Arun", "Ravi"])]

print(result)

between() checks whether values are within a range.

result = df[df["Marks"].between(70, 90)]

print(result)

Renaming Columns

df = df.rename(
    columns={"Marks": "Score"}
)
print(df)

Sorting Data

Ascending

df = df.sort_values("Marks")

print(df)

Descending

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

print(df)

Missing Values

NaN means the value is missing.

Finding Missing Values

print(df.isnull())

print(df.isnull().sum())

Removing Missing Values

df = df.dropna()

Filling Missing Values

df["Marks"] = df["Marks"].fillna(0)

Duplicate Values

Find duplicates

print(df.duplicated())

Remove duplicates

df = df.drop_duplicates()

Exploring the Dataset

Punitha — Tue, 15 Sep 2026 08:44:53 +0000

Pandas provides several useful functions.

head()

Displays the first five rows by default.

print(df.head())

tail()

Displays the last five rows.

print(df.tail())

shape

Shows the number of rows and columns.

print(df.shape)

columns

Displays all column names.

print(df.columns)

dtypes

Shows the data type of each column.

print(df.dtypes)

info()

Provides important information about the DataFrame.

df.info()

Number of rows

Column names

Data types

Non-null values

Memory usage

describe()

Provides statistical information for numerical columns.

print(df.describe())

Count

Mean

Standard deviation

Minimum

Maximum

Quartiles

Pandas DataFrame

Punitha — Mon, 14 Sep 2026 12:49:46 +0000

A DataFrame is a two-dimensional data structure containing rows and columns.

Step 1:

Output:

Selecting Columns

We can select a single column using its column name.

print(df["Name"])

print(df["Name"])

Reading CSV Files

Pandas provides read_csv() to read CSV files.

import pandas as pd

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

print(df)

Reading Excel Files

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

print(df)

Pandas, Creating, and Accessing Series

Punitha — Sat, 12 Sep 2026 08:26:51 +0000

A Series is a one-dimensional data structure in Pandas.

Step 1: Pandas Series

Output:

Here:

0, 1, 2, 3 → index
80, 90, 75, 85 → values

Step 2: Creating Series with Custom Index

Output:

Step 3: Accessing Series Values

We can access individual values using their index.

Output:

Introduction and installing Pandas

Punitha — Fri, 11 Sep 2026 08:26:12 +0000

What is Pandas?

Pandas is a Python library used for working with and analyzing data.

It helps:

Store data in rows and columns

Read data from CSV and Excel files

Filter data

Sort data

Handle missing values

Group and summarize data

Combine different datasets

Analyze real-world data

Why Do We Use Pandas?

Pandas is mainly used for data analysis and data manipulation.

For example, we can use Pandas to:

Find the average marks

Find students who scored above 80

Remove duplicate records

Handle missing values

Sort students by marks

Group students by grade

Read a CSV dataset

Save the processed data into a new file

Installing Pandas

Open Command Prompt / Terminal and run:

pip install pandas

python -m pip install pandas

Import Pandas

After installation, import Pandas into your Python program.

import pandas as pd

Here:

pandas → library name
pd → commonly used short name for Pandas

Example

import pandas as pd

print(pd.__version__)

This displays the installed Pandas version.

Statistical Operations

Punitha — Thu, 10 Sep 2026 08:29:29 +0000

What is unique()?

np.unique() returns the unique values from an array.

Step 1:

Output:

What is Median?

The median is the middle value of the data after sorting.

Step 1:

Output:

What is Mean?

Mean is the average of the values.

Step 1:

Output:

What is Average?

NumPy also provides np.average().

Step 1:

Output: