UNIT-1

### Part A - 2 Marks

1. **Define data analysis**:

Data analysis is the process of inspecting, cleansing, transforming, and modeling data with
the goal of discovering useful information, informing conclusions, and supporting
decision-making.

2. **What is data science**:

Data science is an interdisciplinary field that uses scientific methods, processes, algorithms,
and systems to extract knowledge and insights from structured and unstructured data.

3. **List the challenges of data science**:

- Data quality and quantity issues
- Data privacy and security concerns
- Integration of data from different sources
- Selection of appropriate models and algorithms
- Interpretation of results
- Keeping up with rapidly evolving tools and technologies

4. **Discuss the features of Python**:

- Easy to read and write syntax
- Extensive standard library and third-party modules
- Interpreted language with dynamic typing
- Support for multiple programming paradigms (procedural, object-oriented, functional)
- High-level data structures
- Portability across various platforms

5. **List out the data science components**:

- Data collection
- Data cleaning
- Data exploration and visualization
- Data modeling
- Interpretation and communication of results

6. **What is a Python interpreter**:

A Python interpreter is a program that reads and executes Python code. It translates the
high-level Python code into machine code or intermediate code that the computer can
understand and execute.

### Part B - 5 Marks

1. **Discuss about data science components and applications**:

 Data science components include data collection, data cleaning, data exploration, data
modeling, and communication of results. Applications of data science span various fields such
as healthcare (predicting disease outbreaks), finance (fraud detection), marketing (customer
segmentation), and many others.

2. **Differentiate between data science and BI (Business Intelligence)**:

- **Data Science**: Focuses on predictive modeling, machine learning, and advanced
statistical analysis. It aims to uncover patterns and insights from data and make data-driven
predictions.
- **Business Intelligence (BI)**: Primarily deals with descriptive analysis using historical data.
It focuses on reporting, dashboards, and data visualization to help businesses make informed
decisions.

3. **Discuss the features of Python**:

- Simple and easy to learn syntax
- Interpreted language, which makes debugging easier
- Extensive standard library and a rich ecosystem of third-party packages (e.g., NumPy,
Pandas, Matplotlib, Scikit-learn)
- Cross-platform compatibility
- Strong community support
- Integration capabilities with other languages and tools

4. **Explain different types of data analysis and its tools**:

- **Descriptive Analysis**: Summarizes historical data to understand what has happened.
Tools: Excel, Tableau, R
- **Diagnostic Analysis**: Examines data to understand the causes of past outcomes. Tools:
SQL, Python (Pandas, Matplotlib)
- **Predictive Analysis**: Uses statistical models and machine learning to predict future
outcomes. Tools: Python (Scikit-learn), R, SAS
- **Prescriptive Analysis**: Suggests actions to achieve desired outcomes. Tools: Python
(SciPy), IBM Decision Optimization

5. **What are the challenges of data science technology**:

- Handling large volumes of data (big data)
- Ensuring data quality and consistency
- Managing data privacy and security
- Choosing appropriate models and algorithms
- Interpreting complex models and results
- Keeping up with rapid advancements in technology and tools

6. **Discuss in detail about the tools of data science**:

- **Programming Languages**: Python, R, SQL
- **Data Analysis and Visualization**: Pandas, Matplotlib, Seaborn, Tableau, Power BI
- **Machine Learning**: Scikit-learn, TensorFlow, Keras, PyTorch
 - **Big Data Technologies**: Hadoop, Spark
- **Database Management**: MySQL, PostgreSQL, MongoDB
- **Version Control and Collaboration**: Git, GitHub

7. **Give an overview of different types of analysis**:

- **Descriptive Analysis**: Provides insights into past data through summary statistics and
visualization.
- **Diagnostic Analysis**: Investigates the reasons behind past outcomes.
- **Predictive Analysis**: Uses historical data to predict future events.
- **Prescriptive Analysis**: Recommends actions based on predictive models to achieve
desired outcomes.

Unit-2

### Part A - 2 Marks

1. **What is operator precedence**:

Operator precedence determines the order in which operators are evaluated in an expression.
For example, in the expression `3 + 4 * 2`, the multiplication (`*`) operator has higher
precedence than the addition (`+`) operator, so the result is `3 + (4 * 2) = 11`.

2. **Explain about variable scope**:

Variable scope refers to the context in which a variable is accessible. There are typically four
levels of scope in Python:
- Local: Variables defined inside a function.
- Enclosing: Variables in the local scope of enclosing functions.
- Global: Variables defined at the top-level of a module or explicitly declared as global.
- Built-in: Names preassigned in the Python built-in namespace.

3. **Describe about expression**:

An expression is a combination of values, variables, operators, and function calls that are
evaluated to produce another value. For example, `2 + 3`, `len("hello")`, and `x * y + 7` are all
expressions.

4. **Differentiate between break and continue**:

- `break`: Terminates the nearest enclosing loop entirely.
- `continue`: Skips the rest of the current loop iteration and proceeds to the next iteration.

5. **What do you mean by indentation**:

Indentation in Python refers to the spaces or tabs used at the beginning of a code line to
define the structure of the code blocks. Python uses indentation to indicate the block of code
associated with control structures like loops, conditionals, functions, etc.

### Part B - 5 Marks

1. **Discuss about tuple of assignment and operator**:
- **Tuple Assignment**: Allows you to assign multiple variables at once using tuples. Example:
`a, b = 1, 2` assigns `1` to `a` and `2` to `b`.
- **Operators**: Symbols that perform operations on variables and values. Examples include
`+` for addition, `-` for subtraction, `*` for multiplication, and `/` for division.

2. **Explain Python modules with an example**:

Python modules are files containing Python code that can define functions, classes, and
variables. Example:
```python
# math_operations.py
def add(a, b):
return a + b

def subtract(a, b):

return a - b
```
```python
# main.py
import math_operations as mo

print(mo.add(5, 3)) # Output: 8

print(mo.subtract(5, 3)) # Output: 2
```

3. **Explain chained conditional and nested conditional with suitable example**:

- **Chained Conditional**: Using multiple `if`, `elif`, and `else` statements.
```python
x = 10
if x > 0:
print("Positive")
elif x == 0:
print("Zero")
else:
print("Negative")
```
- **Nested Conditional**: One `if` statement inside another `if` statement.
```python
x = 10
if x >= 0:
if x == 0:
print("Zero")
else:
 print("Positive")
else:
print("Negative")
```

4. **With an example discuss various looping statements in Python**:

- **for loop**:
```python
for i in range(5):
print(i)
```
- **while loop**:
```python
count = 0
while count < 5:
print(count)
count += 1
```
- **Nested loops**:
```python
for i in range(3):
for j in range(3):
print(i, j)
```

5. **Define function and explain different types of functions**:

- **Function**: A block of reusable code that performs a specific task.
- **Built-in Functions**: Predefined functions in Python, e.g., `len()`, `print()`.
- **User-defined Functions**: Functions created by the user.
```python
def greet(name):
return f"Hello, {name}!"
```
- **Anonymous Functions (Lambda Functions)**: Functions defined using the `lambda`
keyword.
```python
add = lambda x, y: x + y
print(add(2, 3))
```

6. **Write a short note on function composition**:

Function composition involves combining two or more functions to form a new function. For
example, if `f` and `g` are functions, their composition `h(x) = f(g(x))` applies `g` to `x` and then
`f` to the result.
 ```python
def double(x):
return x * 2

def increment(x):
return x + 1

def compose(f, g):

return lambda x: f(g(x))

h = compose(double, increment)
print(h(3)) # Output: 8
```

7. **Differentiate between if and if else**:

- **if**: Executes a block of code if its condition is true.
```python
if x > 0:
print("Positive")
```
- **if else**: Provides an alternative block of code to execute if the condition is false.
```python
if x > 0:
print("Positive")
else:
print("Non-positive")
```

8. **Write about input and output in Python with example**:

- **Input**: Using `input()` to take user input.
```python
name = input("Enter your name: ")
print(f"Hello, {name}!")
```
- **Output**: Using `print()` to display output.
```python
print("Hello, World!")
age = 25
print(f"I am {age} years old.")

UNIT-3

### Part A - 2 Marks

1. **Compare list and array**:
- **List**: A built-in Python data type that can contain elements of different types (e.g.,
integers, strings, other lists). It is flexible and dynamic.
- **Array**: Provided by the `array` module or libraries like NumPy. Typically contains
elements of the same type and is more efficient for numerical operations.

2. **What is membership and identity operator**:

- **Membership Operator**: `in` and `not in`, used to check if a value exists in a sequence
(e.g., `if 3 in [1, 2, 3]:`).
- **Identity Operator**: `is` and `is not`, used to compare the memory addresses of two objects
(e.g., `if a is b:`).

3. **Define string module**:

The `string` module in Python provides a collection of string constants and utility functions to
manipulate strings (e.g., `string.ascii_letters`, `string.digits`, `string.capwords()`).

4. **Write a short note on tuple**:

A tuple is an immutable, ordered collection of elements. Elements can be of different types
and are accessed via indexing. Example: `my_tuple = (1, "hello", 3.14)`.

5. **What is list**:
A list is a mutable, ordered collection of elements in Python. Elements can be of different
types and are accessed via indexing. Example: `my_list = [1, "hello", 3.14]`.

6. **What is string slice**:

String slicing allows you to obtain a substring by specifying a range of indices. Example: `s =
"hello"; s[1:4]` results in `"ell"`.

7. **Define dictionary**:
A dictionary is an unordered collection of key-value pairs. Keys must be unique and
immutable, while values can be of any type. Example: `my_dict = {"name": "Alice", "age": 25}`.

### Part B - 5 Marks

1. **What is string? Discuss various string methods with an example**:

A string is a sequence of characters. String methods include:
- `upper()`: Converts to uppercase. Example: `"hello".upper()` returns `"HELLO"`.
- `lower()`: Converts to lowercase. Example: `"HELLO".lower()` returns `"hello"`.
- `strip()`: Removes leading/trailing whitespace. Example: `" hello ".strip()` returns `"hello"`.
- `replace()`: Replaces a substring with another. Example: `"hello world".replace("world",
"Python")` returns `"hello Python"`.
- `split()`: Splits the string into a list based on a delimiter. Example: `"a,b,c".split(",")` returns
`['a', 'b', 'c']`.
2. **Describe the basic list operations in detail using necessary program**:
Basic list operations include:
- **Creating a List**: `my_list = [1, 2, 3]`
- **Accessing Elements**: `my_list[0]` returns `1`
- **Appending**: `my_list.append(4)` results in `[1, 2, 3, 4]`
- **Inserting**: `my_list.insert(1, 1.5)` results in `[1, 1.5, 2, 3, 4]`
- **Removing**: `my_list.remove(1.5)` results in `[1, 2, 3, 4]`
- **Popping**: `my_list.pop()` removes and returns the last element, resulting in `[1, 2, 3]`
- **Slicing**: `my_list[1:3]` returns `[2, 3]`
```python
my_list = [1, 2, 3]
my_list.append(4)
print(my_list)
# Output: [1, 2, 3, 4]
```

3. **Explain the operation on dictionary with example**:

Dictionary operations include:
- **Creating a Dictionary**: `my_dict = {"name": "Alice", "age": 25}`
- **Accessing Values**: `my_dict["name"]` returns `"Alice"`
- **Adding/Updating**: `my_dict["city"] = "New York"` adds a new key-value pair
- **Removing**: `del my_dict["age"]` removes the key `age`
- **Iterating**:
```python
for key, value in my_dict.items():
print(key, value)
```
```python
my_dict = {"name": "Alice", "age": 25}
my_dict["city"] = "New York"
print(my_dict)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York'}
```

4. **Illustrate list comprehension with suitable example**:

List comprehension provides a concise way to create lists. Example:
```python
squares = [x**2 for x in range(5)]
print(squares)
# Output: [0, 1, 4, 9, 16]
```
Example with condition:
```python
 evens = [x for x in range(10) if x % 2 == 0]
print(evens)
# Output: [0, 2, 4, 6, 8]
```

5. **Differentiate between tuple and list**:

- **Tuple**: Immutable, fixed-size, defined using parentheses `()`.
- **List**: Mutable, dynamic-size, defined using square brackets `[]`.
Example:
```python
my_tuple = (1, 2, 3)
my_list = [1, 2, 3]
```

6. **Illustrate and demonstrate operation on tuple**:

- **Creating a Tuple**: `my_tuple = (1, 2, 3)`
- **Accessing Elements**: `my_tuple[0]` returns `1`
- **Concatenation**: `my_tuple + (4, 5)` results in `(1, 2, 3, 4, 5)`
- **Slicing**: `my_tuple[1:3]` returns `(2, 3)`
```python
my_tuple = (1, 2, 3)
print(my_tuple[0])
# Output: 1
new_tuple = my_tuple + (4, 5)
print(new_tuple)
# Output: (1, 2, 3, 4, 5)
```

UNIT-4

### Part A - 2 Marks

1. **What are the attributes of NumPy array**:

Key attributes of a NumPy array include:
- `ndarray.ndim`: Number of dimensions.
- `ndarray.shape`: Tuple of array dimensions.
- `ndarray.size`: Total number of elements.
- `ndarray.dtype`: Data type of elements.
- `ndarray.itemsize`: Size of each element in bytes.
- `ndarray.nbytes`: Total bytes consumed by the elements.

2. **What are the vectorized operations in NumPy**:

 Vectorized operations are operations that can be performed on entire arrays or large chunks
of data at once, leveraging NumPy's internal C implementation for performance. Examples
include element-wise addition, subtraction, multiplication, and division.

3. **Define fancy indexing**:

Fancy indexing is a way of accessing array elements using arrays of indices instead of single
scalars. It allows the selection of arbitrary elements or sets of elements from an array.

4. **Describe about NumPy array**:

A NumPy array is a powerful n-dimensional array object which is the fundamental package for
numerical computing in Python. It supports a wide variety of mathematical operations and
provides tools for efficient data manipulation.

5. **What is boolean logic in NumPy**:

Boolean logic in NumPy refers to operations involving boolean values (`True` and `False`). It
allows for element-wise comparison and manipulation of arrays using logical operators (`&`, `|`,
`~`, `^`).

### Part B - 5 Marks

1. **Explain various computations on NumPy array**:

- **Element-wise operations**:
```python
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a + b)
# Output: [5, 7, 9]
```
- **Broadcasting**: Expands smaller arrays to compatible shapes for element-wise operations.
- **Aggregations**: Sum, mean, median, min, max, etc.
```python
a = np.array([1, 2, 3, 4])
print(a.sum())
# Output: 10
```
- **Linear algebra operations**: Matrix multiplication, determinants, eigenvalues.
```python
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print(np.dot(A, B)) # Matrix multiplication
```

2. **Explain about built-in NumPy aggregation functions**:

- `np.sum()`: Sum of array elements.
 - `np.mean()`: Mean of array elements.
- `np.std()`: Standard deviation of array elements.
- `np.var()`: Variance of array elements.
- `np.min()` and `np.max()`: Minimum and maximum values in the array.
- `np.argmin()` and `np.argmax()`: Indices of the minimum and maximum values.
```python
a = np.array([1, 2, 3, 4])
print(np.sum(a))
# Output: 10
print(np.mean(a))
# Output: 2.5
```

3. **Explain fancy indexing with example**:

Fancy indexing allows selection of elements from an array using arrays of indices.
```python
a = np.array([10, 20, 30, 40, 50])
indices = np.array([0, 2, 4])
print(a[indices])
# Output: [10, 30, 50]
```

4. **Explain NumPy structured data with an example**:

NumPy structured arrays allow for arrays with different data types.
```python
data = np.array([(1, 'Alice', 25), (2, 'Bob', 30)],
dtype=[('id', 'i4'), ('name', 'U10'), ('age', 'i4')])
print(data['name'])
# Output: ['Alice' 'Bob']
```
This allows for efficient manipulation and access of heterogeneous data.

5. **Define NumPy array**:

A NumPy array is a multi-dimensional, fixed-size, and homogeneous data structure. It
provides fast and versatile data manipulation capabilities and is the fundamental building block
for scientific computing in Python.

6. **Describe about masks and boolean logic**:

Masks are arrays of boolean values used to filter elements of another array.
```python
a = np.array([1, 2, 3, 4])
mask = (a % 2 == 0)
print(a[mask])
# Output: [2, 4]
 ```
Boolean logic operations can be used to create complex conditions for filtering arrays.

7. **Give an overview on sorting array in NumPy**:

- `np.sort()`: Returns a sorted copy of an array.
- `np.argsort()`: Returns indices that would sort the array.
- `ndarray.sort()`: Sorts the array in-place.
```python
a = np.array([3, 1, 4, 1, 5])
print(np.sort(a))
# Output: [1, 1, 3, 4, 5]
print(a.argsort())
# Output: [1, 3, 0, 2, 4]
```

UNIT-5

### Part A - 2 Marks

1. **Differentiate between head and tail method**:

- `head()`: Returns the first n rows of a DataFrame.
- `tail()`: Returns the last n rows of a DataFrame.
Example:
```python
df.head(3) # First 3 rows
df.tail(3) # Last 3 rows
```

2. **Describe the use of `.iloc` method in pandas**:

The `.iloc` method is used for integer-location based indexing. It allows you to select rows and
columns by their integer positions.
Example:
```python
df.iloc[0:3, 1:4] # Selects rows 0 to 2 and columns 1 to 3
```

3. **What is data manipulation in pandas**:

Data manipulation in pandas refers to operations that modify data, such as filtering, sorting,
grouping, merging, reshaping, and aggregating data to extract useful information or transform
data for analysis.

4. **State about pandas object**:

Pandas objects include:
- `Series`: A one-dimensional labeled array capable of holding data of any type.
 - `DataFrame`: A two-dimensional, size-mutable, and potentially heterogeneous tabular data
structure with labeled axes (rows and columns).

5. **What is pandas**:
Pandas is an open-source data manipulation and analysis library for Python. It provides data
structures and functions needed to manipulate structured data seamlessly, making data analysis
and manipulation tasks easier.

### Part B - 5 Marks

1. **Discuss the features of pandas**:

- **Data Structures**: Provides Series and DataFrame for data manipulation.
- **Data Alignment**: Automatically aligns data based on labels.
- **Handling Missing Data**: Offers methods to handle missing data (`isnull()`, `dropna()`,
`fillna()`).
- **Data Transformation**: Supports reshaping, merging, and pivoting data.
- **File I/O**: Reads from and writes to various file formats (CSV, Excel, SQL, etc.).
- **Time Series**: Robust functionality for working with time series data.

2. **Explain about pandas object with suitable example**:

- **Series**: A one-dimensional array with an index.
```python
import pandas as pd
s = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
print(s)
```
- **DataFrame**: A two-dimensional array with labeled axes.
```python
data = {'A': [1, 2], 'B': [3, 4]}
df = pd.DataFrame(data)
print(df)
```

3. **Explain about how missing data can be handled in pandas**:

- **Detecting Missing Data**: `isnull()` and `notnull()` methods.
- **Dropping Missing Data**: `dropna()` method.
- **Filling Missing Data**: `fillna()` method.
- **Replacing Missing Data**: `replace()` method.
Example:
```python
df = pd.DataFrame({'A': [1, None, 3], 'B': [4, 5, None]})
df.fillna(0) # Replaces NaN with 0
```
4. **Elaborate the concept of hierarchical indexing with an example**:
Hierarchical indexing (MultiIndex) allows multiple levels of indexing.
```python
index = pd.MultiIndex.from_tuples([('a', 1), ('a', 2), ('b', 1), ('b', 2)])
df = pd.DataFrame({'data': [10, 20, 30, 40]}, index=index)
print(df)
```
This creates a DataFrame with a multi-level index.

5. **Discuss in brief about operations on data in pandas**:

- **Filtering**: Using conditions to select data.
```python
df[df['A'] > 2]
```
- **Sorting**: Sorting by index or columns.
```python
df.sort_values(by='A')
```
- **Aggregating**: Summarizing data using groupby and aggregation functions.
```python
df.groupby('A').sum()
```
- **Reshaping**: Using pivot, melt, and stack/unstack to reshape data.

6. **How to combine data sets using pandas**:

- **Concatenation**: Using `pd.concat()`.
```python
df1 = pd.DataFrame({'A': [1, 2]})
df2 = pd.DataFrame({'A': [3, 4]})
pd.concat([df1, df2])
```
- **Merging/Joining**: Using `pd.merge()` and `join()`.
```python
df1 = pd.DataFrame({'key': ['A', 'B'], 'value': [1, 2]})
df2 = pd.DataFrame({'key': ['A', 'B'], 'value2': [3, 4]})
pd.merge(df1, df2, on='key')
```

7. **Write about data manipulation with pandas**:

- **Filtering**: Select rows based on conditions.
- **Sorting**: Sort data by values or index.
- **Grouping**: Aggregate data by groups using `groupby`.
- **Merging**: Combine multiple DataFrames.
- **Reshaping**: Change the shape of data using `pivot`, `melt`, `stack`, and `unstack`.
 Example:
```python
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df['C'] = df['A'] + df['B']
```

8. **Describe about data indexing and selection**:

- **Indexing**: Setting and manipulating the index of DataFrames using `set_index()`,
`reset_index()`, and `reindex()`.
- **Selection**: Accessing data using labels (`loc`), integer-location (`iloc`), and boolean
indexing.
Example:
```python
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df.set_index('A', inplace=True)
df.loc[2] # Accessing row with index 2
```