Lists 11 Computer Science Chapter 9 CBSE Notes 2025-26

Python lists are a powerful and important data structure, used to store collections of items in an ordered and mutable way. Unlike strings (which only allow characters), a list can hold a mix of data types in one place—such as integers, floats, strings, and even other lists. This makes lists ideal for grouping related items together in programs, like keeping marks of all students in a class or storing the colors in a rainbow. Every list is written inside square brackets and elements are separated by commas. Like strings, lists are indexed: the first item is at index 0, the next at 1, and so on, making it easy to access elements directly.

Creating and Accessing Lists To create a list in Python, you simply place the elements inside square brackets, for example: numbers = [2, 4, 6, 8] or words = ['hello', 'world']. You can also mix types, like mixed = [100, 45.8, 'Hi']. Accessing elements is straightforward: numbers[0] gives 2 (the first element), and negative indices count from the end, so numbers[-1] returns 8. Indexing errors (accessing out-of-range elements) will cause an error, so it's common to use len(list) to check the number of items a list contains before accessing.

Mutability of Lists Lists are mutable, meaning their elements can be changed after the list is created. For example, you can assign a new value to a position in the list: colors = ['Red', 'Green', 'Blue', 'Orange'], then colors[3] = 'Black' will update the fourth element. This feature is what distinguishes lists from strings, which are immutable.

List Operations Just like strings, lists support several useful operations:

• Concatenation (+): Joins two or more lists into one. For example, [1, 2] + [3, 4] results in [1, 2, 3, 4]. Only lists can be joined this way; joining with a different data type gives an error.
• Repetition (*): Repeats the list multiple times. For example, [1, 2] * 3 gives [1, 2, 1, 2, 1, 2].
• Membership (in, not in): Checks if an item exists in the list, e.g. 'a' in ['a','b'] is True.
• Slicing: Retrieves sub-parts of the list. nums[2:5] gives a slice from index 2 up to (but not including) 5.

Traversing Lists To access every element in a list, programmers often use loops. With a for loop: for item in mylist: print(item) prints each item on a separate line. You can also use an index-based for i in range(len(mylist)) loop, or a while loop that keeps track of indices. This makes it easy to process lists of any size.

Common List Methods and Built-in Functions Python provides many methods specifically designed to make working with lists easier. Some essential ones include:

• len(list): Returns the number of elements. For example, len([1,2,3]) gives 3.
• append(x): Adds element x at end of list.
• extend(list2): Adds all elements from another list to the end.
• insert(pos, x): Inserts x at the given position.
• count(x): Counts occurrences of x in list.
• index(x): Finds the first index of x; error if not present.
• remove(x): Removes the first occurrence of x.
• pop([index]): Removes and returns the element at the given position (or end if index omitted).
• reverse(): Reverses the list in place.
• sort(): Sorts the list in place (for strings and numbers).
• sorted(list1): Returns a new sorted list, leaving the original unchanged.
• min(), max(), sum(): Compute the minimum, maximum, or total sum of the numeric elements in the list.

For example, list1 = [10, 20, 5, 40]; list1.sort() will rearrange the items to [5, 10, 20, 40].

Nested Lists A nested list is simply a list inside another list. For example, nested = [[1,2,3], ['a','b']]. You can access inner lists or their elements by using multiple indices: nested[1][0] would return 'a'. Nested lists are useful for organizing data like matrices or tables.

Copying Lists Assigning a list to a new variable like list2 = list1 does not create a fresh copy. Instead, both variables refer to the same list—changes in one are reflected in the other. To actually copy a list, use slicing (list2 = list1[:]), the list() constructor, or copy.copy(list1) from the copy module. This is a common source of confusion for beginners.

Passing Lists to Functions Lists are passed by reference to functions in Python. If you mutate elements (e.g., change list[0]), the change is visible outside the function as well. But if you assign a new list to the variable inside the function, it affects only the local scope. This is helpful for programs where you want to update a list directly through function calls, like increasing all scores by 5 marks at once.

Sample Programs for List Manipulation There are many real-life applications where lists are handy. For example:

• Menu-driven programs to add, insert, update, sort, or delete items interactively from a list.
• Program to calculate the average marks of students using a list to store marks and a loop to sum them.
• Linear search programs that check if a number is present in a given list, showing its position or reporting absence.

These are typical questions for practice and help reinforce concepts.

Typical Exercises on Lists Students studying lists should be able to solve exercises such as:

• Understanding the effect of append() vs. extend() (append adds a single item as one entry, extend adds elements separately).
• Working out the result of slicing and deletion operations, like del list1[3:] or list1[::-2].
• Differentiating various usage of repetition: list1 *= 2, list1 * 2, or list1 = list1 * 2.
• Manipulating and retrieving information from complex lists, such as nested records.

Programming Challenges with Lists To master lists, students should practice common coding problems:

1. Counting occurrences of an element using .count() or a loop.
2. Creating new lists with only positives or negatives from a mixed list.
3. Finding the largest or second largest element with loops or list methods.
4. Calculating the median by sorting and finding the middle (average of two if even count).
5. Removing duplicates by creating a new list only with unique elements.
6. Inserting/deleting items at a chosen position using insert() or pop().
7. Reversing a list in place using reverse() or slicing list[::-1].

Solving these helps in cementing the use of lists for many programming scenarios.

Summary Lists are one of the most versatile features in Python. They make it easy to store, change, sort, and process collections of data in programs. Mastery of lists—and all their methods—prepares students for more advanced programming topics, and makes writing Python code much simpler and more flexible.

Class 11 Computer Science Chapter 9 Notes – Lists (Python) Key Concepts and Summary

These revision notes on CBSE Class 11 Computer Science Chapter 9 Lists cover every major topic—definitions, methods, examples, and important program types. By reading the points and examples, you will gain a full understanding of list operations and master manipulation skills for your exams.

Well-structured lists, tables, and code samples make revision easier and more effective. Practice with the exercises to check your command on Python list methods and ensure you're prepared for both theoretical and coding questions in Class 11 Computer Science.