ProSyllabus Journal

Lists – NCERT Class 11 Computer Science Chapter 9 – List Operations, Traversal, and Methods in Python

Covers lists as mutable ordered sequences that can contain elements of different data types. Explains list creation, accessing elements through indexing, mutability, and various list operations like concatenation, repetition, membership, and slicing. Details traversal techniques using loops, and extensive built-in list methods such as append, extend, insert, remove, pop, sort, reverse, and copying lists. Includes nested lists and passing lists as function arguments for practical programming applications.

Updated 11 months agoNCERT · Class XI · Computer Science · Python · Lists · List Operations · List Methods · Chapter 9

#Lists#List Operations#Mutable Sequences#Indexing#Slicing#Traversal#Append#Extend#Insert#Remove#Pop#Sort#Reverse#Nested Lists#Copying Lists#Python Lists#NCERT Class 11#Computer Science#Chapter 9

Lists – NCERT Class 11 Computer Science Chapter 9 – List Operations, Traversal, and Methods in Python

Lists: NCERT Class 11 Chapter 9 - Enhanced Study Guide, Precise Notes, Diagrams & Quiz 2025

Enhanced Full Chapter Summary & Precise Notes from NCERT PDF (18 Pages)

Overview & Key Concepts

Exact Definition: "The data type list is an ordered sequence which is mutable and made up of one or more elements."

Introduction: Mutable sequences (unlike immutable strings); Mixed data types; Indexing from 0; Square brackets [].
Chapter Structure: Creation/accessing/mutability, Operations (concat/rep/mem/slice), Traversing, Methods/functions, Nested lists, Copying, Arguments to functions, Manipulation (programs).
2025 Relevance: Lists in data structures (e.g., arrays in ML); Dynamic arrays in pandas; Mutable for real-time updates.

9.1 Introduction to List

Precise: Ordered, mutable sequence; Elements: int/float/str/tuple/list; Enclosed in []; Comma-separated.

9.1.1 Accessing Elements

Precise: [index] (0 to n-1, -1 to -n); len() for length. Expanded: IndexError out-of-range; Expressions as index if int.

Precise Example 9.1: List Creation (SVG)

9.1.2 Lists are Mutable

Precise: Contents changeable post-creation; list[3] = 'Black'.

Precise Table 9.1: Indexing [2,4,6,8,10,12] (SVG)

9.2 List Operations

Precise: + (concat), * (rep), in/not in (mem), [n:m:k] (slice). Expanded: No change to originals in concat; TypeError mixing types.

9.3 Traversing a List

Precise: for item in list; for i in range(len(list)); while i < len(list).

9.4 Methods/Functions

Precise: len(), list(), append(), extend(), insert(), count(), index(), remove(), pop(), reverse(), sort(), sorted(), min(), max(), sum().

9.5 Nested Lists

Precise: List in list; Access: list1[i][j].

9.6 Copying Lists

Precise: Shallow: [:], list(), copy.copy(); Assignment aliases.

9.7 List as Argument to Function

Precise: Pass by reference; Changes reflect unless reassigned inside.

9.8 List Manipulation

Precise: Menu-driven (9-3); Average (9-4); Linear search (9-5).

Enhanced Features (2025)

Full PDF integration, expanded programs (9-1 to 9-5), SVGs (indexing/slicing), detailed tables/examples, NCERT Exercises Q&A updated, 10-Q quiz. Focus: List manipulation in Python.

Exam Tips

Predict outputs (slicing/mutability); Write UDFs (increment/search); List methods (Table 9.1); Explain copying/arguments; Practice traversal/loops.

Method	Description	Example
len()	Returns length	len([10,20,30]) → 3
list()	Creates list from sequence	list('aeiou') → ['a','e','i','o','u']
append(x)	Adds x at end	[10,20].append(30) → [10,20,30]
extend(lst)	Adds elements of lst	[10,20].extend([30,40]) → [10,20,30,40]
insert(i,x)	Inserts x at i	[10,20].insert(1,15) → [10,15,20]
count(x)	Occurrences of x	[10,20,10].count(10) → 2
index(x)	First index of x	[10,20,30].index(20) → 1
remove(x)	Removes first x	[10,20,10].remove(10) → [20,10]
pop(i)	Removes/returns at i	[10,20,30].pop(1) → 20; List: [10,30]
reverse()	Reverses in-place	[1,2,3].reverse() → [3,2,1]
sort()	Sorts in-place	[3,1,2].sort() → [1,2,3]
sorted()	New sorted list	sorted([3,1,2]) → [1,2,3]
min()	Smallest element	min([3,1,2]) → 1
max()	Largest element	max([3,1,2]) → 3
sum()	Sum of elements	sum([1,2,3]) → 6

Handling Lists - Programs 9-1 to 9-5 Expanded

Core: UDFs for increment, average, search; Menu-driven manipulation.

Program 9-1: increment(list2)

# Program 9-1
def increment(list2):
    for i in range(0, len(list2)):
        list2[i] += 5
    print('Reference of list Inside Function', id(list2))

list1 = [10,20,30,40,50]
print("Reference of list in Main", id(list1))
print("The list before the function call")
print(list1)
increment(list1)
print("The list after the function call")
print(list1)

Output: Reference of list in Main [some id]
The list before the function call
[10, 20, 30, 40, 50]
Reference of list Inside Function [same id]
The list after the function call
[15, 25, 35, 45, 55]

Program 9-2: increment with Reassignment (No Change)

# Program 9-2
def increment(list2):
    print("\nID of list inside function before assignment:", id(list2))
    list2 = [15,25,35,45,55]
    print("ID of list changes inside function after assignment:", id(list2))
    print("The list inside the function after assignment is:")
    print(list2)

list1 = [10,20,30,40,50]
print("ID of list before function call:", id(list1))
print("The list before function call:")
print(list1)
increment(list1)
print('\nID of list after function call:', id(list1))
print("The list after the function call:")
print(list1)

Output: ID of list before function call: [id1]
The list before function call:
[10, 20, 30, 40, 50]
ID of list inside function before assignment: [id1]
ID of list changes inside function after assignment: [id2]
The list inside the function after assignment is:
[15, 25, 35, 45, 55]
ID of list after function call: [id1]
The list after the function call:
[10, 20, 30, 40, 50]

Program 9-3: Menu-Driven List Operations

# Program 9-3 (Snippet - Full in PDF)
myList = [22,4,16,38,13]
choice = 0
while True:
    print("The list 'myList' has the following elements", myList)
    print("\nL I S T   O P E R A T I O N S")
    print(" 1. Append an element")
    # ... (full menu code)
    choice = int(input("ENTER YOUR CHOICE (1-10): "))
    if choice == 1:
        element = int(input("Enter the element to be appended: "))
        myList.append(element)
        print("The element has been appended\n")
    # ... (other cases)
    elif choice == 10:
        break
    else:
        print("Choice is not valid")

Sample Output: The list 'myList' has the following elements [22, 4, 16, 38, 13]
L I S T O P E R A T I O N S
1. Append an element
...
ENTER YOUR CHOICE (1-10): 8
The list has been sorted in reverse order
The list 'myList' has the following elements [38, 22, 16, 13, 4]

Program 9-4: computeAverage(list1,n)

# Program 9-4
def computeAverage(list1,n):
    total = 0
    for marks in list1:
        total = total + marks
    average = total / n
    return average

list1 = []
print("How many students marks you want to enter: ")
n = int(input())
for i in range(0,n):
    print("Enter marks of student",(i+1),":")
    marks = int(input())
    list1.append(marks)
average = computeAverage(list1,n)
print("Average marks of",n,"students is:",average)

Output: How many students marks you want to enter:
5
Enter marks of student 1:
45
... (inputs)
Average marks of 5 students is: 68.8

Program 9-5: linearSearch(num,list1)

# Program 9-5
def linearSearch(num,list1):
    for i in range(0,len(list1)):
        if list1[i] == num:
            return i
    return None

list1 = []
print("How many numbers do you want to enter in the list: ")
maximum = int(input())
print("Enter a list of numbers: ")
for i in range(0,maximum):
    n = int(input())
    list1.append(n)
num = int(input("Enter the number to be searched: "))
result = linearSearch(num,list1)
if result is None:
    print("Number",num,"is not present in the list")
else:
    print("Number",num,"is present at",result + 1, "position")

Output: How many numbers do you want to enter in the list:
5
Enter a list of numbers:
23
567
12
89
324
Enter the number to be searched:12
Number 12 is present at 3 position

Tip: 2025: Lists in algorithms (e.g., sorting for search engines).

NCERT Exercises - Questions & Answers

Based on full NCERT Chapter 9. Structured like textbook with full questions and detailed answers.

Question 1: What will be the output of the following statements?

i. list1 = [12,32,65,26,80,10]
list1.sort()
print(list1)

Ans: [10, 12, 26, 32, 65, 80]

ii. list1 = [12,32,65,26,80,10]
sorted(list1)
print(list1)

Ans: [12, 32, 65, 26, 80, 10] (Original unchanged)

iii. list1 = [1,2,3,4,5,6,7,8,9,10]
list1[::-2]
list1[:3] + list1[3:]

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

iv. list1 = [1,2,3,4,5]
list1[len(list1)-1]

Ans: 5

Question 2: Consider the following list myList. What will be the elements of myList after the following two operations:
myList = [10,20,30,40]

i. myList.append([50,60])

Ans: [10, 20, 30, 40, [50, 60]]

ii. myList.extend([80,90])

Ans: [10, 20, 30, 40, [50, 60], 80, 90]

Question 3: What will be the output of the following code segment:
myList = [1,2,3,4,5,6,7,8,9,10]
for i in range(0,len(myList)):
if i%2 == 0:
print(myList[i])

Ans:

1
3
5
7
9

Question 4: What will be the output of the following code segments?

a. myList = [1,2,3,4,5,6,7,8,9,10]
del myList[3:]
print(myList)

Ans: [1, 2, 3]

b. myList = [1,2,3,4,5,6,7,8,9,10]
del myList[:5]
print(myList)

Ans: [6, 7, 8, 9, 10]

c. myList = [1,2,3,4,5,6,7,8,9,10]
del myList[::2]
print(myList)

Ans: [2, 4, 6, 8, 10]

Question 5: Differentiate between append() and extend() functions of list.

Ans:

append(): Adds single element (or list as one) at end.
extend(): Adds each element of iterable separately at end.
Example: [1,2].append([3,4]) → [1,2,[3,4]]
[1,2].extend([3,4]) → [1,2,3,4]

Question 6: Consider a list: list1 = [6,7,8,9]
What is the difference between the following operations on list1:

a. list1 * 2

Ans: [6,7,8,9,6,7,8,9] (New list)

b. list1 *= 2

Ans: list1 becomes [6,7,8,9,6,7,8,9] (In-place)

c. list1 = list1 * 2

Ans: list1 becomes [6,7,8,9,6,7,8,9] (Reassign)

Question 7: The record of a student ... stRecord = ['Raman','A-36',[56,98,99,72,69], 78.8]
Write Python statements to retrieve:

a) Percentage of the student

Ans: print(stRecord[3]) # 78.8

b) Marks in the fifth subject

Ans: print(stRecord[2][4]) # 69

c) Maximum marks of the student

Ans: print(max(stRecord[2])) # 99

d) Roll no. of the student

Ans: print(stRecord[1]) # 'A-36'

e) Change the name ... to ‘Raghav’

Ans: stRecord[0] = 'Raghav'

Programming Problems (Sample Solutions)

1. Write a program to find the number of times an element occurs in the list.

Ans:

def countElement(lst, elem):
    return lst.count(elem)
myList = [1,2,3,1,4,1]
print(countElement(myList, 1))  # 3

2. Write a program to read a list of n integers ... positive/negative lists.

Ans:

n = int(input("Enter n: "))
lst = [int(input()) for _ in range(n)]
pos = [x for x in lst if x > 0]
neg = [x for x in lst if x < 0]
print("Original:", lst)
print("Positive:", pos)
print("Negative:", neg)

3. Write a function that returns the largest element of the list passed as parameter.

Ans:

def largest(lst):
    return max(lst)
print(largest([1,5,3]))  # 5

4. Write a function to return the second largest number from a list of numbers.

Ans:

def secondLargest(lst):
    return sorted(lst)[-2]
print(secondLargest([1,5,3,7]))  # 5

5. Write a program to read a list of n integers and find their median.

Ans:

n = int(input())
lst = sorted([int(input()) for _ in range(n)])
if n % 2 == 0:
    med = (lst[n//2 - 1] + lst[n//2]) / 2
else:
    med = lst[n//2]
print("Median:", med)

6. Write a program to read a list of elements. Modify this list so that it does not contain any duplicate elements.

Ans:

lst = [int(input()) for _ in range(int(input("Size: ")))]
unique = []
for x in lst:
    if x not in unique:
        unique.append(x)
print(unique)

7. Write a program to read a list of elements. Input an element ... insert at position.

Ans:

lst = [int(input()) for _ in range(int(input("Size: ")))]
elem = int(input("Element: "))
pos = int(input("Position: "))
lst.insert(pos, elem)
print(lst)

8. Write a program to read elements of a list.
a) Delete by position.
b) Delete by value.

Ans:

lst = [int(input()) for _ in range(int(input("Size: ")))]
pos = int(input("Position to delete: "))
if 0 <= pos < len(lst):
    del lst[pos]
print("After pos delete:", lst)
val = int(input("Value to delete: "))
if val in lst:
    lst.remove(val)
print("After val delete:", lst)

9. Read a list of n elements. Pass this list to a function which reverses this list in-place without creating a new list.

Ans:

def reverseInPlace(lst):
    lst.reverse()
n = int(input())
lst = [int(input()) for _ in range(n)]
reverseInPlace(lst)
print(lst)

Tip: Practice these for board exams; Focus on outputs and UDF logic.

Concept	Precise Description	Example	Process/2025 Note
Creation	Square brackets, mixed types	[1,'a',[2]]	Nested allowed
Accessing	[0 to n-1]; [-n to -1]	list[0] → 2	len() for bound
Mutability	Change post-create	list[1]=3	Unlike strings
Operations	+ * in [n:m:k]	[1]*2 → [1,1]	Slice step
Traversal	for/while loops	for item in list	Access each elem
Methods	Built-in manip	list.append(x)	Table 9.1
Nested	List in list	list[4][1] → 7	Double index
Copying	Shallow copies	list[:] → Clone	Avoid alias
Arguments	Pass by ref	Changes reflect	Unless reassign
Manipulation	UDF programs	Menu-driven	Sort/search

This article has been published in CBSE Class 11 Annual Assessment. Explore everything related to it here.

Recommended BooksSee All →

35% OFF

Bhagvad Gita – The Story Way for Students & Parents

₹194M.R.P. ₹299

Buy on Amazon

34% OFF

You Can – The Classic Guide to Self-Belief & Personal Growth

₹99M.R.P. ₹149

Buy on Amazon

Atomic Habits – Tiny Changes, Remarkable Results

₹521

Buy on Amazon

As an Amazon Associate, ProSyllabus earns from qualifying purchases. Prices shown are subject to change.

This chapter is part of the CBSE Class 11 Annual Assessment Board ExaminationExplore every chapter — summary, notes, extra questions & MCQ quizzes

Practice Quiz

Test your CBSE Class 11 Annual Assessment prep

Dual AI-verified questions Real exam pattern 1 free quiz every month, then ₹9 per quiz — or a monthly plan

What is Psychology?

Start here

Psychology 10 Qs · ~10 min