Q1.
2 Marks Each
1. Use of lambda function in Python:
Lambda functions are anonymous functions defined using the `lambda` keyword for short,
one-line operations. They are useful in functional programming with `map()`, `filter()`, etc.
Example: `x = lambda a: a + 10` → `print(x(5))` outputs `15`.
2. Data Hiding concept and two advantages:
Data Hiding restricts direct access to class attributes using double underscores (`__`) to make
them private, accessible only via methods.
Advantages:
- Enhances security by preventing unauthorized changes.
- Simplifies maintenance by hiding internal details.
3. Syntax of fopen:
Python uses `open()` instead of `fopen` (a C function). Syntax:
```python
file_object = open("filename", "mode")
```
Example: `f = open("data.txt", "r")` opens file for reading.
4. Four Python built-in functions with examples:
- `len()`: Returns length. Example: `len("Python")` → `6`.
- `print()`: Displays output. Example: `print("Hi")` → `Hi`.
- `input()`: Takes user input. Example: `x = input("Enter: ")`.
- `range()`: Generates numbers. Example: `list(range(3))` → `[0, 1, 2]`.
5. Method Overloading example:
Python doesn’t support traditional method overloading but uses default or variable arguments.
```python
class Calculator:
def sum(self, a, b=0):
return a + b
calc = Calculator()
print(calc.sum(5)) # Output: 5
print(calc.sum(5, 3)) # Output: 8
```
6. Python program for zero division error:
```python
try:
num = int(input("Enter number: "))
result = 10 / num
print("Result:", result)
except ZeroDivisionError:
print("Error: Division by zero not allowed!")
```
7. Use of matplotlib package:
Matplotlib is a plotting library used to create 2D graphs and visualizations like line plots, bar
charts, etc., for data representation.
Example: Plotting `y = x^2`.
8. Object-oriented features in Python:
- Encapsulation: Bundling data and methods.
- Inheritance: Reusing parent class code.
- Polymorphism: Same method, different behavior.
- Abstraction: Hiding complexity.
9. Modes of opening a file in Python:
- `"r"`: Read (default).
- `"w"`: Write (overwrites).
- `"a"`: Append.
- `"r+"`: Read and write.
10. Module explanation and definition:
A module is a `.py` file with functions, classes, or variables for code reuse.
Define: Create `maths.py` with:
```python
def add(a, b):
return a + b
```
Use: `import maths`.
11. Class Student with methods:
```python
class Student:
def read_data(self):
self.name = input("Enter Name: ")
self.roll = int(input("Enter Roll No: "))
def display_data(self):
print("Name:", self.name)
print("Roll No:", self.roll)
s = Student()
s.read_data()
s.display_data()
```
12. Try-except-else-finally block with example:
- `try`: Tests code.
- `except`: Catches errors.
- `else`: Runs if no error.
- `finally`: Always runs.
```python
try:
x = 10 / 5
except ZeroDivisionError:
print("Error!")
else:
print("Result:", x)
finally:
print("Finished")
```
13. Purpose of self keyword:
`self` represents the current object in a class, used to access its attributes and methods.
14. Use of super():
`super()` calls a parent class method, often used in inheritance.
Example: `super().__init__()` calls parent’s constructor.
15. Use of __init__ method:
`__init__` initializes object attributes when created.
Example: `def __init__(self): self.x = 10`.
16. Four methods of os module:
- `os.mkdir()`: Creates directory.
- `os.remove()`: Deletes file.
- `os.getcwd()`: Gets current directory.
- `os.listdir()`: Lists directory contents.
17. Two functions to write data in a file:
- `write()`: Writes a string.
- `writelines()`: Writes a list of strings.
---
### Q2. 4 Marks Each
1. Program importing user-defined module:
```python
# mymodule.py
def add(a, b):
return a + b
def subtract(a, b):
return a - b
# main.py
import mymodule
print("Sum:", mymodule.add(5, 3)) # Output: 8
print("Difference:", mymodule.subtract(5, 3)) # Output: 2
```
2. Pandas package with example:
Pandas is used for data analysis with structures like DataFrames.
```python
import pandas as pd
data = {"Roll": [1, 2], "Marks": [85, 90]}
df = pd.DataFrame(data)
print(df)
```
3. Program for multiple and multilevel inheritance:
```python
class A:
def showA(self):
print("Class A")
class B:
def showB(self):
print("Class B")
class C(A, B): # Multiple
def showC(self):
print("Class C")
class D(C): # Multilevel
def showD(self):
print("Class D")
obj = D()
obj.showA() # Output: Class A
obj.showC() # Output: Class C
```
4. Program to read from end and write to another file:
```python
f1 = open("first.txt", "r")
content = f1.read()
reversed_content = content[::-1]
f1.close()
f2 = open("second.txt", "w")
f2.write(reversed_content)
f2.close()
print("Content reversed and written!")
```
5. Program using user-defined package:
```python
# mypackage/calc.py
def multiply(a, b):
return a * b
# main.py
from mypackage import calc
result = calc.multiply(4, 5)
print("Result:", result) # Output: 20
```
6. NumPy package with example:
NumPy supports numerical operations with arrays.
```python
import numpy as np
arr = np.array([1, 2, 3])
print("Array:", arr * 2) # Output: [2 4 6]
```
7. Parent Animal and child Herbivorous class:
```python
class Animal:
def feed(self):
print("Animal eats food")
class Herbivorous(Animal):
def feed(self):
print("Herbivorous eats plants")
obj = Herbivorous()
obj.feed() # Output: Herbivorous eats plants
```
8. Count vowels, consonants, characters, spaces in file:
```python
f = open("sample.txt", "r")
text = f.read()
vowels = "aeiouAEIOU"
v, c, s, t = 0, 0, 0, 0
for ch in text:
t += 1
if ch in vowels:
v += 1
elif ch.isalpha():
c += 1
elif ch == " ":
s += 1
print("Vowels:", v)
print("Consonants:", c)
print("Spaces:", s)
print("Total:", t)
f.close()
```
9. Exception Handling in Python:
Exception handling uses `try`, `except`, `else`, and `finally` to manage errors and prevent
crashes.
Example: See Q1.12.
10. Program to read 10 characters from a file:
```python
f = open("data.txt", "r")
chars = f.read(10)
print("First 10 characters:", chars)
f.close()
```
11. Modes for file opening in Python:
- `"r"`: Read only.
- `"w"`: Write (overwrites).
- `"a"`: Append to end.
- `"r+"`: Read and write.
- `"b"`: Binary mode (e.g., `"rb"`).