CS1010E Lecture 05 - List, Tuple, Set, Dict
In this lecture, we dive into Python’s core data structures for managing collections of data: lists, tuples, sets, and dictionaries. This is a turning point in the course—moving from primitive data types to powerful, flexible structures that allow you to handle large volumes of data efficiently.
We start with sequences (ordered collections like strings, lists, and tuples), then explore lists in depth: how to create, access, slice, concatenate, and modify them. You’ll learn about important list operations like .append() and .remove(), the difference between appending and concatenation, and the critical concept of aliasing (when two variables refer to the same list in memory). We also cover list comprehensions—a concise way to generate lists.
Next, we introduce tuples (immutable sequences) and explain when to use them versus lists, followed by a brief look at sets (unordered collections with no duplicates) and dictionaries (key-value mappings). The lecture ends with a discussion of passing lists to functions and how mutability affects data inside and outside functions.
This session is packed with important concepts and common pitfalls—essential viewing for mastering Python data handling.
🕒 Key Topics Covered
Sequences vs. unordered collections
Lists: creation, indexing, slicing, concatenation, multiplication
List methods: .append(), .remove()
Appending vs. extending/concatenating
Aliasing and shared references (the “box” model)
Nested lists and their behavior
Iterables and looping over lists/strings
List comprehensions
Tuples: syntax, immutability, single-element tuples
Sets: union, intersection, difference, add/remove/discard
Dictionaries: keys (immutable) and values (any type), adding/updating/removing entries
Passing lists to functions (mutable behavior vs. primitive types)
00:00:02 - Introduction & Recap
00:01:54 - Assignment Updates
00:03:22 - Why Collections Matter (Polymers Analogy)
00:04:40 - Sequences vs. Unordered Collections
00:08:11 - Why We Need Lists (700 Students Example)
00:11:33 - Strings as Sequences of Characters
00:15:17 - Defining and Using Lists
00:17:21 - Heterogeneous Lists in Python
00:18:43 - List Operations: Indexing, Slicing, Concatenation
00:20:11 - Append vs. Concatenation
00:21:41 - Removing Items from a List (.remove())
00:22:36 - Removing the Leftmost Occurrence
00:25:12 - Appending a List to a List
00:28:21 - Nested Lists and Box Diagrams
00:29:50 - List Assignment and Aliasing (The "Box" Model)
00:36:56 - Aliasing Example with Modifications
00:40:42 - Nested Lists Referencing Themselves
00:42:42 - Iterables: Looping Over Lists and Strings
00:47:37 - Finding Max in a List (Algorithm)
00:51:18 - Filtering a List (Even Numbers Example)
00:52:48 - Converting Between Strings and Lists
00:54:33 - List Comprehensions (Math Notation Style)
00:57:55 - Generating Squares, Odds, Evens
01:00:58 - Prime Number Generator with Nested Comprehension
01:05:04 - Tuples: Definition and Immutability
01:07:26 - Single-Item Tuples (The Comma Trap)
01:08:53 - Why Tuples? (Homogeneous vs. Heterogeneous)
01:14:27 - Technical Reason: Immutability as Write Protection
01:18:11 - Passing Lists to Functions (Mutable Behavior)
01:21:34 - Sets: Unordered, No Duplicates
01:23:46 - Set Operations: Union, Intersection, Difference
01:24:29 - Remove vs. Discard in Sets
01:25:49 - Dictionaries: Key-Value Pairs
01:27:51 - Dictionary Example (Restaurant Locations)
01:29:13 - Vending Machine Analogy (List vs. Dictionary)
01:30:35 - Adding, Updating, Removing Dictionary Entries
01:32:45 - Q&A and Closing Remarks
📢 Recommended Tags
Python lists, Python tuples, Python sets, Python dictionaries, CS1010E, NUS computing, Python data structures, list comprehension, aliasing Python, immutable vs mutable, Python for beginners, programming lecture