Python Programming Data Structures and Collections Syllabus

Data Structures and Collections syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Data Structures and Collections in Python Programming, not a summary of it.

1. 1

   Lists

   5 topics

   • Creating and Indexing Lists
   • Slicing
   • List Methods and Mutation
   • List Comprehensions
   • Nested and Multidimensional Lists
2. 2

   Tuples and Sequences

   4 topics

   • Creating Tuples
   • Tuple Packing and Unpacking
   • Immutability and Use Cases
   • Named Tuples
3. 3

   Dictionaries

   5 topics

   • Key-Value Pairs and Creation
   • Accessing and Modifying Items
   • Dictionary Methods
   • Dictionary Comprehensions
   • Iterating Over Dictionaries
4. 4

   Sets and Frozensets

   3 topics

   • Creating Sets
   • Set Operations
   • Frozensets
5. 5

   Strings as Sequences

   4 topics

   • String Indexing and Slicing
   • String Methods
   • Character Encoding and Unicode
   • Searching and Replacing

Data Structures and Collections flashcards for Python Programming

24 of 50 cards from the Data Structures and Collections deck — real questions with worked answers.

1. How do you create a list in Python, and what characterizes a list?

   A list is created with square brackets, e.g. `nums = [1, 2, 3]` (or via `list()`). It is an ordered, mutable, heterogeneous collection that allows duplicate elements.

2. What is the index of the first and last element of a list `L = ['a','b','c','d']` using positive and negative indexing?

   First element: `L[0]` = 'a'; last element: `L[3]` or `L[-1]` = 'd'. Positive indices start at 0 from the left; negative indices start at -1 from the right.

3. What happens when you access a list index that is out of range, e.g. `L[10]` on a 3-element list?

   Python raises an `IndexError: list index out of range`. Unlike slicing, direct indexing does not tolerate out-of-bounds positions.

4. What is the general syntax of a slice in Python?

   `sequence[start:stop:step]`. It returns elements from `start` (inclusive) up to `stop` (exclusive), moving by `step`. All three parts are optional.

5. For `L = [0,1,2,3,4,5]`, what does `L[1:4]` return, and why does it exclude index 4?

   It returns `[1, 2, 3]`. The `stop` index (4) is exclusive, so slicing yields elements from `start` up to but not including `stop`.

6. How do you reverse a list using slicing?

   Use a step of -1 with empty start/stop: `L[::-1]`. This returns a new reversed copy of the list.

7. What does `L[:]` produce and why is it useful?

   It produces a shallow copy of the entire list. It is useful for duplicating a list so mutations to the copy do not affect the original.

8. What is the difference between `list.append(x)` and `list.extend(iterable)`?

   `append(x)` adds `x` as a single element (a nested item if `x` is a list). `extend(iterable)` adds each element of the iterable individually, lengthening the list by the iterable's size.

9. What does `list.insert(i, x)` do?

   It inserts `x` at index `i`, shifting existing elements from index `i` onward one position to the right. Existing elements are not overwritten.

10. Compare `list.remove(x)`, `list.pop([i])`, and `del list[i]`.

    `remove(x)` deletes the first element equal to `x` (raises `ValueError` if absent). `pop(i)` removes and returns the element at index `i` (default last). `del list[i]` deletes by index and returns nothing.

11. Why is a list called 'mutable', and what does that imply about `id()` after mutation?

    Mutable means its contents can change in place. After methods like `append` or item assignment, the list's `id()` (object identity) stays the same because the same object is modified rather than replaced.

12. What is the syntax and result of a basic list comprehension that squares numbers 0 through 4?

    `[x**2 for x in range(5)]` produces `[0, 1, 4, 9, 16]`. General form: `[expression for item in iterable]`.

13. How do you add a condition (filter) to a list comprehension?

    Place an `if` clause after the loop: `[x for x in range(10) if x % 2 == 0]` yields even numbers `[0,2,4,6,8]`. The `if` filters which items are included.

14. Where does the conditional expression go when you want an if/else inside a list comprehension?

    Before the `for`, as a ternary expression: `[x if x > 0 else 0 for x in nums]`. A filtering `if` goes after the `for`; a value-choosing if/else goes before it.

15. How do you create a nested list (2D matrix) representing 2 rows of 3 zeros?

    `[[0, 0, 0], [0, 0, 0]]`, or with a comprehension `[[0]*3 for _ in range(2)]`. Avoid `[[0]*3]*2`, which makes all rows reference the same inner list.

16. For a matrix `M = [[1,2,3],[4,5,6]]`, how do you access the element in row 1, column 2?

    `M[1][2]` = 6. The first index selects the row (inner list), the second selects the column (element within that list).

17. Why does `grid = [[0]*3]*2` cause a bug when you set `grid[0][0] = 1`?

    All outer elements reference the same inner list, so `grid[0][0] = 1` changes every row, giving `[[1,0,0],[1,0,0]]`. Use `[[0]*3 for _ in range(2)]` to get independent rows.

18. How do you create a tuple, including the special case of a single-element tuple?

    Use parentheses/commas: `t = (1, 2, 3)`. A one-element tuple requires a trailing comma: `t = (5,)`. Without the comma, `(5)` is just the integer 5.

19. Can you create a tuple without parentheses?

    Yes. Commas define a tuple: `t = 1, 2, 3` creates `(1, 2, 3)`. This is called tuple packing.

20. What is tuple packing versus tuple unpacking?

    Packing groups values into a tuple: `t = 1, 2, 3`. Unpacking assigns a tuple's elements to variables: `a, b, c = t`, giving `a=1, b=2, c=3`.

21. How does extended (starred) unpacking work, e.g. `a, *b, c = [1,2,3,4,5]`?

    `a=1`, `c=5`, and `b=[2,3,4]`. The starred variable absorbs all remaining middle elements as a list; only one starred target is allowed.

22. Why are tuples immutable, and what is one advantage of that immutability?

    A tuple's elements cannot be reassigned after creation. Immutability allows tuples to be hashable, so they can serve as dictionary keys or set elements (if their contents are also hashable).

23. Give a common use case where a tuple is preferred over a list.

    Representing fixed, heterogeneous records (e.g. coordinates `(x, y)`), returning multiple values from a function, or as dictionary keys — cases where the data should not change and/or must be hashable.

24. If a tuple contains a mutable object like `t = (1, [2, 3])`, can that object be changed?

    Yes — `t[1].append(4)` works, giving `(1, [2, 3, 4])`. The tuple's references are fixed, but a referenced mutable object can still be modified in place. Such a tuple is not hashable.

See more Data Structures and Collections flashcards →

Planning Data Structures and Collections for Python Programming

Data Structures and Collections (Python Programming) FAQ