Python Data Structures Cheat Sheet - Lists, Dicts, Sets, Tuples, Strings

[hirenpatel1903]

📚 Python Data Structures - Extended CheatSheet : Lists | Dictionaries | Sets | Tuples | Strings

A complete and developer-friendly reference guide covering the core Python data structures.
Perfect for beginners, interview prep, revision, and quick lookup.

---

🔵 Lists

A list is an ordered, mutable collection in Python.
Common operations include creation, indexing, slicing, appending, removing, sorting, copying, and comprehensions.

Create a list: my_list = [1, 2, 3, 4, 5]
Create list from iterable: list(range(5))
Access element by index: element = my_list[0]
Access last element: last = my_list[-1]
Slicing: sub_list = my_list[1:4]
Slicing with step: every_second = my_list[::2]
Reverse list with slicing: reversed_list = my_list[::-1]
Append element: my_list.append(6)
Extend list: my_list.extend([7, 8, 9])
Insert element: my_list.insert(2, 10)
Remove element: my_list.remove(3)
Remove element at index: del my_list[2]
Pop element: popped = my_list.pop()
Pop element at index: popped = my_list.pop(2)
Clear list: my_list.clear()
Index of element: index = my_list.index(4)
Count occurrences: count = my_list.count(2)
Sort list in-place: my_list.sort()
Sort list descending: my_list.sort(reverse=True)
Sort list with key: my_list.sort(key=abs)
Reverse list in-place: my_list.reverse()
Copy list: new_list = my_list.copy()
Shallow copy: import copy; shallow_copy = copy.copy(my_list)
Deep copy: import copy; deep_copy = copy.deepcopy(my_list)
List comprehension: squares = [x**2 for x in range(10)]
Conditional list comprehension: evens = [x for x in my_list if x % 2 == 0]
Nested list comprehension: matrix = [[i*j for j in range(5)] for i in range(5)]
Map function to list: doubled = list(map(lambda x: x*2, my_list))
Filter list: evens = list(filter(lambda x: x % 2 == 0, my_list))
Check if item in list: is_present = 3 in my_list
Get length of list: length = len(my_list)
Get max value: max_val = max(my_list)
Get min value: min_val = min(my_list)
Sum of list: total = sum(my_list)
Join list of strings: joined = " ".join(["Hello", "World"])
Split string to list: my_list = "Hello World".split()
Zip lists: zipped = list(zip([1, 2, 3], ['a', 'b', 'c']))
Unzip lists: nums, letters = zip(*zipped)
Enumerate list: for index, value in enumerate(my_list):
List from enumerated: indexed = list(enumerate(my_list))
Flatten list of lists: flattened = [item for sublist in matrix for item in sublist]
Create list with repeated elements: repeated = [0] * 5

🟡 Dictionaries

A dictionary stores key-value pairs and is one of Python’s most powerful data types.
Supports fast lookups, updates, merging, filtering, comprehensions, and advanced usage like defaultdict, OrderedDict, and deep copying.

Create a dictionary: my_dict = {'a': 1, 'b': 2, 'c': 3}
Create dict from list: my_dict = dict(a=1, b=2, c=3)
Create dict from list of tuples: my_dict = dict([('a', 1), ('b', 2), ('c', 3)])
Access value by key: value = my_dict['a']
Get value with default: value = my_dict.get('d', 0)
Add/update item: my_dict['d'] = 4
Update multiple items: my_dict.update({'e': 5, 'f': 6})
Remove item: del my_dict['b']
Pop item: value = my_dict.pop('c')
Pop item with default: value = my_dict.pop('e', None)
Remove and return item: item = my_dict.popitem()
Clear dictionary: my_dict.clear()
Get all keys: keys = my_dict.keys()
Get all values: values = my_dict.values()
Get all items: items = my_dict.items()
Copy dictionary: new_dict = my_dict.copy()
Shallow copy: import copy; shallow_copy = copy.copy(my_dict)
Deep copy: import copy; deep_copy = copy.deepcopy(my_dict)
Check if key exists: exists = 'a' in my_dict
Check if key not exists: not_exists = 'z' not in my_dict
Dictionary comprehension: squared = {x: x**2 for x in range(5)}
Conditional dict comprehension: even_squares = {x: x**2 for x in range(10) if x % 2 == 0}
Merge dictionaries (Python 3.9+): merged = dict1 | dict2
Merge dictionaries (Python 3.5+): merged = {**dict1, **dict2}
Get length: length = len(my_dict)
Create dict from keys: new_dict = dict.fromkeys(['a', 'b', 'c'], 0)
Set default value: my_dict.setdefault('g', 7)
Get value or set default: value = my_dict.setdefault('h', 8)
OrderedDict: from collections import OrderedDict; ordered = OrderedDict()
Defaultdict: from collections import defaultdict; dd = defaultdict(int)
Invert dictionary: inverted = {v: k for k, v in my_dict.items()}
Sort by key: sorted_dict = dict(sorted(my_dict.items()))
Sort by value: sorted_dict = dict(sorted(my_dict.items(), key=lambda x: x[1]))
Filter dict: filtered = {k: v for k, v in my_dict.items() if v > 2}

🟢 Sets

Sets are unordered collections of unique elements.
Useful for membership tests, removing duplicates, unions, intersections, differences, symmetric differences, and set comprehensions.

Create set: my_set = {1, 2, 3, 4, 5}
Create set from list: my_set = set([1, 2, 3, 4, 5])
Create empty set: empty_set = set()
Add: my_set.add(6)
Update: my_set.update({7, 8, 9})
Remove: my_set.remove(3)
Discard: my_set.discard(10)
Pop: element = my_set.pop()
Clear: my_set.clear()
Copy: new_set = my_set.copy()
Shallow copy: import copy; shallow_copy = copy.copy(my_set)
Deep copy: import copy; deep_copy = copy.deepcopy(my_set)
Union: union_set = set1.union(set2)
Union operator: set1 | set2
Intersection: set1 & set2
Difference: set1 - set2
Symmetric difference: set1 ^ set2
Subset check: set1.issubset(set2)
Superset check: set1.issuperset(set2)
Disjoint: set1.isdisjoint(set2)
Frozen set: frozen = frozenset([1, 2, 3])
Set comprehension: even_set = {x for x in range(10) if x % 2 == 0}
Length: len(my_set)
Max/min: max(my_set) / min(my_set)
Sum: sum(my_set)

🔴 Tuples

Tuples are immutable ordered collections.
Great for fixed data, unpacking, safe structured storage, and operations like counting, indexing, slicing, and mapping.

Create: my_tuple = (1, 2, 3, 4, 5)
From list: tuple([1, 2, 3, 4, 5])
Single element: (42,)
Empty: ()
Access: element = my_tuple[0]
Negative index: last = my_tuple[-1]
Slice: sub_tuple = my_tuple[1:4]
Concat: new_tuple = my_tuple + (6, 7, 8)
Repeat: repeated = my_tuple * 3
Unpack: a, b, c = (1, 2, 3)
Unpack with *: a, *rest = (1, 2, 3, 4, 5)
Swap: a, b = b, a
Nested: nested = ((1, 2), (3, 4))
Count: my_tuple.count(2)
Index: my_tuple.index(3)
Length: len(my_tuple)
Max/min: max(my_tuple) / min(my_tuple)
Sum: sum(my_tuple)
Sort (returns list): sorted(my_tuple)
Map: mapped = tuple(map(lambda x: x * 2, my_tuple))
Any/all: any(my_tuple), all(my_tuple)

🟣 Strings

Strings in Python are powerful and flexible.
Includes slicing, formatting, case conversion, trimming, splitting, joining, searching, encoding/decoding, and complex formatting (f-strings, .format(), maketrans, etc.)

Create: my_string = "Hello, World!"
Multiline: """This is multiline"""
Raw: r"C:\Users\John"
F-string: f"Hello, {name}"
Access: char = my_string[1]
Slice: my_string[7:12]
Reverse: my_string[::-1]
Concat: "Hello" + " World"
Repeat: "Ha" * 3
Upper/lower: my_string.upper(), my_string.lower()
Capitalize/title/swapcase
Strip/lstrip/rstrip
Replace: my_string.replace("Hello", "Hi")
Split, splitlines
Join: "-".join(["a", "b", "c"])
Center/ljust/rjust
Starts/ends with
Find, rfind, index, rindex
Count: my_string.count("l")
Checks: isalpha, isdigit, islower, isupper, isspace, isprintable, isnumeric, isidentifier
Encode/decode
Remove prefix/suffix
Partition / rpartition
Translate: my_string.translate(str.maketrans('aeiou', '12345'))
Formatting: format(), f-string

---

📝 How to Use This Repository

✔ Use this list for interview preparation
✔️ Practice each topic with examples
✔️ Contribute improvements via Pull Request
✔️ Share with your friends or students

🌐 Follow & Subscribe

Stay connected and support us online:

Platform	Link
🐦 Twitter	https://twitter.com/einzigartigetec/
📘 Facebook	https://www.facebook.com/einzigartige/
💼 LinkedIn	https://www.linkedin.com/company/einzigartige/
▶️ YouTube	https://www.youtube.com/@einzigartige_/
🌍 Website	http://einzigartige.in/

---

📊 Live YouTube Statistics

👉 Subscribe here: https://www.youtube.com/@einzigartige_/