Computer Science · Class 11

Active learning ideas

List Methods and Built-in Functions

Active learning helps students grasp list methods and functions because Python’s list operations behave differently from mathematical lists. When students write code, test outputs, and debug together, they notice how methods like append change the list while len does not, building durable understanding of mutability.

• CBSE Learning Outcomes
• CBSE: Python Lists and Tuples - Class 11

• 25–45 min
• Pairs → Whole Class
• 4 activities

Activity 01

• Collaborative Problem-Solving
• 30 min · Pairs

Pair Coding: Method Match-Up

Pairs receive a list of student scores and tasks like appending new scores, inserting at positions, removing fails, and sorting. They write code, run it in IDLE, and predict outcomes before execution. Switch roles after each method to discuss changes.

Differentiate between methods that modify a list in-place and those that return a new list.

Facilitation Tip

During Pair Coding: Method Match-Up, sit with each pair and ask them to read the documentation aloud before coding so they practice reading technical text.

What to look for

Provide students with a pre-defined list of numbers, e.g., `my_list = [15, 8, 22, 5]`. Ask them to write down the Python code to: 1. Add the number 30 to the end. 2. Insert the number 10 at the beginning. 3. Find the sum of all elements. 4. State whether the `append` and `insert` operations changed the original list.

• Apply
• Analyze
• Evaluate
• Create
• Relationship Skills
• Decision-Making
• Self-Management

Activity 02

• Collaborative Problem-Solving
• 45 min · Small Groups

Small Groups: Efficiency Race

Groups get identical lists and time operations: repeated inserts at start versus append then reverse. They record times for 100 operations and compare results. Present findings to class on why append is faster.

Construct Python code to manipulate list data using various methods and functions.

Facilitation Tip

In Small Groups: Efficiency Race, provide printed timers and colored pencils so groups can visually mark the original list to see in-place changes.

What to look for

Display a short Python code snippet that uses a list method (e.g., `my_list.sort()`). Ask students to predict the output of `print(my_list)` and `print(my_list.sort())`. Discuss why one shows the sorted list and the other shows `None`.

• Apply
• Analyze
• Evaluate
• Create
• Relationship Skills
• Decision-Making
• Self-Management

Activity 03

• Collaborative Problem-Solving
• 25 min · Whole Class

Whole Class: Function Gallery Walk

Project code snippets using len, min, max, sum on different lists. Class votes on outputs, then runs code to verify. Discuss errors like summing strings and corrections.

Evaluate the efficiency of different list operations for specific tasks.

Facilitation Tip

For the Whole Class: Function Gallery Walk, ask students to annotate their code snippets with arrows showing which parts of the list are modified.

What to look for

Pose this scenario: 'Imagine you have a list of 10,000 customer IDs and you need to add 100 new IDs to the end. Would it be more efficient to use `append()` 100 times or `insert(0, id)` 100 times? Explain your reasoning, considering how lists are structured in memory.'

• Apply
• Analyze
• Evaluate
• Create
• Relationship Skills
• Decision-Making
• Self-Management

Activity 04

• Collaborative Problem-Solving
• 40 min · Individual

Individual: List Manipulator Challenge

Students create a programme to input shopping list, add items, compute total cost with sum, find max spend, and sort. Test with personal data and debug alone before sharing.

Differentiate between methods that modify a list in-place and those that return a new list.

Facilitation Tip

For the Individual: List Manipulator Challenge, circulate with a checklist of common mistakes so you can redirect students immediately.

What to look for

Provide students with a pre-defined list of numbers, e.g., `my_list = [15, 8, 22, 5]`. Ask them to write down the Python code to: 1. Add the number 30 to the end. 2. Insert the number 10 at the beginning. 3. Find the sum of all elements. 4. State whether the `append` and `insert` operations changed the original list.

• Apply
• Analyze
• Evaluate
• Create
• Relationship Skills
• Decision-Making
• Self-Management

A few notes on teaching this unit

Teachers should avoid rushing through the difference between mutable and immutable operations, because students otherwise memorize steps without understanding side effects. A good approach is to have students write small test cases before each new method, testing both the return value and the state of the list. Research shows that when students predict outputs and then run code to verify, misconceptions about None and in-place changes reduce significantly.

By the end of these activities, students will confidently choose between methods that modify lists and functions that return values, explain why sort returns None, and justify the use of append versus insert in different contexts.

---

Watch Out for These Misconceptions

• During Pair Coding: Method Match-Up, watch for students who assume every method returns a new list.

  Have each pair add two print statements: one to check the return value and another to print the list itself. When they see None and the modified list, redirect them to the Python docs to read the return description of each method.

• During Small Groups: Efficiency Race, watch for students who think sort() returns a sorted list.

  Ask each group to time both sort() and sorted(), then compare the original list with the output. Emphasize that sorted() returns a new list, while sort() changes the original and returns None.

• During Individual: List Manipulator Challenge, watch for students who confuse remove() with deleting by index.

  Ask students to run a small example like my_list.remove(5) on [3, 5, 7] and observe that 5 is removed, not the element at index 5. Use error messages to guide them to try pop() when they need index-based removal.

---

Methods used in this brief

• Collaborative Problem-Solving