This program focuses on basic operations such as creating a list, accessing

elements, modifying elements, and using list methods.

```python
# Python Program: List Basics

# Creating a list of fruits

fruits = ["apple", "banana", "orange", "grape", "kiwi"]

# Displaying the original list

print("Original List of Fruits:", fruits)

# Accessing elements in a list

print("\nAccessing Elements:")
print("First Fruit:", fruits[0])
print("Second Fruit:", fruits[1])
print("Last Fruit:", fruits[-1])

# Modifying elements in a list

print("\nModifying Elements:")
fruits[1] = "pear"
print("Updated List:", fruits)

# Adding elements to a list

print("\nAdding Elements:")
fruits.append("melon")
print("List after Adding Melon:", fruits)

# Removing elements from a list

print("\nRemoving Elements:")
removed_fruit = fruits.pop(2)
print("Removed Fruit:", removed_fruit)
print("List after Removing Orange:", fruits)

# List slicing
print("\nList Slicing:")
subset_of_fruits = fruits[1:4]
print("Subset of Fruits:", subset_of_fruits)

# Finding the length of a list

print("\nLength of the List:", len(fruits))

# Checking if an element is in the list

print("\nChecking Element:")
if "kiwi" in fruits:
print("Kiwi is in the list.")
else:
print("Kiwi is not in the list.")
```
**Explanation:**
1. The program starts by creating a list of fruits.
2. It demonstrates accessing elements using index, modifying elements, adding elements
using `append`, and removing elements using `pop`.
3. List slicing is used to create a subset of the original list.
4. The program finds the length of the list using `len`.
5. It checks if a specific element ("kiwi") is in the list.

**Suggestions for Revision:**

- Encourage students to modify the program by adding more fruits to the list and
experimenting with various list operations.
- Ask students to explore additional list methods such as `insert`, `remove`, and `clear`.
- Challenge students to create a program that takes user input to build a dynamic list.
- Discuss the concept of mutable sequences (lists) and how they differ from immutable
sequences (like tuples).

### Lists in Python:

#### 1. **Definition:**
- A list is a versatile, ordered, and mutable collection of items.
- Items in a list can be of different data types, including numbers, strings, or even other lists.

#### 2. **Creating Lists:**

- Lists are created using square brackets `[]` and can be assigned to a variable.
- Example:

```python
fruits = ["apple", "banana", "orange", "grape"]
```

#### 3. **Accessing Elements:**

- Elements in a list are accessed using their index.
- Indexing starts from 0 for the first element.
- Negative indexing is also possible, starting from -1 for the last element.
- Example:

```python
print(fruits[0]) # Output: "apple"
print(fruits[-1]) # Output: "grape"
```

#### 4. **Modifying Elements:**

- Lists are mutable, meaning you can change their elements after creation.
- Example:

```python
fruits[1] = "pear"
```

#### 5. **Adding Elements:**

- Elements can be added to the end of the list using the `append` method.
- Example:
 ```python
fruits.append("kiwi")
```

#### 6. **Removing Elements:**

- Elements can be removed using the `pop` method by specifying the index.
- Example:

```python
removed_fruit = fruits.pop(2)
```

#### 7. **List Slicing:**

- You can create a subset of a list using slicing.
- Slicing is done using the colon (`:`) notation.
- Example:

```python
subset_of_fruits = fruits[1:3]
```

#### 8. **Length of a List:**

- The `len` function returns the number of elements in a list.
- Example:

```python
length_of_list = len(fruits)
```

#### 9. **Checking Membership:**

- You can check if an element is present in a list using the `in` keyword.
- Example:

```python
if "kiwi" in fruits:
print("Kiwi is in the list.")
```

#### 10. **List Methods:**

- Lists have several built-in methods for various operations (e.g., `insert`, `remove`, `extend`,
`index`).
- Example:

```python
fruits.insert(1, "peach")
```

#### 11. **Iterating Over a List:**

- You can use loops (e.g., `for` loop) to iterate over the elements of a list.
- Example:

```python
for fruit in fruits:
print(fruit)
```
#### 12. **List Comprehension:**
- List comprehensions provide a concise way to create lists.
- Example:

```python
squared_numbers = [x**2 for x in range(5)]
```

#### 13. **Copying Lists:**

- Be careful when copying lists. Assignment (`new_list = old_list`) creates a reference, not a new
list.
- Example:

```python
new_list = fruits.copy()
```

#### 14. **Nested Lists:**

- Lists can contain other lists, creating nested structures.
- Example:

```python
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
```

*********