Tuples and Dictionaries

Using tuple operations:

- `tuple1.index(45)` gives the index of the first `45`, which is `2`.
- `tuple1.count(45)` counts all `45`s, which is `3`.
- `tuple1 + tuple2` concatenates the tuples.
- `len(tuple2) = 2`
- `max(tuple1) = 67`
- `min(tuple1) = 1`
- `sum(tuple2) = 100 + 200 = 300`
- `sorted(tuple1)` returns a list in ascending order.
- `print(tuple1)` prints the original tuple unchanged.

So the outputs are:

i. `2`
ii. `3`
iii. `(23, 1, 45, 67, 45, 9, 55, 45, 100, 200)`
iv. `2`
v. `67`
vi. `1`
vii. `300`
viii. `[1, 9, 23, 45, 45, 45, 55, 67]`

`(23, 1, 45, 67, 45, 9, 55, 45)`

From the dictionary operations in the chapter:

- `stateCapital.get("Bihar")` returns the value for `Bihar`, which is Patna.
- `keys()`, `values()`, and `items()` return the dictionary views in the same order the items were entered.
- `len(stateCapital)` is `4`.
- `"Maharashtra" in stateCapital` checks for the key, so it is `True`.
- `stateCapital.get("Assam")` returns `None` because the key is not present.
- After deleting `"Rajasthan"`, the remaining dictionary is shown.

So the outputs are:

i. `Patna`
ii. `dict_keys(['AndhraPradesh', 'Bihar', 'Maharashtra', 'Rajasthan'])`
iii. `dict_values(['Hyderabad', 'Patna', 'Mumbai', 'Jaipur'])`
iv. `dict_items([('AndhraPradesh', 'Hyderabad'), ('Bihar', 'Patna'), ('Maharashtra', 'Mumbai'), ('Rajasthan', 'Jaipur')])`
v. `4`
vi. `True`
vii. `None`
viii. `{'AndhraPradesh': 'Hyderabad', 'Bihar': 'Patna', 'Maharashtra': 'Mumbai'}`

A list and a tuple are both ordered sequences. This means that every element has a fixed position, so the order in which elements are stored is maintained.

Because they are ordered, we can access elements by index. For example, the first element is at index $0$, the second at index $1$, and so on. In a list or tuple, the same set of elements arranged in a different order is considered different.

So, saying "Lists and Tuples are ordered" means their elements are stored in a definite sequence and can be accessed by position.

A function can return more than one value by returning a tuple.

Example:

```python
def circle(r):
area = 3.14 * r * r
circumference = 2 * 3.14 * r
return (area, circumference)

radius = 5
area, circumference = circle(radius)
print(area)
print(circumference)
```

Here, the function `circle()` returns two values: area and circumference. These are packed into a tuple and then unpacked into two variables on the left side of the assignment.

Tuples have these advantages over lists:

- Tuples are immutable: once created, their elements cannot be changed accidentally.
- Because they do not change, iterating through a tuple is faster than through a list.
- Tuples are useful for storing data that should remain fixed, such as records.

So, tuples are better when the data is not meant to change.

Use a tuple when the data is fixed and should not be changed. For example:

- storing a student's roll number, name, and marks together
- storing a record that must remain unchanged

Use a dictionary when data needs to be stored as key-value pairs and accessed by a key. For example:

- storing names of students as keys and their marks as values
- storing state names as keys and capital cities as values
- storing phone numbers of friends with names as keys

So, tuples are useful for fixed ordered data, while dictionaries are useful for mapping one thing to another.

For an immutable data type, if we try to change a value, Python does not modify the existing object; instead, a new object is created.

Example:

```python
s = "Hello"
print(id(s))
s = s + " World"
print(id(s))
```

The string `s` is immutable. When `" World"` is added, the old string is not changed. A new string is created, so the `id()` value changes. This proves that the variable is rebuilt in case of immutable data types.

`tuple1 = (5)` does not create a tuple. It is treated as an integer because a single-element tuple must have a comma.

So `len(tuple1)` causes a TypeError because `len()` cannot be applied to an integer.

Correct form:

```python
tuple1 = (5,)
print(len(tuple1))
```

Now `tuple1` is a tuple with one element, so `len(tuple1)` will work.

```python
# Read email IDs of n students and store them in a tuple
n = int(input("Enter number of students: "))
emails = ()
usernames = ()
domains = ()

for i in range(n):
email = input("Enter email ID: ")
emails = emails + (email,)
username, domain = email.split('@')
usernames = usernames + (username,)
domains = domains + (domain,)

print("Email IDs:", emails)
print("Usernames:", usernames)
print("Domains:", domains)
```

This program stores the email IDs in a tuple, then uses `split('@')` to separate each email into username and domain, and stores them in two new tuples.