Q1. Explain 2D Numeric and Character array with example.

ans. ### 2D Numeric Array:

A **2D numeric array** is an array that stores values in a matrix form with rows
and columns. Each element of the array can be accessed using two indices: one for
the row and the other for the column.

- **Example**: A 2D numeric array storing integers.

```python
# Creating a 2D numeric array (3 rows and 2 columns)
array_2d = [
[1, 2],
[3, 4],
[5, 6]
]

# Accessing elements
print(array_2d[0][1]) # Output: 2 (element at row 0, column 1)
print(array_2d[2][0]) # Output: 5 (element at row 2, column 0)
```

In this example, `array_2d` is a 2D numeric array where:

- The first row is `[1, 2]`
- The second row is `[3, 4]`
- The third row is `[5, 6]`

To access an element, you provide two indices: the row index and the column index.
For example, `array_2d[0][1]` accesses the element at row 0, column 1, which is
`2`.

### 2D Character Array:

A **2D character array** is a similar concept but stores characters (strings or

individual characters) in rows and columns. Just like a numeric array, each element
can be accessed using two indices.

- **Example**: A 2D character array storing characters.

```python
# Creating a 2D character array (3 rows and 4 columns)
char_array_2d = [
['a', 'b', 'c', 'd'],
['e', 'f', 'g', 'h'],
['i', 'j', 'k', 'l']
]

# Accessing elements
print(char_array_2d[1][2]) # Output: 'g' (element at row 1, column 2)
print(char_array_2d[2][0]) # Output: 'i' (element at row 2, column 0)
```

In this example, `char_array_2d` is a 2D character array:

- The first row is `['a', 'b', 'c', 'd']`
- The second row is `['e', 'f', 'g', 'h']`
- The third row is `['i', 'j', 'k', 'l']`

To access an element, the process is the same as in the numeric array, where you
use the row and column indices to get the character value at that position.

### Key Points:

1. A **2D numeric array** stores numbers in a grid-like structure.
2. A **2D character array** stores characters or strings in a similar grid
structure.
3. Both arrays can be accessed using two indices, one for the row and one for the
column.

Q2. Explain need of structure with example and write difference between structure
and union.

ans. ### Need of Structure:

A **structure** is a user-defined data type in many programming languages (such as

C, C++, etc.) that allows grouping different data types under one name. Each
element within the structure is called a **member** or **field**, and each member
can have a different data type.

The need for a structure arises when you want to group together different types of
data (which are logically related) into a single unit, rather than managing them
individually. It helps in organizing complex data efficiently and makes the code
more readable and manageable.

**Why structures are needed:**

1. **Organization of data**: Structures allow us to group different types of data
(e.g., integers, floats, strings) together that logically belong to one entity.
2. **Improved code clarity**: By grouping related data together, it is easier to
understand and maintain the code.
3. **Memory management**: Structures help manage data in a more structured way,
particularly when dealing with complex data in real-world applications.

### Example of Structure:

Suppose we are designing a system to store information about students. Each student
has:
- Name (string)
- Age (integer)
- Grade (float)

We can define a structure to represent this information.

```c
#include <stdio.h>

// Defining a structure to represent a student

struct Student {
char name[50];
int age;
float grade;
};

int main() {
// Declaring a structure variable
struct Student student1;
 // Assigning values to structure members
strcpy(student1.name, "Alice");
student1.age = 20;
student1.grade = 88.5;

// Printing the structure values

printf("Name: %s\n", student1.name);
printf("Age: %d\n", student1.age);
printf("Grade: %.2f\n", student1.grade);

return 0;
}
```

In the above example:

- We define a structure `Student` with members `name`, `age`, and `grade`.
- We create a variable `student1` of type `struct Student` to hold the data.
- We assign values to each member of `student1` and print them.

### Difference between Structure and Union:

| **Aspect** | **Structure**
| **Union** |
|------------------------|---------------------------------------------------------
---|-------------------------------------------------------------|
| **Memory allocation** | In a structure, memory is allocated for each member.
| In a union, memory is allocated for the largest member only. |
| **Memory usage** | The total memory size of a structure is the sum of the
memory required for all its members. | The memory size of a union is equal to the
size of its largest member. |
| **Accessing members** | All members can be accessed independently.
| Only one member can be accessed at a time. |
| **Data type** | Members can have different data types and hold
different values simultaneously. | All members share the same memory location and
hold one value at a time. |
| **Use case** | Used when you need to store multiple pieces of data
that are logically related and accessed at the same time. | Used when you need to
store different types of data in the same location but not simultaneously. |
| **Memory example** | If a structure has an integer, float, and char array,
memory is allocated for all three. | If a union has an integer, float, and char
array, memory is allocated for the largest data type among them. |

### Example of Union:

```c
#include <stdio.h>

// Defining a union to represent data of different types

union Data {
int i;
float f;
char str[20];
};

int main() {
// Declaring a union variable
union Data data1;

// Assigning an integer value

 data1.i = 10;
printf("data1.i: %d\n", data1.i);

// Assigning a float value (overwrites previous value)

data1.f = 220.5;
printf("data1.f: %.2f\n", data1.f);

// Assigning a string value (overwrites previous value)

strcpy(data1.str, "Hello, World!");
printf("data1.str: %s\n", data1.str);

return 0;
}
```

In the above union example, only one of the members can hold a value at any given
time, and each member shares the same memory space.

### Key Differences Summary:

- **Structure**: Memory for all members is allocated separately, and they can hold
different values at the same time.
- **Union**: Memory is allocated for the largest member, and all members share the
same memory space. Only one member can hold a value at a time.

Structures are ideal when you need to store multiple attributes that will be used
together, while unions are more efficient when you only need to store one of
several possible types of data at a time, saving memory.

Q3. . Types of User Define Function with example.

ans. In programming, a **User-Defined Function (UDF)** is a function that is

defined by the programmer to perform a specific task. These functions allow code to
be more organized, reusable, and modular. There are several types of user-defined
functions, based on their return types and arguments. Below are the common types:

### Types of User-Defined Functions

1. **Function with No Arguments and No Return Value**:

- This type of function does not accept any arguments and does not return a
value. It performs some actions, but no data is passed to or returned from the
function.

**Syntax**:
```c
return_type function_name() {
// Code to perform action
}
```

**Example**:
```c
#include <stdio.h>

// Function with no arguments and no return value

void greet() {
 printf("Hello, Welcome to Programming!\n");
}

int main() {
greet(); // Calling the function
return 0;
}
```

In this example:
- The `greet` function does not take any arguments nor return any value, but it
prints a greeting message.

2. **Function with Arguments but No Return Value**:

- This type of function accepts arguments but does not return any value. It
performs actions using the arguments passed to it.

**Syntax**:
```c
return_type function_name(type arg1, type arg2, ...) {
// Code using arguments
}
```

**Example**:
```c
#include <stdio.h>

// Function with arguments but no return value

void addNumbers(int a, int b) {
printf("Sum: %d\n", a + b);
}

int main() {
addNumbers(10, 20); // Calling the function with arguments
return 0;
}
```

In this example:
- The `addNumbers` function takes two arguments (integers), performs addition,
and prints the result. It does not return any value.

3. **Function with No Arguments but with a Return Value**:

- This type of function does not accept any arguments, but it returns a value
after performing some computation.

**Syntax**:
```c
return_type function_name() {
// Code to compute and return a value
}
```

**Example**:
```c
#include <stdio.h>

// Function with no arguments but returns a value

 int getNumber() {
return 42; // Returning a value
}

int main() {
int num = getNumber(); // Calling the function and storing the return value
printf("The number is: %d\n", num);
return 0;
}
```

In this example:
- The `getNumber` function does not take any arguments, but it returns the
integer value `42`.

4. **Function with Arguments and a Return Value**:

- This type of function takes arguments and returns a value after performing a
computation or operation using those arguments.

**Syntax**:
```c
return_type function_name(type arg1, type arg2, ...) {
// Code to compute a value and return it
}
```

**Example**:
```c
#include <stdio.h>

// Function with arguments and a return value

int multiply(int x, int y) {
return x * y; // Returning the product
}

int main() {
int result = multiply(5, 10); // Calling the function with arguments
printf("The result of multiplication is: %d\n", result);
return 0;
}
```

In this example:
- The `multiply` function accepts two integer arguments, multiplies them, and
returns the result. The return value is then printed.

### Summary of User-Defined Functions:

| **Type of Function** | **Arguments** | **Return

Value** | **Example Use Case** |
|-------------------------------------------------|----------------------|---------
----------------|---------------------------------------------------------|
| **Function with No Arguments and No Return Value** | No arguments | No
return value | Simple tasks like printing a message or displaying
information. |
| **Function with Arguments but No Return Value** | Yes (Arguments passed) | No
return value | Perform an operation using passed arguments, e.g., printing
sum. |
| **Function with No Arguments but with Return Value** | No arguments |
Returns a value | Return a calculated value (e.g., a constant or computed
result). |
| **Function with Arguments and a Return Value** | Yes (Arguments passed) |
Returns a value | Perform calculations or transformations using arguments
and return the result. |

### Conclusion:
- **User-Defined Functions (UDFs)** are powerful tools for making code more
modular, reusable, and organized. Functions can be categorized based on whether
they accept arguments and whether they return values, as shown in the examples
above.

Q4. . Explain String Methods with proper example in python

ans. In Python, strings are sequences of characters, and there are various built-in
methods that allow you to manipulate and work with strings effectively. Here are
some commonly used **string methods** in Python, along with examples:

### 1. **`upper()`**
- Converts all characters of the string to uppercase.

**Syntax**:
```python
string.upper()
```

**Example**:
```python
text = "hello"
print(text.upper()) # Output: "HELLO"
```

### 2. **`lower()`**
- Converts all characters of the string to lowercase.

**Syntax**:
```python
string.lower()
```

**Example**:
```python
text = "HELLO"
print(text.lower()) # Output: "hello"
```

### 3. **`capitalize()`**
- Capitalizes the first character of the string and makes all other characters
lowercase.

**Syntax**:
```python
string.capitalize()
```

**Example**:
```python
 text = "hello world"
print(text.capitalize()) # Output: "Hello world"
```

### 4. **`title()`**
- Converts the first character of each word to uppercase and the remaining
characters to lowercase.

**Syntax**:
```python
string.title()
```

**Example**:
```python
text = "hello world"
print(text.title()) # Output: "Hello World"
```

### 5. **`strip()`**
- Removes any leading (spaces at the beginning) and trailing (spaces at the end)
characters (by default, it removes spaces).

**Syntax**:
```python
string.strip()
```

**Example**:
```python
text = " hello "
print(text.strip()) # Output: "hello"
```

### 6. **`replace(old, new)`**

- Replaces all occurrences of the `old` substring with the `new` substring in
the string.

**Syntax**:
```python
string.replace(old, new)
```

**Example**:
```python
text = "I love programming"
print(text.replace("love", "enjoy")) # Output: "I enjoy programming"
```

### 7. **`split(delimiter)`**
- Splits the string into a list where each word is a list item. The `delimiter`
specifies where to split (by default, it splits by spaces).

**Syntax**:
```python
string.split(delimiter)
```

**Example**:
 ```python
text = "apple,banana,cherry"
print(text.split(',')) # Output: ['apple', 'banana', 'cherry']
```

### 8. **`join(iterable)`**
- Joins the elements of an iterable (such as a list) into a string, with the
string acting as a separator between the elements.

**Syntax**:
```python
string.join(iterable)
```

**Example**:
```python
words = ['apple', 'banana', 'cherry']
print(', '.join(words)) # Output: "apple, banana, cherry"
```

### 9. **`find(substring)`**
- Returns the lowest index where the substring is found in the string. If not
found, it returns `-1`.

**Syntax**:
```python
string.find(substring)
```

**Example**:
```python
text = "hello world"
print(text.find("world")) # Output: 6
print(text.find("python")) # Output: -1 (substring not found)
```

### 10. **`startswith(prefix)`**

- Returns `True` if the string starts with the specified prefix, otherwise
returns `False`.

**Syntax**:
```python
string.startswith(prefix)
```

**Example**:
```python
text = "hello world"
print(text.startswith("hello")) # Output: True
print(text.startswith("world")) # Output: False
```

### 11. **`endswith(suffix)`**

- Returns `True` if the string ends with the specified suffix, otherwise returns
`False`.

**Syntax**:
```python
string.endswith(suffix)
 ```

**Example**:
```python
text = "hello world"
print(text.endswith("world")) # Output: True
print(text.endswith("hello")) # Output: False
```

### 12. **`isdigit()`**

- Returns `True` if all characters in the string are digits, otherwise returns
`False`.

**Syntax**:
```python
string.isdigit()
```

**Example**:
```python
text = "12345"
print(text.isdigit()) # Output: True

text2 = "hello"
print(text2.isdigit()) # Output: False
```

### 13. **`isspace()`**

- Returns `True` if all characters in the string are whitespace characters
(spaces, tabs, newlines), otherwise returns `False`.

**Syntax**:
```python
string.isspace()
```

**Example**:
```python
text = " "
print(text.isspace()) # Output: True

text2 = "hello"
print(text2.isspace()) # Output: False
```

### 14. **`len()`**

- While not a method specific to strings, `len()` is used to get the length of a
string (the number of characters it contains).

**Syntax**:
```python
len(string)
```

**Example**:
```python
text = "hello"
print(len(text)) # Output: 5
```
### 15. **`isalpha()`**
- Returns `True` if all characters in the string are alphabetic (letters only),
otherwise returns `False`.

**Syntax**:
```python
string.isalpha()
```

**Example**:
```python
text = "hello"
print(text.isalpha()) # Output: True

text2 = "hello123"
print(text2.isalpha()) # Output: False
```

---

### Conclusion:
Python provides a rich set of string methods that make string manipulation easier
and more efficient. These methods help you modify, search, and analyze strings in
various ways, making it simpler to handle text data in your programs.

Q5. . Explain list with example and its methods.

ans. ### **List in Python**

A **list** in Python is an ordered collection of elements that can hold items of

different types, such as integers, strings, or even other lists. Lists are
**mutable**, meaning you can change their contents after they have been created
(e.g., add, remove, or modify elements).

### **Creating a List**

You can create a list by placing comma-separated values inside square brackets
`[]`.

**Example:**
```python
# Creating a list with mixed data types
my_list = [1, "apple", 3.14, True]
print(my_list)
```
**Output:**
```
[1, "apple", 3.14, True]
```

### **Accessing List Elements**

You can access individual elements of the list using **indexing**. Python uses
**zero-based indexing**, meaning the first element has index `0`, the second
element has index `1`, and so on.
**Example:**
```python
my_list = [1, "apple", 3.14, True]
print(my_list[1]) # Output: "apple"
print(my_list[2]) # Output: 3.14
```

You can also use **negative indexing** to access elements from the end of the list.
The last element has index `-1`, the second-last has index `-2`, etc.

**Example:**
```python
print(my_list[-1]) # Output: True (last element)
print(my_list[-2]) # Output: 3.14 (second-last element)
```

### **List Methods in Python**

Here are some of the most commonly used **list methods** in Python:

---

### 1. **`append(item)`**
- Adds an item to the end of the list.

**Syntax**:
```python
list.append(item)
```

**Example**:
```python
my_list = [1, 2, 3]
my_list.append(4)
print(my_list) # Output: [1, 2, 3, 4]
```

---

### 2. **`extend(iterable)`**
- Extends the list by appending all elements from the provided iterable (another
list, tuple, etc.) to the end of the list.

**Syntax**:
```python
list.extend(iterable)
```

**Example**:
```python
my_list = [1, 2, 3]
my_list.extend([4, 5])
print(my_list) # Output: [1, 2, 3, 4, 5]
```

---

### 3. **`insert(index, item)`**

- Inserts an item at the specified index in the list, shifting other elements to
the right.

**Syntax**:
```python
list.insert(index, item)
```

**Example**:
```python
my_list = [1, 2, 3]
my_list.insert(1, "apple")
print(my_list) # Output: [1, "apple", 2, 3]
```

---

### 4. **`remove(item)`**
- Removes the first occurrence of the specified item from the list. If the item
is not found, it raises a `ValueError`.

**Syntax**:
```python
list.remove(item)
```

**Example**:
```python
my_list = [1, 2, 3, 2, 4]
my_list.remove(2)
print(my_list) # Output: [1, 3, 2, 4]
```

---

### 5. **`pop(index)`**
- Removes and returns the element at the specified index. If no index is
provided, it removes and returns the last element.

**Syntax**:
```python
list.pop(index)
```

**Example**:
```python
my_list = [1, 2, 3, 4]
popped_item = my_list.pop(1)
print(popped_item) # Output: 2
print(my_list) # Output: [1, 3, 4]
```

---

### 6. **`index(item)`**
- Returns the index of the first occurrence of the specified item in the list.
If the item is not found, it raises a `ValueError`.

**Syntax**:
```python
 list.index(item)
```

**Example**:
```python
my_list = [1, 2, 3, 4]
print(my_list.index(3)) # Output: 2
```

---

### 7. **`count(item)`**
- Returns the number of times the specified item appears in the list.

**Syntax**:
```python
list.count(item)
```

**Example**:
```python
my_list = [1, 2, 2, 3, 2]
print(my_list.count(2)) # Output: 3
```

---

### 8. **`sort()`**
- Sorts the elements of the list in ascending order by default. You can also
sort in descending order by passing `reverse=True`.

**Syntax**:
```python
list.sort(reverse=False)
```

**Example**:
```python
my_list = [3, 1, 4, 2]
my_list.sort()
print(my_list) # Output: [1, 2, 3, 4]
```

**Descending Order**:
```python
my_list.sort(reverse=True)
print(my_list) # Output: [4, 3, 2, 1]
```

---

### 9. **`reverse()`**
- Reverses the elements of the list in place.

**Syntax**:
```python
list.reverse()
```
 **Example**:
```python
my_list = [1, 2, 3, 4]
my_list.reverse()
print(my_list) # Output: [4, 3, 2, 1]
```

---

### 10. **`clear()`**

- Removes all items from the list, leaving it empty.

**Syntax**:
```python
list.clear()
```

**Example**:
```python
my_list = [1, 2, 3]
my_list.clear()
print(my_list) # Output: []
```

---

### 11. **`copy()`**

- Returns a shallow copy of the list (creates a new list with the same
elements).

**Syntax**:
```python
list.copy()
```

**Example**:
```python
my_list = [1, 2, 3]
new_list = my_list.copy()
print(new_list) # Output: [1, 2, 3]
```

---

### 12. **`list()`:**

- Converts other iterable objects (such as tuples, sets, etc.) into a list.

**Syntax**:
```python
list(iterable)
```

**Example**:
```python
my_tuple = (1, 2, 3)
new_list = list(my_tuple)
print(new_list) # Output: [1, 2, 3]
```
---

### Summary of List Methods:

- **Adding Elements**: `append()`, `extend()`, `insert()`
- **Removing Elements**: `remove()`, `pop()`, `clear()`
- **Searching and Counting**: `index()`, `count()`
- **Sorting and Reversing**: `sort()`, `reverse()`
- **Copying**: `copy()`
- **Length**: Use `len(list)` to find the number of elements.

---

### Conclusion:
Lists in Python are a powerful and flexible data structure, supporting many methods
for adding, removing, searching, and modifying elements. Understanding these
methods allows you to efficiently work with lists in Python for a wide range of
applications.

Q6. Write a short note on the python collections.

ans. ### **Python Collections**

In Python, the **collections module** provides alternatives to the built-in

general-purpose container types like **lists**, **tuples**, and **dictionaries**.
The collections module offers specialized container datatypes that provide high-
performance alternatives and some additional features. The most commonly used
collections are:

### **1. `namedtuple()`**

- A `namedtuple` is a subclass of the built-in `tuple`. It allows you to create
tuple-like objects with named fields, making the code more readable by accessing
elements via names instead of indices.
- **Use case**: Ideal for representing simple objects that only contain data (e.g.,
coordinates, RGB color values, etc.).

**Example**:
```python
from collections import namedtuple

# Create a namedtuple called 'Point' with fields 'x' and 'y'

Point = namedtuple('Point', ['x', 'y'])

# Create an instance of Point

p = Point(1, 2)

# Accessing values by name

print(p.x) # Output: 1
print(p.y) # Output: 2
```

### **2. `deque()`**

- A `deque` (short for "double-ended queue") is a list-like container that allows
you to append and pop elements from both ends with **O(1)** time complexity, making
it more efficient than a list for such operations.
- **Use case**: Useful for implementing queues, stacks, or sliding windows.

**Example**:
```python
from collections import deque

# Create a deque
d = deque([1, 2, 3])

# Append elements to both ends

d.append(4) # Append to the right
d.appendleft(0) # Append to the left

print(d) # Output: deque([0, 1, 2, 3, 4])

# Pop elements from both ends

d.pop() # Removes from the right
d.popleft() # Removes from the left

print(d) # Output: deque([1, 2, 3])

```

### **3. `Counter()`**

- A `Counter` is a specialized dictionary that helps count the occurrences of
elements in an iterable. It’s essentially a subclass of the built-in `dict`, with
extra functionality for counting.
- **Use case**: Useful for frequency counting or tallying items.

**Example**:
```python
from collections import Counter

# Create a counter from a list

c = Counter([1, 2, 2, 3, 3, 3, 4])

print(c) # Output: Counter({3: 3, 2: 2, 1: 1, 4: 1})

# Access count of an element

print(c[3]) # Output: 3

# Most common elements

print(c.most_common(2)) # Output: [(3, 3), (2, 2)]
```

### **4. `OrderedDict()`**

- An `OrderedDict` is a dictionary subclass that maintains the order in which items
are added. Unlike regular dictionaries (before Python 3.7), an `OrderedDict`
remembers the order of keys.
- **Use case**: Useful when the order of insertion matters (e.g., for data that
needs to be iterated in a specific order).

**Example**:
```python
from collections import OrderedDict

# Create an OrderedDict
od = OrderedDict([('apple', 2), ('banana', 3), ('cherry', 1)])

# Adding a new key-value pair

od['orange'] = 4

print(od) # Output: OrderedDict([('apple', 2), ('banana', 3), ('cherry', 1),

('orange', 4)])

# The order is preserved

```

### **5. `defaultdict()`**

- A `defaultdict` is a subclass of the built-in `dict` that provides a default
value for a nonexistent key. Instead of raising a `KeyError`, it returns a default
value (which is specified at the time of creation).
- **Use case**: Useful when you need to avoid manually checking if a key exists and
handle missing keys with a default value.

**Example**:
```python
from collections import defaultdict

# Create a defaultdict with default value type as int (0)

d = defaultdict(int)

d['apple'] += 1
d['banana'] += 2

print(d) # Output: defaultdict(<class 'int'>, {'apple': 1, 'banana': 2})

print(d['orange']) # Output: 0 (default value for missing key)
```

---

### **Summary**

- **`namedtuple()`**: Creates tuple-like objects with named fields for better

readability.
- **`deque()`**: Provides fast appends and pops from both ends of the collection.
- **`Counter()`**: Counts occurrences of elements in an iterable.
- **`OrderedDict()`**: Maintains the order of insertion of key-value pairs.
- **`defaultdict()`**: A dictionary that returns a default value for missing keys.

These specialized collection types in the **`collections` module** make working

with data structures in Python easier and more efficient, especially when you need
features like fast access, ordering, counting, or default values.

Q7. What is Numpy and Pandas? Explain it with example.

ans. ### **NumPy (Numerical Python)**

**NumPy** is a powerful library for numerical computing in Python. It provides

support for large, multi-dimensional arrays and matrices, along with a collection
of high-level mathematical functions to operate on these arrays. NumPy is widely
used for scientific computing, data analysis, machine learning, and more, due to
its efficient handling of large datasets and mathematical operations.

#### Key Features of NumPy:

- **N-dimensional arrays**: NumPy provides the `ndarray` object, which is a fast,
flexible array that can hold homogeneous data types (like integers, floats, etc.).
- **Mathematical operations**: NumPy supports element-wise operations (like
addition, subtraction, etc.) and advanced mathematical operations (like linear
algebra, statistics, etc.).
- **Vectorized operations**: NumPy allows operations on entire arrays without
needing explicit loops, making it faster and more efficient than regular Python
lists.

#### Example of NumPy:

```python
import numpy as np

# Creating a 1D array (vector)

arr = np.array([1, 2, 3, 4])
print("1D Array:", arr)

# Creating a 2D array (matrix)

matrix = np.array([[1, 2], [3, 4], [5, 6]])
print("2D Matrix:\n", matrix)

# Element-wise operations (vectorized)

arr2 = np.array([5, 6, 7, 8])
sum_arr = arr + arr2 # Adding two arrays element-wise
print("Element-wise addition:", sum_arr)

# Array multiplication by a scalar

scaled_arr = arr * 2
print("Array multiplied by 2:", scaled_arr)

# Basic statistics
mean_value = np.mean(arr)
print("Mean of arr:", mean_value)
```

**Output:**
```
1D Array: [1 2 3 4]
2D Matrix:
[[1 2]
[3 4]
[5 6]]
Element-wise addition: [ 6 8 10 12]
Array multiplied by 2: [2 4 6 8]
Mean of arr: 2.5
```

---

### **Pandas**

**Pandas** is a high-level data manipulation library built on top of NumPy. It is

primarily used for working with structured data (like tables or data frames) and is
extremely useful for tasks such as data cleaning, exploration, and analysis. Pandas
introduces two main data structures:
- **`Series`**: A one-dimensional labeled array, similar to a list or an array.
- **`DataFrame`**: A two-dimensional labeled data structure, similar to a table or
a spreadsheet.

#### Key Features of Pandas:

- **DataFrames**: Provides flexible data structures (like `DataFrame` and `Series`)
to represent and manipulate structured data.
- **Labeling**: Both rows and columns can have labels, which makes it easier to
access and manipulate data.
- **Handling missing data**: Provides easy ways to handle missing data with
operations like `fillna()` or `dropna()`.
- **Data alignment and merging**: Tools for joining, merging, and aligning
datasets.

#### Example of Pandas:

```python
import pandas as pd

# Creating a Series (1D data structure)

data = [10, 20, 30, 40]
series = pd.Series(data)
print("Pandas Series:")
print(series)

# Creating a DataFrame (2D data structure)

data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35], 'City': ['New
York', 'Los Angeles', 'Chicago']}
df = pd.DataFrame(data)
print("\nPandas DataFrame:")
print(df)

# Accessing a column
print("\nAccessing the 'Name' column:")
print(df['Name'])

# Basic operations
df['Age'] = df['Age'] + 1 # Incrementing age by 1
print("\nDataFrame after incrementing age by 1:")
print(df)

# Handling missing data

df.loc[1, 'Age'] = None # Introducing missing data
print("\nDataFrame with missing data:")
print(df)

# Filling missing data with a specified value

df['Age'] = df['Age'].fillna(df['Age'].mean()) # Filling missing values with the
mean age
print("\nDataFrame after filling missing data:")
print(df)
```

**Output:**
```
Pandas Series:
0 10
1 20
2 30
3 40
dtype: int64

Pandas DataFrame:
Name Age City
0 Alice 25 New York
1 Bob 30 Los Angeles
2 Charlie 35 Chicago

Accessing the 'Name' column:

0 Alice
1 Bob
2 Charlie
Name: Name, dtype: object

DataFrame after incrementing age by 1:

Name Age City
0 Alice 26 New York
1 Bob 31 Los Angeles
2 Charlie 36 Chicago

DataFrame with missing data:

Name Age City
0 Alice 26.0 New York
1 Bob NaN Los Angeles
2 Charlie 36.0 Chicago

DataFrame after filling missing data:

Name Age City
0 Alice 26.0 New York
1 Bob 31.0 Los Angeles
2 Charlie 36.0 Chicago
```

---

### **Summary of Differences:**

| Feature | **NumPy** | **Pandas**

|
|--------------------|---------------------------------------------|---------------
------------------------------|
| **Data Structure** | `ndarray` (for multi-dimensional arrays) | `Series`
(1D), `DataFrame` (2D) |
| **Use Case** | High-performance numerical computing, arrays | Data
manipulation, analysis, and cleaning |
| **Operations** | Element-wise operations, linear algebra, etc. | Label-based
indexing, data wrangling, merging, etc. |
| **Performance** | Faster for numerical operations due to vectorization |
Convenient and flexible, but may be slower for certain operations |
| **Library Focus** | Scientific computing, math-heavy tasks | Data analysis,
handling and analyzing structured data |

---

### **Conclusion:**

- **NumPy** is perfect for handling numerical data, especially for large-scale

mathematical operations, as it provides efficient arrays and advanced mathematical
functions.
- **Pandas** builds on NumPy and is tailored for data manipulation tasks, making it
much easier to handle structured data like tables, perform data wrangling, and
clean datasets. Pandas is especially useful for real-world data analysis tasks,
such as working with CSV files, handling missing data, and performing group-by
operations.

Both libraries are crucial in the data science ecosystem and are often used
together for various data processing and analysis tasks.