Question 1

Consider the following tuples, tuple1 and tuple2:

tuple1 = (23,1,45,67,45,9,55,45)
tuple2 = (100,200)

Find the output of the following statements:

i. print(tuple1.index(45))
ii. print(tuple1.count(45))
iii. print(tuple1 + tuple2)
iv. print(len(tuple2))
v. print(max(tuple1))
vi print(min(tuple1))
vii. print(sum(tuple2))
viii. print(sorted(tuple1))
print(tuple1)

Accepted Answer

Given:
 tuple1 = (23,1,45,67,45,9,55,45)
 tuple2 = (100,200)

Solutions:

i. tuple1.index(45) returns the index of the first occurrence of 45 in tuple1.
   tuple1 = (23,1,45,67,45,9,55,45)
   The first 45 is at index 2 (0-based indexing).
   Output: 2

ii. tuple1.count(45) counts how many times 45 appears in tuple1.
   45 appears 3 times.
   Output: 3

iii. tuple1 + tuple2 concatenates the two tuples.
   Output: (23,1,45,67,45,9,55,45,100,200)

iv. len(tuple2) gives the length of tuple2.
   tuple2 has 2 elements.
   Output: 2

v. max(tuple1) gives the maximum value in tuple1.
   Values: 23,1,45,67,45,9,55,45
   Maximum is 67.
   Output: 67

vi. min(tuple1) gives the minimum value in tuple1.
   Minimum is 1.
   Output: 1

vii. sum(tuple2) sums all elements in tuple2.
   100 + 200 = 300
   Output: 300

viii. sorted(tuple1) returns a sorted list of tuple1 elements.
   Sorted: [1, 9, 23, 45, 45, 45, 55, 67]
   Output: [1, 9, 23, 45, 45, 45, 55, 67]

print(tuple1) prints the original tuple1.
Output: (23, 1, 45, 67, 45, 9, 55, 45) — Step-by-step:
- index(45): Find first occurrence index.
- count(45): Count occurrences.
- + operator: Concatenate tuples.
- len(): Number of elements.
- max()/min(): Find max/min values.
- sum(): Add all elements.
- sorted(): Return sorted list.
- print(tuple1): Display original tuple.

Question 2

Consider the following dictionary stateCapital:
stateCapital = {"AndhraPradesh": "Hyderabad", "Bihar": "Patna", "Maharashtra": "Mumbai", "Rajasthan": "Jaipur"}
Find the output of the following statements:

i. print(stateCapital.get("Bihar"))
ii. print(stateCapital.keys())
iii. print(stateCapital.values())
iv. print(stateCapital.items())
v. print(len(stateCapital))
vi. print("Maharashtra" in stateCapital)
vii. print(stateCapital.get("Assam"))
viii. del stateCapital["Rajasthan"]
print(stateCapital)

Accepted Answer

Given:
stateCapital = {"AndhraPradesh": "Hyderabad", "Bihar": "Patna", "Maharashtra": "Mumbai", "Rajasthan": "Jaipur"}

Solutions:

i. stateCapital.get("Bihar") returns the value for key "Bihar".
   Output: Patna

ii. stateCapital.keys() returns all keys.
   Output: dict_keys(['AndhraPradesh', 'Bihar', 'Maharashtra', 'Rajasthan'])

iii. stateCapital.values() returns all values.
   Output: dict_values(['Hyderabad', 'Patna', 'Mumbai', 'Jaipur'])

iv. stateCapital.items() returns key-value pairs as tuples.
   Output: dict_items([('AndhraPradesh', 'Hyderabad'), ('Bihar', 'Patna'), ('Maharashtra', 'Mumbai'), ('Rajasthan', 'Jaipur')])

v. len(stateCapital) returns number of key-value pairs.
   Output: 4

vi. "Maharashtra" in stateCapital checks if key exists.
   Output: True

vii. stateCapital.get("Assam") returns None as key "Assam" not present.
   Output: None

viii. del stateCapital["Rajasthan"] deletes the key "Rajasthan".
After deletion, print(stateCapital) outputs:
{'AndhraPradesh': 'Hyderabad', 'Bihar': 'Patna', 'Maharashtra': 'Mumbai'} — Step-by-step:
- get(key): Returns value or None if key absent.
- keys(): Returns all keys.
- values(): Returns all values.
- items(): Returns all key-value pairs.
- len(): Number of entries.
- 'in' operator: Checks key presence.
- del: Deletes key-value pair.

Question 3

"Lists and Tuples are ordered". Explain.

Accepted Answer

Lists and tuples are ordered because the elements have a defined sequence and each element can be accessed by its index. The order in which elements are inserted is preserved. For example, in a list [10, 20, 30], 10 is at index 0, 20 at index 1, and 30 at index 2. Similarly, in a tuple (5, 15, 25), the order is maintained and elements can be accessed by their positions. — Ordered means elements maintain their position and can be accessed via indices. This property allows predictable retrieval and manipulation of elements based on their order.

Question 4

With the help of an example show how can you return more than one value from a function.

Accepted Answer

In Python, a function can return multiple values by returning them as a tuple. For example:

def get_min_max(numbers):
    return min(numbers), max(numbers)

result = get_min_max([10, 20, 30, 40])
print(result)  # Output: (10, 40)

Here, the function get_min_max returns two values: minimum and maximum of the list. These are returned as a tuple and can be unpacked if needed. — Functions can return multiple values by returning a tuple containing all values. This allows returning more than one result from a single function call.

Question 5

What advantages do tuples have over lists?

Accepted Answer

Advantages of tuples over lists:
1. Tuples are immutable, so their elements cannot be changed, which makes them safer to use when data should not be modified.
2. Tuples can be used as keys in dictionaries because they are hashable, unlike lists.
3. Tuples generally have faster access and are more memory efficient than lists.
4. Tuples can be used to represent fixed collections of items.

These advantages make tuples suitable for storing data that should remain constant. — Immutability provides safety and hashability, enabling use as dictionary keys. Memory efficiency and speed are additional benefits.

Question 6

When to use tuple or dictionary in Python. Give some examples of programming situations mentioning their usefulness.

Accepted Answer

Use tuples when you need an ordered collection of items that should not change throughout the program. For example, storing coordinates (x, y) of a point, or returning multiple values from a function.

Use dictionaries when you need to associate keys with values for fast lookup, insertion, and deletion. For example, storing student names as keys and their marks as values, or mapping country names to their capitals.

Examples:
- Tuple: Representing RGB color as (255, 0, 0).
- Dictionary: Storing phone book entries with names as keys and phone numbers as values. — Tuples are immutable ordered collections useful for fixed data. Dictionaries provide key-value mapping useful for associative arrays and fast data retrieval.

Question 7

Prove with the help of an example that the variable is rebuilt in case of immutable data types.

Accepted Answer

Example:

x = (1, 2, 3)
print(id(x))  # Suppose id is 140353
x = x + (4,)
print(id(x))  # New id, e.g., 140400

Explanation:
Initially, x points to a tuple (1, 2, 3). When we add (4,) to x, a new tuple is created and x now points to this new tuple. The id (memory address) changes, proving that the variable is rebuilt rather than modified in place, which is characteristic of immutable data types like tuples. — Immutable objects cannot be changed after creation; operations create new objects and variables point to these new objects.

Question 8

TypeError occurs while statement 2 is running. Give reason. How can it be corrected?

>>> tuple1 = (5)  #statement 1
>>> len(tuple1)  #statement 2

Accepted Answer

Reason:
In statement 1, tuple1 = (5) is not a tuple but an integer enclosed in parentheses. Hence, tuple1 is an int, and len(tuple1) causes TypeError because integers do not have length.

Correction:
To create a tuple with one element, a comma is needed:

tuple1 = (5,)

Now, len(tuple1) will return 1 without error. — Parentheses alone do not make a tuple; a trailing comma is required for single-element tuples.

Question 9

Write a program to read email IDs of n number of students and store them in a tuple. Create two new tuples, one to store only the usernames from the email IDs and second to store domain names from the email IDs. Print all three tuples at the end of the program. [Hint: You may use the function split()]

Accepted Answer

Solution:

# Read number of students
n = int(input("Enter number of students: "))

# Read email IDs and store in a tuple
email_ids = tuple(input(f"Enter email ID of student {i+1}: ") for i in range(n))

# Extract usernames and domain names
usernames = tuple(email.split('@')[0] for email in email_ids)
domains = tuple(email.split('@')[1] for email in email_ids)

# Print all three tuples
print("Email IDs:", email_ids)
print("Usernames:", usernames)
print("Domain names:", domains) — Step-by-step:
1. Input the number of students.
2. Use a loop to input each email ID and store them in a tuple.
3. For each email ID, split the string at '@' to separate username and domain.
4. Store usernames and domains in separate tuples.
5. Print all three tuples.

Question 10

Consider the following tuples, tuple1 and tuple2:

tuple1 = (23,1,45,67,45,9,55,45)
tuple2 = (100,200)

Find the output of the following statements:

i. print(tuple1.index(45))
ii. print(tuple1.count(45))
iii. print(tuple1 + tuple2)
iv. print(len(tuple2))
v. print(max(tuple1))
vi. print(min(tuple1))
vii. print(sum(tuple2))
viii. print(sorted(tuple1))
print(tuple1)

Accepted Answer

Given:
 tuple1 = (23,1,45,67,45,9,55,45)
 tuple2 = (100,200)

Solutions:
 i. tuple1.index(45) returns the index of the first occurrence of 45 in tuple1.
    The first 45 is at index 2 (0-based indexing).
    Output: 2

ii. tuple1.count(45) counts how many times 45 appears in tuple1.
     45 appears 3 times.
     Output: 3

iii. tuple1 + tuple2 concatenates the two tuples.
      Output: (23, 1, 45, 67, 45, 9, 55, 45, 100, 200)

iv. len(tuple2) returns the length of tuple2.
     tuple2 has 2 elements.
     Output: 2

v. max(tuple1) returns the maximum element in tuple1.
    Elements are: 23,1,45,67,45,9,55,45
    Maximum is 67.
    Output: 67

vi. min(tuple1) returns the minimum element in tuple1.
     Minimum is 1.
     Output: 1

vii. sum(tuple2) returns the sum of elements in tuple2.
      100 + 200 = 300
      Output: 300

viii. sorted(tuple1) returns a sorted list of elements in tuple1.
       Sorted tuple1: [1, 9, 23, 45, 45, 45, 55, 67]
       Output: [1, 9, 23, 45, 45, 45, 55, 67]

print(tuple1) prints the original tuple1.
 Output: (23, 1, 45, 67, 45, 9, 55, 45) — Step-by-step:
- index() finds first occurrence index.
- count() counts occurrences.
- + concatenates tuples.
- len() returns number of elements.
- max() and min() find max and min values.
- sum() adds elements.
- sorted() returns sorted list.
- print() outputs the tuple as is.

Question 11

Consider the following dictionary stateCapital:
stateCapital = {"AndhraPradesh": "Hyderabad", "Bihar": "Patna", "Maharashtra": "Mumbai", "Rajasthan": "Jaipur"}
Find the output of the following statements:

i. print(stateCapital.get("Bihar"))
ii. print(stateCapital.keys())
iii. print(stateCapital.values())
iv. print(stateCapital.items())
v. print(len(stateCapital))
vi. print("Maharashtra" in stateCapital)
vii. print(stateCapital.get("Assam"))
viii. del stateCapital["Rajasthan"]
print(stateCapital)

Accepted Answer

Given:
 stateCapital = {"AndhraPradesh": "Hyderabad", "Bihar": "Patna", "Maharashtra": "Mumbai", "Rajasthan": "Jaipur"}

Solutions:
 i. stateCapital.get("Bihar") returns the value for key "Bihar".
    Output: Patna

ii. stateCapital.keys() returns all keys in the dictionary.
     Output: dict_keys(['AndhraPradesh', 'Bihar', 'Maharashtra', 'Rajasthan'])

iii. stateCapital.values() returns all values.
      Output: dict_values(['Hyderabad', 'Patna', 'Mumbai', 'Jaipur'])

iv. stateCapital.items() returns key-value pairs as tuples.
     Output: dict_items([('AndhraPradesh', 'Hyderabad'), ('Bihar', 'Patna'), ('Maharashtra', 'Mumbai'), ('Rajasthan', 'Jaipur')])

v. len(stateCapital) returns number of key-value pairs.
    Output: 4

vi. "Maharashtra" in stateCapital checks if key exists.
     Output: True

vii. stateCapital.get("Assam") tries to get value for "Assam" key which does not exist.
      Returns None.
      Output: None

viii. del stateCapital["Rajasthan"] deletes the key "Rajasthan" and its value.
       After deletion, print(stateCapital) outputs:
       {'AndhraPradesh': 'Hyderabad', 'Bihar': 'Patna', 'Maharashtra': 'Mumbai'} — Step-by-step:
- get() fetches value for given key or None if absent.
- keys(), values(), items() return views of dictionary contents.
- len() returns number of entries.
- 'in' operator checks key presence.
- del removes key-value pair.
- print shows updated dictionary.

Question 12

"Lists and Tuples are ordered". Explain.

Accepted Answer

Lists and tuples in Python are ordered collections, which means that the items have a defined order, and that order will not change unless explicitly modified (in case of lists). This ordering allows elements to be accessed by their index positions starting from 0. For example, in a list [10, 20, 30], 10 is at index 0, 20 at index 1, and 30 at index 2. Similarly, in a tuple (10, 20, 30), the order is preserved and elements can be accessed by their indices. This property distinguishes ordered collections from unordered ones like sets or dictionaries (prior to Python 3.7). — The explanation highlights that both lists and tuples maintain the sequence of elements, enabling index-based access and predictable iteration order.

Question 13

With the help of an example show how can you return more than one value from a function.

Accepted Answer

In Python, a function can return multiple values by returning a tuple containing those values. For example:

```python
def arithmetic_operations(a, b):
    sum_val = a + b
    diff_val = a - b
    return sum_val, diff_val

result = arithmetic_operations(10, 5)
print(result)  # Output: (15, 5)

# To get individual values:
sum_result, diff_result = arithmetic_operations(10, 5)
print(sum_result)  # 15
print(diff_result) # 5
```

Here, the function `arithmetic_operations` returns two values as a tuple, which can be unpacked into separate variables. — The function returns multiple values as a tuple, which can be captured as a single tuple or unpacked into multiple variables.

Question 14

What advantages do tuples have over lists?

Accepted Answer

Advantages of tuples over lists:
1. Immutability: Tuples are immutable, meaning their elements cannot be changed after creation. This makes tuples safer to use when you want to ensure data integrity.
2. Performance: Tuples can be more memory efficient and faster than lists due to immutability.
3. Hashability: Tuples can be used as keys in dictionaries because they are hashable, whereas lists cannot.
4. Semantic clarity: Using tuples can indicate that the data is fixed and should not be modified.

Hence, tuples are preferred when the data should remain constant and when you need to use the data as dictionary keys. — The explanation covers immutability, performance, hashability, and semantic usage as key advantages of tuples.

Question 15

When to use tuple or dictionary in Python. Give some examples of programming situations mentioning their usefulness.

Accepted Answer

Tuples and dictionaries serve different purposes in Python:

- Use a tuple when you want to store a collection of items that should not change throughout the program. Tuples are ordered and immutable. For example, storing coordinates of a point (x, y), or fixed configuration values.

- Use a dictionary when you want to store data as key-value pairs, allowing fast lookup, insertion, and deletion by key. Dictionaries are mutable and unordered (in older Python versions) but maintain insertion order in Python 3.7+.

Examples:
1. Tuple:
   Storing RGB color values: color = (255, 0, 0)
   Coordinates of a location: location = (28.7041, 77.1025)

2. Dictionary:
   Storing student marks: marks = {"Alice": 85, "Bob": 90}
   Configuration settings: config = {"theme": "dark", "font": "Arial"}

Use tuples when data is fixed and should not be modified, and dictionaries when you need to associate values with unique keys and modify data dynamically. — The answer explains the characteristics of tuples and dictionaries and provides practical examples illustrating when to use each.

Tuples and Dictionaries

Tuples and Dictionaries — Study Notes

10.1 INTRODUCTION TO TUPLES

10.1.1 Accessing Elements in a Tuple

10.1.2 Tuple is Immutable

Practice Questions — Tuples and Dictionaries

All 11 Chapters in Computer Science