Lists

`sort()` changes the list in place and arranges the elements in ascending order.

So `list1` becomes:

`[12, 32, 65, 26, 80, 10] -> [10, 12, 26, 32, 65, 80]`

`sorted(list1)` creates a new sorted list and does not change the original list when the result is not stored anywhere.

So `print(list1)` prints the original list unchanged:

`[12, 32, 65, 26, 80, 10]`

- `list1[::-2]` produces a slice, but since it is not printed or stored, it has no visible output.
- `list1[:3] + list1[3:]` joins the first three elements with the remaining elements, so the list is unchanged.

Therefore the resulting list is:

`[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`

`list1[len(list1)-1]` means the last element.

- `len([1,2,3,4,5]) = 5`
- so the index is `5 - 1 = 4`
- `list1[4] = 5`

- append([50,60]) adds the whole list as a single element at the end.
- extend([80,90]) adds each element separately to the end.

So:

1. After `myList.append([50,60])` → `[10, 20, 30, 40, [50, 60]]`
2. After `myList.extend([80,90])` → `[10, 20, 30, 40, [50, 60], 80, 90]`

The loop checks every index `i` from `0` to `9`.

It prints `myList[i]` only when `i % 2 == 0`, i.e. for even indices:

- `i = 0` → `1`
- `i = 2` → `3`
- `i = 4` → `5`
- `i = 6` → `7`
- `i = 8` → `9`

So the output is:

`1`
`3`
`5`
`7`
`9`

- a. `del myList[3:]` deletes from index `3` to the end, so only the first three elements remain.
- Result: `[1, 2, 3]`
- b. `del myList[:5]` deletes from the start up to index `4`, so the last five elements remain.
- Result: `[6, 7, 8, 9, 10]`
- c. `del myList[::2]` deletes every element at even indices: `1, 3, 5, 7, 9`.
- Remaining elements are at odd indices: `[2, 4, 6, 8, 10]`

- append() inserts its argument as one element at the end of the list.
- Example: `[10, 20].append([30, 40])` gives `[10, 20, [30, 40]]`
- extend() adds the individual elements of the given list to the end.
- Example: `[10, 20].extend([30, 40])` gives `[10, 20, 30, 40]`

So, append() increases the list by one element, whereas extend() merges another list element by element.

For `list1 = [6,7,8,9]`:

- **a. `list1 * 2` → returns `[6, 7, 8, 9, 6, 7, 8, 9]`, but `list1` remains unchanged if the result is not stored.
- b. `list1 *= 2` → updates the same list in place, so `list1` becomes `[6, 7, 8, 9, 6, 7, 8, 9]`.
- c. `list1 = list1 * 2` → creates a new repeated list and assigns it to `list1`; the final contents are also `[6, 7, 8, 9, 6, 7, 8, 9]`.

The difference is that `* 2` only produces a value, while `*= 2` modifies the list in place and `list1 = list1 * 2` reassigns `list1` to a new list**.

The list structure is:

- `stRecord[0]` → name
- `stRecord[1]` → roll no.
- `stRecord[2]` → list of marks
- `stRecord[3]` → percentage

So:

- a) Percentage of the student: `stRecord[3]`
- b) Marks in the fifth subject: `stRecord[2][4]`
- c) Maximum marks of the student: `max(stRecord[2])`
- d) Roll no. of the student: `stRecord[1]`
- e) Change the name: `stRecord[0] = 'Raghav'`