Python Data Structures Handbook: Individual Method Examples

List Data Structure Mutable Ordered

Detailed individual operational cards for all 18 List methods & syntax constructs.

1. Creation (Literals & list())

Creation

Instantiates a new list using square brackets or iterable conversion.

Syntax: lst = [] or list(iterable)

a = [1, 2, 3]
b = list("py")
print(a)
print(b)

[1, 2, 3]
['p', 'y']

2. List Comprehension

Creation

Concise syntax to construct lists based on existing iterables and filters.

Syntax: [expr for item in iterable if cond]

evens = [x for x in range(6) if x % 2 == 0]
print(evens)

[0, 2, 4]

3. Index Access

Accessing

Retrieves a single element at a zero-based positive or negative index.

Syntax: lst[index]

lst = ['a', 'b', 'c']
print(lst[0], lst[-1])

a c

4. Slicing

Accessing

Extracts a subset range of elements using start, stop, and step bounds.

Syntax: lst[start:stop:step]

nums = [10, 20, 30, 40, 50]
print(nums[1:4])
print(nums[::-1])

[20, 30, 40]
[50, 40, 30, 20, 10]

5. append()

Insertion

Appends a single element to the right end of the list in O(1) time.

Syntax: lst.append(element)

lst = [1, 2]
lst.append(3)
print(lst)

[1, 2, 3]

6. insert()

Insertion

Inserts an element at a specified index, shifting existing items to the right.

Syntax: lst.insert(index, element)

lst = [10, 30]
lst.insert(1, 20)
print(lst)

[10, 20, 30]

7. extend()

Insertion

Appends all elements from an iterable to the end of the list in-place.

Syntax: lst.extend(iterable)

lst = [1, 2]
lst.extend([3, 4])
print(lst)

[1, 2, 3, 4]

8. Concatenation (+)

Insertion

Combines two lists into a new third list using the + operator.

Syntax: new_lst = lst1 + lst2

a = [1, 2]
b = [3, 4]
res = a + b
print(res)

[1, 2, 3, 4]

9. Slice Assignment

Insertion

Replaces or inserts elements within a slice range in-place.

Syntax: lst[i:j] = iterable

lst = [1, 5]
lst[1:1] = [2, 3, 4]
print(lst)

[1, 2, 3, 4, 5]

10. remove()

Deletion

Removes the first matching element by value. Raises ValueError if absent.

Syntax: lst.remove(value)

lst = ['a', 'b', 'c']
lst.remove('b')
print(lst)

['a', 'c']

11. pop()

Deletion

Removes and returns an item at a specified index (defaults to the last item).

Syntax: item = lst.pop([index])

lst = [10, 20, 30]
val = lst.pop(1)
print("Popped:", val, "List:", lst)

Popped: 20 List: [10, 30]

12. del Statement

Deletion

Deletes items at a given index or slice, or deletes the whole variable.

Syntax: del lst[index] or del lst[i:j]

nums = [1, 2, 3, 4]
del nums[1:3]
print(nums)

[1, 4]

13. clear()

Deletion

Removes all items from the list, leaving an empty list.

Syntax: lst.clear()

lst = [10, 20]
lst.clear()
print(lst)

[]

14. sort()

Manipulation

Sorts list elements in ascending or descending order in-place.

Syntax: lst.sort(key=None, reverse=False)

nums = [3, 1, 4, 2]
nums.sort(reverse=True)
print(nums)

[4, 3, 2, 1]

15. reverse()

Manipulation

Reverses the order of list elements in-place.

Syntax: lst.reverse()

lst = [1, 2, 3]
lst.reverse()
print(lst)

[3, 2, 1]

16. count()

Utility

Returns total number of occurrences of a specified value.

Syntax: count_val = lst.count(value)

lst = [1, 2, 2, 3, 2]
print(lst.count(2))

17. index()

Utility

Returns index of first match of value. Raises ValueError if missing.

Syntax: idx = lst.index(value, [start, stop])

lst = ['a', 'b', 'c']
print(lst.index('b'))

18. copy()

Utility

Returns a shallow copy of the existing list.

Syntax: shallow_copy = lst.copy()

orig = [1, 2]
cp = orig.copy()
cp.append(3)
print("Orig:", orig, "Copy:", cp)

Orig: [1, 2] Copy: [1, 2, 3]

Tuple Data Structure Immutable Ordered

Detailed individual operational cards for all 10 Tuple operations & methods.

1. Creation (Literals & tuple())

Creation

Constructs an immutable tuple using parentheses or constructor.

Syntax: t = () or tuple(iterable)

t1 = (1, 2, 3)
t2 = tuple([4, 5])
print(t1, t2)

(1, 2, 3) (4, 5)

2. Single-element Tuple

Creation

Requires a trailing comma to distinguish a 1-tuple from a parenthesized expression.

Syntax: t = (val,)

single = (42,)
not_single = (42)
print(type(single), type(not_single))

3. Indexing & Slicing

Accessing

Reads individual elements or sub-slices from the tuple.

Syntax: t[index] or t[start:stop]

t = (10, 20, 30, 40)
print(t[0], t[1:3])

10 (20, 30)

4. Tuple Unpacking

Accessing

Assigns tuple elements directly into multiple individual variables.

Syntax: a, b, *rest = t

pt = (5, 10, 15, 20)
x, y, *rem = pt
print(x, y, rem)

5 10 [15, 20]

5. Concatenation (+)

Addition

Merges two tuples into a brand-new tuple object.

Syntax: t3 = t1 + t2

t1 = (1, 2)
t2 = (3, 4)
print(t1 + t2)

(1, 2, 3, 4)

6. Repetition (*)

Addition

Duplicates tuple elements N times into a new tuple.

Syntax: t_rep = t * n

t = ('a', 'b')
print(t * 3)

('a', 'b', 'a', 'b', 'a', 'b')

7. Workaround Modification

Manipulation

Converts to a list to modify elements before converting back to tuple.

Syntax: tuple(list(t).append(x))

t = (1, 2)
temp = list(t)
temp.append(3)
t = tuple(temp)
print(t)

(1, 2, 3)

8. del Statement

Deletion

Deletes the complete tuple reference (item deletion is forbidden).

Syntax: del tuple_var

t = (10, 20)
del t
try:
    print(t)
except NameError as e:
    print("Deleted successfully")

Deleted successfully

9. count()

Utility

Counts occurrences of a given element in the tuple.

Syntax: c = t.count(value)

t = (1, 1, 2, 3)
print(t.count(1))

10. index()

Utility

Returns index of first match of value in the tuple.

Syntax: idx = t.index(value)

t = ('x', 'y', 'z')
print(t.index('y'))

Set Data Structure Mutable Unordered

Detailed individual operational cards for all 13 Set methods & set operations.

1. Creation (Literals & set())

Creation

Creates a unique set using curly braces or constructor set().

Syntax: s = {1, 2} or set(iterable)

s = {1, 2, 2, 3}
empty = set()
print(s, type(empty))

{1, 2, 3} <class 'set'>

2. add()

Insertion

Adds a single unique item to the set in O(1) time.

Syntax: s.add(element)

s = {1, 2}
s.add(3)
print(s)

{1, 2, 3}

3. update()

Insertion

Adds elements from one or multiple iterables into the set.

Syntax: s.update(*iterables)

s = {1}
s.update([2, 3], {4})
print(s)

{1, 2, 3, 4}

4. discard()

Deletion

Removes element if present; does NOTHING if missing (safe removal).

Syntax: s.discard(element)

s = {1, 2}
s.discard(99)  # No error raised
print(s)

{1, 2}

5. remove()

Deletion

Removes element if present; raises KeyError if missing.

Syntax: s.remove(element)

s = {1, 2}
s.remove(2)
print(s)

{1}

6. pop()

Deletion

Removes and returns an arbitrary element from the set.

Syntax: elem = s.pop()

s = {100, 200}
removed = s.pop()
print("Removed arbitrary element:", removed)

Removed arbitrary element: 100

7. clear()

Deletion

Removes all elements, resetting to empty set().

Syntax: s.clear()

s = {1, 2, 3}
s.clear()
print(s)

set()

8. union (|)

Operation

Returns a new set with elements from both sets.

Syntax: s1 | s2 or s1.union(s2)

a = {1, 2}
b = {2, 3}
print(a | b)

{1, 2, 3}

9. intersection (&)

Operation

Returns elements common to both sets.

Syntax: s1 & s2 or s1.intersection(s2)

a = {1, 2}
b = {2, 3}
print(a & b)

{2}

10. difference (-)

Operation

Returns elements in first set but absent from second set.

Syntax: s1 - s2 or s1.difference(s2)

a = {1, 2, 3}
b = {2, 4}
print(a - b)

{1, 3}

11. symmetric_difference (^)

Operation

Returns elements in either set, but not in both.

Syntax: s1 ^ s2 or s1.symmetric_difference(s2)

a = {1, 2}
b = {2, 3}
print(a ^ b)

{1, 3}

12. issubset / issuperset

Predicates

Tests boolean containment relationships between sets.

Syntax: s1.issubset(s2), s1.issuperset(s2)

a = {1, 2}
b = {1, 2, 3}
print(a.issubset(b))
print(b.issuperset(a))

True
True

13. isdisjoint()

Predicates

Returns True if two sets have NO elements in common.

Syntax: s1.isdisjoint(s2)

a = {1, 2}
b = {3, 4}
print(a.isdisjoint(b))

True

Dictionary Data Structure Mutable Key-Ordered (3.7+)

Detailed individual operational cards for all 14 Dictionary methods & operators.

1. Creation (Literals & dict())

Creation

Constructs key-value pairs using curly braces or dict constructor.

Syntax: d = {"k": "v"} or dict(k=v)

d1 = {"a": 1}
d2 = dict(b=2)
print(d1, d2)

{'a': 1} {'b': 2}

2. fromkeys()

Creation

Creates a new dictionary with specified keys and default value.

Syntax: dict.fromkeys(keys_seq, value)

keys = ['x', 'y']
d = dict.fromkeys(keys, 0)
print(d)

{'x': 0, 'y': 0}

3. Bracket Access [key]

Accessing

Fetches value associated with key. Raises KeyError if missing.

Syntax: val = d[key]

d = {"name": "Alice"}
print(d["name"])

Alice

4. get()

Accessing

Safely retrieves value for key with custom default fallback.

Syntax: val = d.get(key, default)

d = {"age": 25}
print(d.get("age", 0))
print(d.get("score", 100))

25
100

5. Key Assignment

Insertion

Inserts a new key-value pair or updates an existing key's value.

Syntax: d[key] = value

d = {}
d["status"] = "active"
print(d)

{'status': 'active'}

6. update()

Insertion

Merges another dictionary or key-value iterable in-place.

Syntax: d.update(other_dict)

d = {"a": 1}
d.update({"b": 2, "c": 3})
print(d)

{'a': 1, 'b': 2, 'c': 3}

7. setdefault()

Insertion

Returns key value if present; otherwise inserts key with default value.

Syntax: val = d.setdefault(key, default)

d = {"a": 10}
val = d.setdefault("b", 20)
print(val, d)

20 {'a': 10, 'b': 20}

8. Merge Operator (|)

Insertion

Merges two dictionaries into a new third dictionary (Python 3.9+).

Syntax: d3 = d1 | d2

d1 = {"a": 1}
d2 = {"b": 2}
print(d1 | d2)

{'a': 1, 'b': 2}

9. pop()

Deletion

Removes specified key and returns its value.

Syntax: val = d.pop(key, [default])

d = {"x": 100, "y": 200}
val = d.pop("x")
print(val, d)

100 {'y': 200}

10. popitem()

Deletion

Removes and returns the last inserted key-value tuple pair (LIFO).

Syntax: (k, v) = d.popitem()

d = {"a": 1, "b": 2}
pair = d.popitem()
print(pair, d)

('b', 2) {'a': 1}

11. del Statement

Deletion

Deletes a specific key entry or the entire dictionary variable.

Syntax: del d[key]

d = {"k1": 10, "k2": 20}
del d["k1"]
print(d)

{'k2': 20}

12. clear()

Deletion

Removes all items from dictionary, leaving an empty {} dict.

Syntax: d.clear()

d = {"a": 1, "b": 2}
d.clear()
print(d)

{}

13. Dynamic Dict Views

Views

Returns dynamic view objects of dictionary keys, values, or key-value tuple pairs.

Syntax: d.keys(), d.values(), d.items()

d = {"a": 1, "b": 2}
print(list(d.keys()))
print(list(d.values()))
print(list(d.items()))

['a', 'b']
[1, 2]
[('a', 1), ('b', 2)]

14. copy()

Utility

Returns a shallow copy of the dictionary object.

Syntax: new_d = d.copy()

orig = {"a": 1}
cp = orig.copy()
cp["b"] = 2
print("Orig:", orig, "Copy:", cp)

Orig: {'a': 1} Copy: {'a': 1, 'b': 2}

Comprehensive Comparison Matrix

Side-by-side technical specification of Python built-in data structures.

Property / Method	List (`list`)	Tuple (`tuple`)	Set (`set`)	Dictionary (`dict`)
Mutability	Mutable	Immutable	Mutable	Mutable
Order Guarantees	Sequential Index	Sequential Index	Unordered	Insertion Order (3.7+)
Duplicate Support	Allowed	Allowed	Disallowed (Unique)	Unique Keys
Access Lookup Time	O(1) by Index	O(1) by Index	O(1) Hash Membership	O(1) Key Lookup
Primary Creation	`[1, 2]`	`(1, 2)`	`{1, 2}`	`{"k": "v"}`
Insertion Methods	`append`, `insert`, `extend`	N/A (+ operator)	`add`, `update`	`d[k]=v`, `update`, `setdefault`
Deletion Methods	`remove`, `pop`, `del`, `clear`	`del var`	`discard`, `remove`, `pop`, `clear`	`pop`, `popitem`, `del`, `clear`