Both lists and tuples store multiple items in an ordered sequence.
List: Mutable (can be modified)
Tuple: Immutable (cannot be modified after creation)
Lists are commonly used when data changes, while tuples are preferred for fixed values.

For Example :
my_list = [1, 2, 3]
my_list.append(4)
my_tuple = (1, 2, 3)
# my_tuple.append(4) ❌ Error

== compares whether two objects have the same value.
is checks whether both variables refer to the same object in memory.

For Example:
a = [1,2]
b = [1,2]
a == b # True
a is b # False

Mutable objects can be modified after they are created.
Immutable objects cannot be changed once created.

Mutable Examples
List
Dictionary
Set

Immutable Examples
Tuple
String
Integer
Float

Note: Understanding this concept helps avoid unexpected behavior when working with variables and functions.

Python provides several built-in data types for storing different kinds of information.

Integer (int) – 10
Float (float) – 10.5
String (str) – "Python"
Boolean (bool) – True, False
List (list) – [1, 2, 3]
Tuple (tuple) – (1, 2, 3)
Dictionary (dict) – {"Name": "John"}
Set (set) – {1, 2, 3}

Both methods add elements to a list, but they behave differently.

append() adds the entire object as a single element.
extend() adds each element from another iterable individually.

numbers = [1, 2]

numbers.append([3, 4])
print(numbers)
# [1, 2, [3, 4]]

numbers = [1, 2]
numbers.extend([3, 4])
print(numbers)
# [1, 2, 3, 4]

Unpacking is the process of assigning elements from a collection to multiple variables in a single statement.

name, age, city = ("Alice", 25, "Toronto")
print(name)
print(age)

Slicing allows you to extract a portion of a sequence such as a string, list, or tuple.

General Slicing Format
sequence[start:end:step]

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

print(numbers[1:4])
# [20, 30, 40]

Both statements control the flow of a loop, but they behave differently.

break immediately exits the loop.
continue skips the current iteration and moves to the next iteration.

for i in range(5):
if i == 3:
break
print(i)

# Output:
# 0
# 1
# 2

for i in range(5):
if i == 3:
continue
print(i)

# Output:
# 0
# 1
# 2
# 4

The pass statement is used as a placeholder when a statement is required syntactically, but no action is needed yet.

It is commonly used while writing functions, loops, or classes that will be implemented later.

def calculate_salary():
pass

This allows the program to run without producing an error.

Both loops are used to repeat a block of code.

for loop is used when the number of iterations is known or when iterating over a sequence.
while loop is used when the number of iterations is unknown and depends on a condition.

for i in range(5):
print(i)

count = 0

while count < 5: print(count) count += 1 Choose a for loop for fixed iterations and a while loop for condition-based repetition.

One simple approach is to use a set to track seen values.

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

seen = set()
duplicates = set()

for num in numbers:
if num in seen:
duplicates.add(num)
else:
seen.add(num)

print(duplicates)

# Output:
# {2, 3}

A nested loop is a loop inside another loop. It is useful when working with two-dimensional data, comparing elements, or generating combinations.

for i in range(3):
for j in range(2):
print(i, j)

Nested loops are commonly used when processing matrices, comparing every element with another element, or generating patterns.

A function is a reusable block of code designed to perform a specific task. It helps make programs more organized, readable, and easier to maintain.

def greet():
print("Welcome to SAI DataScience!")

greet()

Although they are often used interchangeably, they have different meanings.

Parameter: A variable defined in the function declaration.
Argument: The actual value passed when calling the function.

def greet(name): # name is a parameter
print("Hello", name)

greet("John") # "John" is an argument

The return statement sends a value back to the caller and ends the execution of the function.

def add(a, b):
return a + b
result = add(5, 3)
print(result)

Without return, a function returns None by default.

Default arguments allow you to assign a value to a parameter. If no argument is provided when calling the function, the default value is used.

def greet(name="Student"):
print("Hello", name)

greet()
greet("Alice")

A lambda function is a small anonymous function written in a single line. It is commonly used for short operations.

lambda arguments: expression
square = lambda x: x ** 2

print(square(5))

Lambda functions are often used with functions like map(), filter(), and sorted().

A local variable is created inside a function and can only be accessed within that function.
A global variable is created outside a function and can be accessed throughout the program.

message = "Welcome"

def greet():
name = "Alice"
print(message) # Global variable
print(name) # Local variable

greet()

Each collection type serves a different purpose:

List – Ordered and mutable.
Tuple – Ordered and immutable.
Set – Unordered and stores unique values.
Dictionary – Stores data as key-value pairs.

Choose the collection based on your data and use case.

List comprehension is a concise way to create a list using a single line of code.

numbers = [x * 2 for x in range(5)]
print(numbers)

It improves code readability and is commonly used in data analysis.

Use a dictionary when data has a unique key associated with each value.
student = {
"Name": "John",
"Age": 22
}
Dictionaries provide fast lookups using keys and are widely used for structured data.

One simple method is to convert the list into a set.
numbers = [1,2,2,3,4,4]
unique = list(set(numbers))

If preserving the original order is important, use:
unique = list(dict.fromkeys(numbers))

Both methods add elements to a list.
append() adds an item to the end of the list.
insert() adds an item at a specific position.

numbers = [1,2,3]

numbers.append(4)
numbers.insert(1,100)

You can reverse a string using slicing.

text = "Python"
print(text[::-1])

split() converts a string into a list.
join() combines a list into a single string.

text = "Python SQL Excel"
words = text.split()
sentence = " ".join(words)

Use the strip() method.
name = " Alice "
clean_name = name.strip()

Use lstrip() to remove leading spaces and rstrip() to remove trailing spaces.

Split the string into words and use the len() function.

text = "Python is easy to learn"
count = len(text.split())
print(count)

text = "I love Java"
text = text.replace("Java", "Python")
print(text)

File handling allows Python programs to read, write, and update data stored in files. Data Analysts commonly use it to work with CSV, text, and log files.

Use the open() function.
file = open("data.txt", "r")

Common modes:

"r" Read
"w" Write
"a" Append

The with statement automatically closes the file after use, making the code safer and easier to maintain.
with open("data.txt","r") as file:
data = file.read()

Exception handling prevents a program from crashing when an error occurs.
try:
file = open("sales.csv")
except FileNotFoundError:
print("File not found.")

import pandas as pd
df = pd.read_csv("sales.csv")

Object-Oriented Programming is a programming approach that organizes code using classes and objects. It helps create reusable, organized, and maintainable programs.

A Class is a blueprint.
An Object is an instance created from that blueprint.
class Student:
pass

student1 = Student()

A constructor is a special method called __init__() that automatically runs when an object is created. It is used to initialize object attributes.
class Student:
def __init__(self, name):
self.name = name

student = Student("Alice")

The self keyword refers to the current object of the class. It allows access to the object's attributes and methods.
class Student:

def __init__(self, name):
self.name = name

Sample Answer

I would first investigate why the values are missing rather than immediately filling or removing them.
Calculate the percentage of missing values.
Identify whether the missing values appear randomly or follow a pattern.
If only a small percentage is missing, I may remove those rows.
If the column is important, I would consider imputing values using the median, mean, or a business-specific strategy.
Finally, I would validate that the chosen approach does not introduce bias into the analysis.

💡 Interview Tip

Always explain why you selected an imputation method instead of only naming it.

I would first identify the bottleneck before making changes.

Possible optimizations include:
Avoid unnecessary loops.
Use vectorized Pandas operations.
Filter data before processing.
Profile the code to locate slow sections.
Consider chunk processing for large datasets.

💡 Interview Tip

Interviewers are testing your problem-solving process, not whether you know every optimization technique.

I would first define what qualifies as a duplicate.

Then I would:

Identify duplicate rows.
Compare key columns such as email or phone number.
Decide which record should be retained.
Remove duplicates while preserving important information.
Validate the final dataset.

I would avoid loading the entire file into memory.

Instead I would:

Read the data in chunks.
Process each chunk individually.
Aggregate results.
Save intermediate outputs if necessary.
Consider using libraries such as Dask or PySpark if appropriate.

I would focus on communicating business value rather than technical details.

My response would include:

The key finding.
Why it matters.
Supporting evidence.
Recommended next action.
Potential business impact.

💡 Interview Tip

Great analysts don't just analyze data—they communicate actionable insights.