Do you want to pick out elements from a list of objects but forgot how to do list comprehension? Or maybe you have a JavaScript Object Notation (JSON) file and need to find a suitable data structure (such as Python's dictionary data type) to process the data in it. Browsing app development forums to find a helpful piece of Python code can be frustrating.
The good news is we’ve prepared this cheat sheet for people like you. It doubles as a refresher on data structures and algorithms as applied to Python. Keep a copy of this Python data structures cheat sheet on your desk to look up commands or code snippets the next time you need to recall them.
This Python data structures cheat sheet covers the theoretical essentials. Download the PDF version here.
Python Data Structures Cheat Sheet Search
Search our Python data structures cheat sheet to find the right cheat for the term you're looking for. Simply enter the term in the search bar and you'll receive the matching cheats available.
Types of Data Structures in Python
Here’s a diagram to illustrate the hierarchy of Python data structures:
Python Primitive Data Structures
These store simple data values.
| Description | Examples | |
|---|---|---|
| String | Collection of characters surrounded by single or double quotation marks | 'Alice', "Bob" |
| Boolean | Logical values | True, False |
| Integer | Whole number of unlimited length | 0, -273 |
| Float | Floating-point decimal | 1.618, 3.1415926 |
Python Built-In Non-Primitive Data Structures
These data structures, which store values and collections of values, are inherent to Python.
| Description | Ordered | Allow duplicates | Mutable | Syntax | Examples |
|---|---|---|---|---|---|
| List | √ | √ | √ | [ ] | • [1, 2.3, True]• ['John', 'Doe'] |
| Tuple | √ | √ | ✕ | ( ) | • ('age', 22)• (7.89, False) |
| Set 0 is the same as False, as are 1 and True. | ✕ | ✕ | ✕ | { } | • {6, 4.5}• {'nice', True} |
| Dictionary Map, storing key-value pairs. | √ > 3.7 ✕ ≤ 3.6 | ✕ | √ | {key: value} | • {"FB": "Facebook",• {'name': 'Bob', 'id': 255} |
List and Tuple Operations
Note that Python lists and tuples are zero-indexed, meaning the first element has an index of 0. See the command chart below for an example.
Accessing Items in Lists
The table below is based on this list:
fruit_list = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"].
| Command | Description |
|---|---|
fruit_list[0] | Get the first item on the list ("apple") |
fruit_list[1] | Get the second item on the list ("banana") |
fruit_list[-1] | Get the last item ("mango") |
fruit_list[Â2:5] | Get the items from start to end indexes |
fruit_list[:4] | Get the items from the beginning but exclude "kiwi" and beyond |
fruit_list[2:] | Get the items from "ÂcheÂrryÂ" to the end |
fruit_list[Â-4:-1] | Get the items from "ÂoraÂngeÂ" (-4) onwards but exclude "ÂmanÂgo" (-1) |
if "ÂappÂle" in fruit_list: print(Â"Yes, we have 'apple'") | Check if "ÂappÂle" is in the list |
List (and Tuple) Methods
Commands with an asterisk (*) apply to tuples.
| Command | Description | Usage |
|---|---|---|
append() | Add an element at the end of the list | list1.aÂppend(element) |
clear() | Remove all the elements from the list | list1.cÂlear() |
copy() | Return a copy of the list | list1.cÂopy() |
count() | Return the number of elements with the specified value* | list1.cÂounÂt(eÂlement) |
extend() | Add the elements of a list (or any iterable), to the end of the current list | list1.eÂxtÂendÂ(list2) |
index() | Return the index of the first element with the specified value* | list1.iÂndeÂx(eÂlemÂentÂ[,sÂtarÂt[,Âend]]) |
insert() | Add an element at the specified position (position is an integer) | list1.iÂnseÂrt(ÂpoÂsition, element) |
pop() | Remove the element at the specified position | list1.pÂop(Â[inÂdex]) |
remove() | Remove the first item with the specified value | list1.rÂemoÂve(ÂeleÂment) |
reverse() | Reverse the order of the list | list1.reÂverse() |
sort()sort(reverse = True) | Sort the list in ascending / descending order | list1.sort()list2.sort(reverse = True) |
del() | Delete from the list the item specified with its index | del list1[Âindex] |
list1 + list2 | Join two lists | list1 = ["x", "y"]list2 = [8, 9]list3 = list1 + list2# Returns: ["x","y",8,9] |
List Comprehension
List compreÂhension simplifies the creation of a new list based on the values of an existing list.
| Command | Description |
|---|---|
[n for n in range(10) if n < 5] | Accept only numbers less than 5 |
[x for x in fruits if "Âa" in x] | Accept items containing "Âa". |
[x for x in fruits if x != "ÂappÂle"] | Accept all items except "ÂappÂle" |
[x.upper() for x in fruits] | Make uppercase the values in the new list |
[x + '?' for x in fruits] | Add a question mark at the end of each item |
['hello' for x in fruits] | Set all values in the new list to 'hello' |
[x if x != "ÂbanÂanaÂ" else "ÂoraÂngeÂ" for x in fruits] | Replace "ÂbanÂanaÂ" with "ÂoraÂngeÂ" in the new list |
Accessing Items in Tuples
Below, the tuple in question is fruits = ("apple", "banana", "cherry").
| Command | Description |
|---|---|
"ÂappÂle" in fruits | Check if "ÂappÂle" is present in the tuple. This command returns the value True. |
(x, y, z) = fruits# y == "banana"# z == "cherry"# _ == ["banana", "cherry"] | Assign variables to take up each item in the tuple, also known as unpacking a tuple. Either the number of variables must match the number of values in the tuple, or use an asterisk as shown to put away the unwanted values. |
Tuple Manipulation
Adding items
You can add items to a tuple as follows:
| Initial | original = ("apÂpleÂ", "ÂbanÂanaÂ", "ÂcheÂrryÂ") |
| Code | new_item = ("orÂangÂe",)original += new_item |
| Result | ("apÂpleÂ", "ÂbanÂanaÂ", "ÂcheÂrryÂ", "orange") |
Tip: When creating a single-item tuple, remember to include a comma.
Removing items and changing values
Since tuples are immutable, you can’t remove or modify their contents directly. The key is converting it into a list and back.
| Example | Addition | Removal | Change |
|---|---|---|---|
| Initial | original = ("apÂpleÂ", "ÂbanÂanaÂ", "ÂcheÂrryÂ") | original = ("apÂpleÂ", "ÂbanÂanaÂ", "ÂcheÂrryÂ") | original = ("apÂpleÂ", "ÂbanÂanaÂ", "ÂcheÂrryÂ") |
| → List | tempList = list(original) | tempList = list(original) | tempList = list(original) |
| Code | tempList.appeÂnd(Â"ÂoraÂngeÂ") | tempList.remoÂve(Â"ÂappÂle") | tempList[1] = "ÂkiwÂi" |
| → Tuple | newList = tuple(tempList) | newList = tuple(tempList) | newList = tuple(tempList) |
Result of newList | ("apÂpleÂ", "ÂbanÂanaÂ", "ÂcheÂrryÂ", "orange") | ("ÂbanÂanaÂ", "ÂcheÂrryÂ") | ("kiwi", "ÂbanÂanaÂ", "ÂcheÂrryÂ") |
Dictionary Operations
Adding Items
There are three methods:
| Example | Addition #1 (direct) | Addition #2 (update()) | Addition #3 (**) |
|---|---|---|---|
| Initial | meta = { "FB": "Facebook", "WA": "WhatsApp", "IG": "Instagram" }new_co = { "GIF": "Giphy" } | meta = { "FB": "Facebook", "WA": "WhatsApp", "IG": "Instagram" }new_co = { "GIF": "Giphy" } | meta = { "FB": "Facebook", "WA": "WhatsApp", "IG": "Instagram" }new_co = { "GIF": "Giphy" } |
| Code | meta[Â"GIF"] = "Giphy" | meta.update(new_co) | meta = {**meta, **new_co} |
Result of meta | { "FB": "Facebook", "WA": "WhatsApp", "IG": "Instagram", "GIF": "Giphy" } | { "FB": "Facebook", "WA": "WhatsApp", "IG": "Instagram", "GIF": "Giphy" } | { "FB": "Facebook", "WA": "WhatsApp", "IG": "Instagram", "GIF": "Giphy" } |
Warning: duplicate keys will cause the latest values to overwrite earlier values.
General Operations
| Command | Description | Example |
|---|---|---|
del dict1[Â"key1"] | Remove the item with the specified key name | del meta[Â"WA"]# "WhatsApp" |
del diÂct1 | Delete the dictionary | del meta |
dict1[key1] | Access the value of a dictionary dict1 element using its key key1 | meta["FB"]# "Facebook" |
| Dictionary method | Description | Usage |
clear() | Remove all the elements from the dictionary | dict1.cÂlear() |
copy() | Return a copy of the dictionary | dict1.cÂopy() |
fromkeys() | Return a dictionary with the specified keys and value | dict1.fÂromÂkeyÂs(keys, value) |
get() | Return the value of the specified key | dictioÂnarÂy.gÂet(ÂkeyÂ_name, value) |
items() | Return a list containing a tuple for each key-value pair | dict1.iÂtems() |
keys() | Return a list containing the dictioÂnary’s keys | dict1.kÂeys() |
pop() | Remove the element with the specified key | dict1.pÂop(keÂy_name) |
popitem() | Remove the last inserted key-value pair | dict1.pÂopiÂtem() |
setdefÂault() | Return the value of the specified key. If the key does not exist, add as new key-value pair | dict1.sÂetdÂefaÂultÂ(keÂy_name, value) |
update() | Update the dictionary with the specified key-value pairs | dict1.uÂpdaÂte(ÂiteÂrable) |
values() | Return a list of all the values in the dictionary | dict1.vÂalues() |
Set Operations
Accessing
Although you can’t directly access items in a set, you can loop through the items:
| Example | Accessing items in a set (using list comprehension) |
|---|---|
| Code | set1 = {32, 1, 2, 27, 83, 26, 59, 60}set1_odd = [i for i in set1 if i % 2 == 1] |
| Result | set1_odd = [1, 27, 83, 59] |
Adding and Removing Items
| Command | Description | Usage |
|---|---|---|
add() | Add a single element to the set | fruits.aÂdd(Â"ÂoraÂngeÂ") |
update() | Add elements from another set into this set | fruits.aÂdd(Â{"piÂneaÂpplÂe", "ÂmanÂgo", "durian"}) |
discard()remove() | Remove the specified element | fruits.dÂiscÂardÂ("baÂnanÂa")fruits.rÂemoÂve(Â"ÂbanÂanaÂ") |
pop() | Remove the last element in the set. The return value of bye is the removed element. | bye = fruits.pop() |
clear() | Empty the set | fruits.clear() |
copy() | Return a copy of the set | fruits.copy() |
del | Delete the set | del fruits |
Mathematical Operations
| Command / Binary operator(s) | Description |
|---|---|
differÂence()- | Get the difference of several sets |
differÂencÂe_uÂpdate() | Remove the elements in this set that are also included in another, specified set |
intersÂectÂion()& | Get intersection of sets |
intersÂectÂionÂ_upÂdate() | Remove the elements in this set that are not present in other, specified set(s) |
isdisjÂoint() | Return whether two sets have an intersÂection |
issubset()<, <= | Check if a set is a (strict <) subset |
issupeÂrset()>, >= | Check if a set is a (strict >) superset |
symmetÂricÂ_diÂffeÂrence()^ | Get symmetric differÂence of two sets |
symmetric_difference_update() | Insert the symmetric differÂences from this set and another |
union()| | Get the union of sets |
Algorithms and the Complexities
This section is about the complexity classes of various Python data structures.
List
Tuples have the same operations (non-mutable) and complexities.
Command (L: list) | Complexity class |
|---|---|
L.append(item) | O(1) |
L.clear() | O(1) |
item in/not in L | O(N) |
L.copy() | O(N) |
del L[i] | O(N) |
L.extend(…) | O(N) |
L1==L2, L1!=L2 | O(N) |
L[i] | O(1) |
for item in L: | O(N) |
len(L) | O(1) |
k*L | O(k*N) |
min(L), max(L) | O(N) |
L.pop(-1) | O(1) |
L.pop(item) | O(N) |
L.remove(…) | O(N) |
L.reverse() | O(N) |
L[x:y] | O(y-x) |
L.sort() | O(N*log(N)) |
L[i]=item | O(1) |
Dictionary
Command (d: dictionary) | Complexity class / range (—) |
|---|---|
d.clear() | O(1) |
dict(…) | O(len(d)) |
del d[k] | O(1) — O(N) |
d.get() | O(1) — O(N) |
for item in d: | O(N) |
len(d) | O(1) |
d.pop(item) | O(1) — O(N) |
d.popitem() | O(1) |
d.values() | O(1) |
d.keys() | O(1) |
d.fromkeys(seq) | O(len(seq)) |
Set
| Operation | Command (s: set) | Complexity class / range (—) |
|---|---|---|
| Add | s.add(item) | O(1) — O(N) |
| Clear | s.clear() | O(1) |
| Copy | s.copy() | O(N) |
| Containment | item in/not in s | O(1) — O(N) |
| Creation | set(…) | O(len(s)) |
| Discard | s.discard(item) | O(1) — O(N) |
| Difference | s1-s2 | O(len(s1)) |
| Difference Update | s1.difference_update(s2) | O(len(s2)) — ∞ |
| Equality | s1==s2, s1!=s2 | O(min(len(s1), len(s2))) |
| Intersection | s1&s2 | O(min(len(s1), len(s2))) |
| Iteration | for item in s: | O(N) |
| Is Subset | s1<=s2 | O(len(s1)) |
| Is Superset | s1>=s2 | O(len(s2)) — O(len(s1)) |
| Pop | s.pop() | O(1) — O(N) |
| Union | s1|s2 | O(len(s1)+len(s2)) — ∞ |
| Symmetric Difference | s1^s2 | O(len(s1)) — O(len(s1)*len(s2)) |
Symbol Table
Python keeps track of variables using symbol tables, which you can explore using the following basic commands:
| Command | Description |
|---|---|
__doc__ | Program documentation as comments (#, """, ''') at the beginning of the code |
__name__ | How you run the Python program.Direct execution: __name__ == "__main__" |
dir() | Effective namespace |
global() | Dictionary of variable names of global scope to variable values |
locals() | Dictionary of variable names of local scope to variable values |
eval() | Return the value of the specified variable Example usage: for x in dir(): print(x, eval(x)) |
Python Libraries
The following commands are for setting up Python programs or libraries for use inside your program:
| Command | Description |
|---|---|
import module1 | Import program / library module1 as Python module |
from module1 import obj1, obj2 | Import the objects obj1, obj2 from module1 |
from module1 import * | Import all objects in module1 |
module1.__dict__ | Return the dictionary containing module1’s symbol table, like dir() of the main program |
Examples of Python libraries containing other non-primitive data structures:
- array: Efficient arrays of numeric values
- collections: Abstract data structures
- dataclasses: For creating user-defined data structures
- datetime: Basic date and time types
- queue: Synchronized queue class
Experience Software Development
Much of the above is crucial in developing apps for commercial settings, including freelancing. We hope this Python data structures cheat sheet is helpful. To download a PDF version, click here.
At StationX, we have self-paced Python tutorials and labs focusing on cybersecurity. Check out our VIP membership to learn more.
Frequently Asked Questions
Level Up in Cyber Security: Join Our Membership Today!
