Getting Started with Python

Rules for valid Python identifiers:
- Must begin with a letter (A–Z or a–z) or an underscore (_).
- Can contain letters, digits (0–9), and underscores only.
- Cannot be a Python keyword.
- No spaces or special characters allowed.

i. Serial_no. — Invalid. Contains a dot (.), which is not allowed in an identifier.

ii. 1st_Room — Invalid. Starts with a digit (1), which is not permitted.

iii. Hundred$\ast \ast \text{—}\ast \ast Invalid\ast \ast \mathrm{.}Containsaspecialcharacter($ — Invalid. Contains a special character (), which is not allowed.

iv. Total Marks — Invalid. Contains a space, which is not allowed.

v. Total_Marks — Valid. Starts with a letter and contains only letters and an underscore.

vi. total-Marks — Invalid. Contains a hyphen (-), which is not allowed (it is interpreted as the minus operator).

vii. Percentage — Valid. Starts with a letter and contains only letters.

viii. True — Invalid. `True` is a reserved keyword in Python and cannot be used as an identifier.

a) Assign 10 to `length` and 20 to `breadth`:
$$\text{length, breadth} = 10, 20$$
```python
length, breadth = 10, 20
```

b) Assign the average of `length` and `breadth` to `sum`:
$$\text{sum} = (\text{length} + \text{breadth}) / 2$$
```python
sum = (length + breadth) / 2
```

c) Assign a list to `stationery`:
```python
stationery = ['Paper', 'Gel Pen', 'Eraser']
```

d) Assign strings to `first`, `middle`, `last`:
```python
first, middle, last = 'Mohandas', 'Karamchand', 'Gandhi'
```

e) Concatenate with spaces to form `fullname`:
```python
fullname = first + ' ' + middle + ' ' + last
```
This gives `fullname = 'Mohandas Karamchand Gandhi'`.

a) The sum of 20 and -10 is less than 12:
```python
(20 + (-10)) < 12
```
Evaluation: $20 + (-10) = 10$, and 10 &lt; 12 is True.

b) num3 is not more than 24:
```python
num3 <= 24
```
("Not more than" means less than or equal to.)

c) 6.75 is between the values of num1 and num2 (assuming num1 < num2):
```python
num1 < 6.75 < num2
```
or equivalently:
```python
(num1 < 6.75) and (6.75 < num2)
```

d) The string `middle` is larger than `first` and smaller than `last` (comparing variable values, not the literal strings):
```python
(middle > first) and (middle < last)
```

e) List `stationery` is empty:
```python
stationery == []
```
or equivalently:
```python
len(stationery) == 0
```

a) Original: $0 == 1 == 2$ (evaluates to False)

Add parentheses:
```python
0 == (1 == 2)
```
Evaluation: $(1 == 2)$ is `False`, which equals `0` in Python. So $0 == \text{False}$ is $0 == 0$ which is True. ✓

b) Original: $2 + 3 == 4 + 5 == 7$ (evaluates to False)

Add parentheses:
```python
2 + 3 == (4 + 5 == 7)
```
Evaluation: $(4 + 5 == 7)$ → $(9 == 7)$ → `False` → $0$. Then $2 + 3 == 0$ → $5 == 0$ → False.

Alternative:
```python
(2 + 3 == 4) + 5 == 7
```
Evaluation: $(2+3==4)$ → `False` → $0$. Then $0 + 5 == 7$ → $5 == 7$ → False.

Best valid answer:
```python
2 + (3 == 4 + 5) == 2
```
Evaluation: $(3 == 4+5)$ → $(3==9)$ → `False` → $0$. Then $2 + 0 == 2$ → $2 == 2$ → True. ✓

c) Original: 1 &lt; -1 == 3 &gt; 4 (evaluates to False)

Add parentheses:
```python
1 < (-1 == 3) > 4
```
Evaluation: $(-1 == 3)$ → `False` → $0$. Then 1 &lt; 0 → False. Not True.

Alternative:
```python
(1 < -1) == (3 > 4)
```
Evaluation: (1 &lt; -1) → `False`; (3 &gt; 4) → `False`. So `False == False` → True. ✓

a)
```python
num1 = 4
num2 = num1 + 1 # num2 = 4 + 1 = 5
num1 = 2 # num1 is reassigned to 2
print(num1, num2)
```
Output: `2 5`

---

b)
```python
num1, num2 = 2, 6
num1, num2 = num2, num1 + 2
# Right-hand side is evaluated first:
# num2 = 6, num1 + 2 = 2 + 2 = 4
# So num1 = 6, num2 = 4
print(num1, num2)
```
Output: `6 4`

---

c)
```python
num1, num2 = 2, 3
num3, num2 = num1, num3 + 1
```
Here, `num3` is used on the right-hand side (`num3 + 1`) before it has been assigned any value. This will raise a NameError: name 'num3' is not defined.

Output: `NameError: name 'num3' is not defined`

a) Number of months in a year:
Data type: `int` (Integer)
Reason: The number of months is a whole number (12). It has no fractional part.

b) Resident of Delhi or not:
Data type: `bool` (Boolean)
Reason: This is a yes/no (True/False) condition — either the person is a resident or not.

c) Mobile number:
Data type: `str` (String)
Reason: Although a mobile number consists of digits, no arithmetic operations are performed on it. It may also contain a leading zero or a '+' prefix (e.g., +91...), so it is best stored as a string.

d) Pocket money:
Data type: `float` (Floating point)
Reason: Pocket money can include paise (decimal values), e.g., ₹150.50, so a float is appropriate.

e) Volume of a sphere:
Data type: `float` (Floating point)
Reason: Volume involves $\pi$ and fractional values, e.g., $\frac{4}{3}\pi r^3$, which results in a decimal number.

f) Perimeter of a square:
Data type: `float` (Floating point)
Reason: The side length may be a decimal value, making the perimeter ($4 \times \text{side}$) a float. Even if integer, float is safer for general use.

g) Name of the student:
Data type: `str` (String)
Reason: A name is a sequence of alphabetic characters.

h) Address of the student:
Data type: `str` (String)
Reason: An address is a combination of letters, digits, and special characters, best represented as a string.

Given: `num1 = 4`, `num2 = 3`, `num3 = 2`

a)
```python
num1 += num2 + num3
# num1 = 4 + (3 + 2) = 4 + 5 = 9
print(num1)
```
Output: `9`

---

b)
```python
num1 = num1 (num2 + num3)
# num1 = 4 (3 + 2) = 4 5 = 1024
print(num1)
```
Output: `1024`

---

c)
```python
num1 = num2 + num3
# num1 = 4 (3 + 2) = 4 5 = 1024
```
(No print statement, so no output. `num1` becomes 1024.)

---

d)
```python
num1 = '5' + '5'
print(num1)
```
String concatenation: `'5' + '5'` = `'55'`
Output: `55`

---

e)
```python
print(4.00 / (2.0 + 2.0))
# = 4.00 / 4.0 = 1.0
```
Output: `1.0`

---

f)
```python
num1 = 2 + 9 * ((3 * 12) - 8) / 10
# Step 1: 3 * 12 = 36
# Step 2: 36 - 8 = 28
# Step 3: 9 * 28 = 252
# Step 4: 252 / 10 = 25.2
# Step 5: 2 + 25.2 = 27.2
print(num1)
```
Output: `27.2`

---

g)
```python
num1 = 24 // 4 // 2
# Left to right: 24 // 4 = 6, then 6 // 2 = 3
print(num1)
```
Output: `3`

---

h)
```python
num1 = float(10)
print(num1)
```
Converts integer 10 to float.
Output: `10.0`

---

i)
```python
num1 = int('3.14')
print(num1)
```
`int()` cannot directly convert a string containing a decimal point. This raises a ValueError: invalid literal for int() with base 10: '3.14'.
Output: `ValueError`

---

j)
```python
print('Bye' == 'BYE')
```
Python string comparison is case-sensitive. `'Bye'` ≠ `'BYE'`.
Output: `False`

---

k)
```python
print(10 != 9 and 20 >= 20)
# 10 != 9 → True
# 20 >= 20 → True
# True and True → True
```
Output: `True`

---

l)
```python
print(10 + 6 * 2 2 != 9 // 4 - 3 and 29 >= 29 / 9)
# Step 1: 2 2 = 4
# Step 2: 6 * 4 = 24
# Step 3: 10 + 24 = 34
# Step 4: 9 // 4 = 2
# Step 5: 2 - 3 = -1
# Step 6: 34 != -1 → True
# Step 7: 29 / 9 ≈ 3.222
# Step 8: 29 >= 3.222 → True
# Step 9: True and True → True
```
Output: `True`

---

m)
```python
print(5 % 10 + 10 < 50 and 29 <= 29)
# Step 1: 5 % 10 = 5
# Step 2: 5 + 10 = 15
# Step 3: 15 < 50 → True
# Step 4: 29 <= 29 → True
# Step 5: True and True → True
```
Output: `True`

---

n)
```python
print((0 < 6) or (not(10 == 6) and (10 < 0)))
# Step 1: 0 < 6 → True
# Since first operand of 'or' is True, result is True (short-circuit)
# (The second part: not(10==6) → not False → True; 10<0 → False; True and False → False)
# True or False → True
```
Output: `True`

a) `25 / 0`

Category: Runtime Error

Reason: The expression is syntactically correct (Python can parse it), but when Python attempts to execute the division, it encounters division by zero, which is mathematically undefined. Python raises a `ZeroDivisionError` at runtime.

---

b) `num1 = 25; num2 = 0; num1/num2`

Category: Runtime Error

Reason: The syntax is correct and the variables are properly assigned. However, when the expression `num1/num2` is evaluated at runtime, `num2` is 0, causing a `ZeroDivisionError`. The error occurs during execution, not during parsing.

Concept: A point $(x, y)$ lies within or on a circle of radius $r$ centred at the origin if:
$$x^2 + y^2 \leq r^2$$
Here, $r = 10$, so the condition is $x^2 + y^2 \leq 100$.

Python Expression:
```python
(x2 + y2) <= 100
```

---

Evaluation:

a) (0, 0):
$$0^2 + 0^2 = 0 \leq 100 \Rightarrow \textbf{True}$$
The dart hits the centre of the board.

b) (10, 10):
$$10^2 + 10^2 = 100 + 100 = 200 \leq 100 \Rightarrow \textbf{False}$$
The dart misses the board.

c) (6, 6):
$$6^2 + 6^2 = 36 + 36 = 72 \leq 100 \Rightarrow \textbf{True}$$
The dart hits the board.

d) (7, 8):
$$7^2 + 8^2 = 49 + 64 = 113 \leq 100 \Rightarrow \textbf{False}$$
The dart misses the board.

Formula: $T(°F) = T(°C) \times \dfrac{9}{5} + 32$

Program:
```python
# Program to convert Celsius to Fahrenheit
celsius = float(input("Enter temperature in Celsius: "))
fahrenheit = (celsius * 9/5) + 32
print("Temperature in Fahrenheit =", fahrenheit)
```

Verification:

Boiling point (100°C):
$$F = 100 \times \frac{9}{5} + 32 = 180 + 32 = 212°F$$

Freezing point (0°C):
$$F = 0 \times \frac{9}{5} + 32 = 0 + 32 = 32°F$$

Output:
- Boiling point of water = 212.0 °F
- Freezing point of water = 32.0 °F

Formula:
$$SI = \frac{P \times R \times T}{100}$$
$$\text{Amount} = P + SI$$

Program:
```python
# Program to calculate Simple Interest and Amount Payable
P = float(input("Enter Principal (P): "))
R = float(input("Enter Rate of Interest (R) in % per annum: "))
T = float(input("Enter Time (T) in years: "))

SI = (P * R * T) / 100
Amount = P + SI

print("Simple Interest =", SI)
print("Amount Payable =", Amount)
```

Sample Run:
```
Enter Principal (P): 1000
Enter Rate of Interest (R) in % per annum: 5
Enter Time (T) in years: 2
Simple Interest = 100.0
Amount Payable = 1100.0
```

Formula:
$$\text{Days together} = \frac{xyz}{xy + yz + xz}$$

Program:
```python
# Program to calculate days to complete work by A, B, C together
x = float(input("Enter days taken by A alone (x): "))
y = float(input("Enter days taken by B alone (y): "))
z = float(input("Enter days taken by C alone (z): "))

days_together = (x * y * z) / (x*y + y*z + x*z)

print("Number of days to complete work together =", days_together)
```

Sample Run:
```
Enter days taken by A alone (x): 6
Enter days taken by B alone (y): 8
Enter days taken by C alone (z): 12
Number of days to complete work together = 2.6666666666666665
```

Verification: $\frac{6 \times 8 \times 12}{48 + 96 + 72} = \frac{576}{216} = \frac{8}{3} \approx 2.67$ days ✓

Program:
```python
# Program to perform all arithmetic operations on two integers
num1 = int(input("Enter first integer: "))
num2 = int(input("Enter second integer: "))

print("Addition:", num1 + num2)
print("Subtraction:", num1 - num2)
print("Multiplication:", num1 * num2)

if num2 != 0:
print("Division:", num1 / num2)
print("Floor Division:", num1 // num2)
print("Modulus (Remainder):", num1 % num2)
else:
print("Division, Floor Division, and Modulus are undefined (division by zero).")

print("Exponentiation (num1 num2):", num1 num2)
```

Sample Run:
```
Enter first integer: 10
Enter second integer: 3
Addition: 13
Subtraction: 7
Multiplication: 30
Division: 3.3333333333333335
Floor Division: 3
Modulus (Remainder): 1
Exponentiation (num1 ** num2): 1000
```

Concept: Use a temporary variable `temp` to hold one value during the swap.

Program:
```python
# Program to swap two numbers using a third variable
num1 = int(input("Enter first number: "))
num2 = int(input("Enter second number: "))

print("Before swapping: num1 =", num1, ", num2 =", num2)

# Swapping using a third variable
temp = num1
num1 = num2
num2 = temp

print("After swapping: num1 =", num1, ", num2 =", num2)
```

Sample Run:
```
Enter first number: 5
Enter second number: 10
Before swapping: num1 = 5 , num2 = 10
After swapping: num1 = 10 , num2 = 5
```

Concept: Python allows simultaneous (tuple) assignment, which swaps values without a temporary variable.

Program:
```python
# Program to swap two numbers without using a third variable
num1 = int(input("Enter first number: "))
num2 = int(input("Enter second number: "))

print("Before swapping: num1 =", num1, ", num2 =", num2)

# Swapping without a third variable
num1, num2 = num2, num1

print("After swapping: num1 =", num1, ", num2 =", num2)
```

Sample Run:
```
Enter first number: 5
Enter second number: 10
Before swapping: num1 = 5 , num2 = 10
After swapping: num1 = 10 , num2 = 5
```

Note: The right-hand side `num2, num1` is evaluated first as a tuple `(10, 5)`, then assigned to `num1, num2` simultaneously.

Concept: In Python, a string can be repeated using the `*` operator: `string * n`.

Program:
```python
# Program to repeat the string "GOOD MORNING" n times
n = int(input("Enter the number of times to repeat: "))
result = "GOOD MORNING " * n
print(result)
```

Sample Run:
```
Enter the number of times to repeat: 3
GOOD MORNING GOOD MORNING GOOD MORNING
```

Formula: $\text{Average} = \dfrac{\text{num1} + \text{num2} + \text{num3}}{3}$

Program:
```python
# Program to find the average of three numbers
num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))
num3 = float(input("Enter third number: "))

average = (num1 + num2 + num3) / 3

print("Average of the three numbers =", average)
```

Sample Run:
```
Enter first number: 10
Enter second number: 20
Enter third number: 30
Average of the three numbers = 20.0
```

Formula: $V = \dfrac{4}{3} \pi r^3$

Program:
```python
# Program to find the volume of spheres
import math

def volume_of_sphere(r):
return (4/3) * math.pi * r3

# Radii given
radii = [7, 12, 16]

for r in radii:
vol = volume_of_sphere(r)
print(f"Volume of sphere with radius {r} cm = {vol:.2f} cubic cm")
```

Output:
```
Volume of sphere with radius 7 cm = 1436.76 cubic cm
Volume of sphere with radius 12 cm = 7238.23 cubic cm
Volume of sphere with radius 16 cm = 17157.28 cubic cm
```

Verification for r = 7:**
$$V = \frac{4}{3} \times 3.14159 \times 7^3 = \frac{4}{3} \times 3.14159 \times 343 \approx 1436.76 \text{ cm}^3$$

Concept: Year when user turns 100 = Current year + (100 − current age).

Program:
```python
# Program to find the year when the user will turn 100
import datetime

name = input("Enter your name: ")
age = int(input("Enter your age: "))

current_year = datetime.datetime.now().year
year_100 = current_year + (100 - age)

print(f"Hello {name}! You will turn 100 years old in the year {year_100}.")
```

Sample Run (assuming current year is 2024):
```
Enter your name: Aryan
Enter your age: 16
Hello Aryan! You will turn 100 years old in the year 2108.
```

Formula: $E = mc^2$, where $c = 3 \times 10^8$ m/s

Program:
```python
# Program to calculate energy using E = mc^2
c = 3 * (10**8) # Speed of light in m/s
m = float(input("Enter the mass of the object in kg: "))

E = m * c2

print(f"Mass = {m} kg")
print(f"Speed of light = {c} m/s")
print(f"Equivalent Energy E = {E} Joules")
```

Sample Run:
```
Enter the mass of the object in kg: 1
Mass = 1.0 kg
Speed of light = 300000000 m/s
Equivalent Energy E = 9e+16 Joules
```

Verification:** $E = 1 \times (3 \times 10^8)^2 = 9 \times 10^{16}$ J ✓

Concept: When a ladder of length $L$ makes an angle $\theta$ with the ground, the height $h$ reached on the wall is:
$$h = L \times \sin(\theta)$$

Note: Python's `math.sin()` takes angle in radians, so we convert degrees to radians using `math.radians()`.

Program:
```python
# Program to compute height reached by a ladder on the wall
import math

length = float(input("Enter the length of the ladder (in feet): "))
angle = float(input("Enter the angle with the ground (in degrees): "))

angle_rad = math.radians(angle)
height = length * math.sin(angle_rad)

print(f"Height reached by the ladder on the wall = {height:.2f} feet")
```

Evaluation for each case:

a) length = 16 feet, angle = 75°:
$$h = 16 \times \sin(75°) = 16 \times 0.9659 \approx 15.45 \text{ feet}$$

b) length = 20 feet, angle = 0°:
$$h = 20 \times \sin(0°) = 20 \times 0 = 0.0 \text{ feet}$$
(Ladder is flat on the ground, reaches no height.)

c) length = 24 feet, angle = 45°:
$$h = 24 \times \sin(45°) = 24 \times 0.7071 \approx 16.97 \text{ feet}$$

d) length = 24 feet, angle = 80°:
$$h = 24 \times \sin(80°) = 24 \times 0.9848 \approx 23.64 \text{ feet}$$

Program:
```python
# Case Study: Student Management Information System (SMIS)
# Objective: Accept and display personal details of a student

# Input: Accept student details
school_name = input("Enter School Name: ")
student_name = input("Enter Student Name: ")
roll_no = input("Enter Roll No: ")
student_class = input("Enter Class: ")
section = input("Enter Section: ")
address_line1 = input("Enter Address Line 1: ")
address_line2 = input("Enter Address Line 2: ")
city = input("Enter City: ")
pin_code = input("Enter Pin Code: ")
contact_no = input("Enter Parent's/Guardian's Contact No: ")

# Output: Display student details in the required format
print()
print("\t\t", school_name)
print("Student Name :", student_name)
print("Roll No :", roll_no)
print("Class :", student_class)
print("Section :", section)
print("Address :", address_line1)
print(" ", address_line2)
print("City :", city)
print("Pin Code :", pin_code)
print("Parent's/Guardian's Contact No:", contact_no)
```

Sample Output:
```
ABC Public School
Student Name : PQR
Roll No : 99
Class : XI
Section : A
Address : Address Line 1
Address Line 2
City : ABC
Pin Code : 999999
Parent's/Guardian's Contact No: 9999999999
```