Review this guide on Python data types and data structures, and print the illustrations to help with your study.
You ever wonder why Python’s a go-to for so many developers? It’s not a mystery—it’s the data types and structures. Simple but powerful. You’ve got two groups: atomic types and composed types. One holds a single value, the other, a collection. This guide’s here to break it all down, clear the fog, and show you how to make these types work for you, no filler, no frills. Just the basics, straight up.
Primitive Data Types
These are the building blocks. The basics of Python. Simple values that are the backbone of any program.
Atomic Types
These types represent a single value. You’ll be using these all the time.
- bool
- int
- float
- complex
- NoneType
- str
Boolean Data Type
The boolean data type holds a value of either True or False. It’s simple but powerful.
Boolean Type Complexity
Time complexity: O(1)
Space complexity: O(1)
Boolean Functions
bool()
any()
all()
not
and
or
Boolean Examples
bool(1) => True
bool(0) => False
any([False, True]) => True
all([True, True]) => True
not False => True
(True and False) => False
(True or False) => True
Complex Data Type
Complex numbers have both a real and an imaginary part. This type lets you handle that.
Complex Type Complexity
Time complexity: O(1)
Space complexity: O(1)
Complex Functions
complex()
Complex Examples
complex(2, 3) => (2+3j)
Integer Data Type
Integers are whole numbers. No decimals, no fractions—just solid, raw numbers.
Integer Type Complexity
Time complexity: O(1)
Space complexity: O(1)
Integer Functions
int()
abs()
pow()
divmod()
round()
bin()
hex()
oct()
Integer Examples
int("42") => 42
abs(-5) => 5
pow(2, 3) => 8
divmod(10, 3) => (3, 1)
round(3.6) => 4
bin(5) => '0b101'
hex(255) => '0xff'
oct(8) => '0o10'
NoneType Data
NoneType is used when you don’t have a value. It’s Python’s way of saying “nothing here.”
NoneType Complexity
Time complexity: O(1)
Space complexity: O(1)
NoneType Functions
None
NoneType Examples
None == None => True
Floating Point Data Type
Floats are numbers with decimals. Perfect for handling precision.
Float Type Complexity
Time complexity: O(1)
Space complexity: O(1)
Float Functions
float()
round()
math.ceil()
math.floor()
math.sqrt()
math.exp()
math.log()
Float Examples
float("3.14") => 3.14
round(52.345, 2) => 52.35
math.ceil(4.2) => 5
math.floor(4.8) => 4
math.sqrt(16) => 4.0
math.exp(2) => 7.389
math.log(8, 2) => 3.0
String Data Type
Strings are sequences of characters. They’re how you handle text in Python.
String Type Complexity
Time complexity: O(1) for index access
Space complexity: O(n)
String Functions
ord()
chr()
str()
len()
lower()
upper()
isdigit()
String Examples
ord('A') => 65
chr(65) => 'A'
str(42) => '42'
len("hello") => 5
"hello".lower() => 'hello'
"hello".upper() => 'HELLO'
"123".isdigit() => True
Composed Abstract Data Types
Composed data types let you work with collections of values. They make Python flexible and powerful.
Dictionary Data Type
Dictionaries store key-value pairs. Think of it like a phone book: a name and its number.
Dictionary Type Complexity
Time complexity: O(1) for access
Space complexity: O(n)
Dictionary Functions
dict()
keys()
values()
items()
get()
pop()
update()
Dictionary Examples
dict(a=1, b=2).keys() => ['a', 'b']
dict(a=1, b=2).values() => [1, 2]
dict(a=1, b=2).items() => [('a', 1), ('b', 2)]
dict(a=1, b=2).pop('a') => 1
dict(a=1, b=2).update({'c': 3}) => {'a': 1, 'b': 2, 'c': 3}
Heap Data Type
Heaps are trees that store data with priority. Think of a heap like a min/max priority queue. The heap data type is a tree structure where the smallest or largest value is at the root.
Heap Type Complexity
Time complexity: O(log n) for insert/remove
Space complexity: O(n)
Heap Functions
heapq.heappush()
heapq.heappop()
heapq.heapify()
Heap Examples
heapq.heappush([], 3) => [3]
heapq.heappush([], 1) => [1, 3]
heapq.heappop([1, 3]) => 1
Priority Queue Data Type
A priority queue stores items with a given priority. Priority queues give you a way to deal with data based on importance, not order of arrival.
Priority Queue Type Complexity
Time complexity: O(log n) for insert/remove
Space complexity: O(n)
Priority Queue Functions
put()
get()
empty()
task_done()
join()
Priority Queue Examples
import queue
pq = queue.PriorityQueue()
pq.put((1, "A")) => None
pq.put((2, "B")) => None
pq.get() => (1, "A")
pq.get() => (2, "B")
Queue Data Type
The queue data type is a list where items are added at one end and removed from the other. A queue works on a first-in, first-out basis, like a line at a coffee shop.
Queue Type Complexity
Time complexity: O(1) for enqueue/dequeue
Space complexity: O(n)
Queue Functions
collections.deque()
append()
popleft()
Queue Examples
collections.deque([1, 2, 3]).append(4) => deque([1, 2, 3, 4])
collections.deque([1, 2, 3]).popleft() => 1
Set Data Type
Sets store unique elements and don’t care about order.
Set Type Complexity
Time complexity: O(1) for add/remove
Space complexity: O(n)
Set Functions
set()
add()
remove()
union()
intersection()
difference()
Set Examples
set([1, 2, 2, 3]) => {1, 2, 3}
{1, 2, 3}.add(4) => {1, 2, 3, 4}
{1, 2, 3}.remove(2) => {1, 3}
{1, 2, 3}.union({4, 5}) => {1, 2, 3, 4, 5}
{1, 2, 3}.intersection({2, 3, 4}) => {2, 3}
{1, 2, 3}.difference({2, 3}) => {1}
Stack Data Type
A stack follows the last-in, first-out (LIFO) rule. Think of it like a stack of plates at a buffet.
Stack Type Complexity
Time complexity: O(1) for push/pop
Space complexity: O(n)
Stack Functions
append()
pop()
collections.deque()
Stack Examples
stack = []
stack.append(1) => [1]
stack.append(2) => [1, 2]
stack.pop() => 2
Concrete Data Structures
Concrete data structures are the nuts and bolts of Python. They're what you use when the abstract stuff just doesn't cut it. You need something to hold your data, to let you work with it, and that's where these guys come in. Let’s break them down, section by section.
Built-in Data Structures
These are the ones that come with Python, no need to install anything. They’re the bread and butter of everyday programming.
Sequential Structures
These store stuff in a simple, ordered line. You add to the end, take from the end, and you’re good to go.
Array Data Type (List-Based)
An array is a simple sequence of values. It's your basic go-to structure for storing ordered items.
Array Type Complexity
Time complexity: O(1) for access
Time complexity: O(n) for insert/delete
Space complexity: O(n)
Array Functions
list()
len()
append()
pop()
extend()
index()
Array Examples
len(list("abc")) => 3
list("abc").append("d") => ['a', 'b', 'c', 'd']
list("abc").extend(["d", "e"]) => ['a', 'b', 'c', 'd', 'e']
list("abc").pop() => 'c'
list("abc").index("b") => 1
Dynamic Array
A dynamic array is like an array, but it can grow or shrink. Perfect for when you're not sure how much space you need upfront.
Dynamic Array Type Complexity
Time complexity: O(1) for access
Time complexity: O(n) for insert/delete
Space complexity: O(n)
Dynamic Array Functions
append()
insert()
remove()
resize()
List Data Type
The list is the most versatile of the bunch. It’s mutable, which means you can change it as you go.
List Type Complexity
Time complexity: O(1) for access
Space complexity: O(n)
List Functions
list()
append()
insert()
remove()
pop()
extend()
List Examples
lst = [1, 2, 3]
lst.append(4) => [1, 2, 3, 4]
lst.insert(1, 5) => [1, 5, 2, 3, 4]
lst.remove(3) => [1, 5, 2, 4]
lst.pop() => 4
Tuple Data Type
A tuple is like a list but locked. Once it’s set, you can’t change it. It’s perfect for when you need a fixed collection of items.
Tuple Type Complexity
Time complexity: O(1) for access
Space complexity: O(n)
Tuple Functions
tuple()
len()
index()
count()
Tuple Examples
tuple([1, 2, 3]) => (1, 2, 3)
len((1, 2, 3)) => 3
(1, 2, 3).index(2) => 1
(1, 2, 3).count(2) => 1
Range Data Type
Ranges store a sequence of numbers. They’re used a lot for looping and iterating.
Range Type Complexity
Time complexity: O(1) for access
Space complexity: O(n)
Range Functions
range()
Range Examples
range(0, 5) => range(0, 5)
Linked Data Structures
These structures are all about linking nodes together, each one pointing to the next. They're flexible, efficient, and perfect for dynamic data.
Deque Data Type
A deque, or double-ended queue, lets you add and remove items from both ends. It’s like a queue, but twice as handy.
Deque Type Complexity
Time complexity: O(1) for append/pop at ends
Space complexity: O(n)
Deque Functions
collections.deque()
append()
appendleft()
pop()
popleft()
Deque Examples
collections.deque([1, 2, 3]).append(4) => deque([1, 2, 3, 4])
collections.deque([1, 2, 3]).appendleft(0) => deque([0, 1, 2, 3])
collections.deque([1, 2, 3]).pop() => 3
collections.deque([1, 2, 3]).popleft() => 1
Linked List Data Type
The linked list is a chain of elements, where each element points to the next. It’s like a list, but it’s all pointers.
Linked List Type Complexity
Time complexity: O(1) for insert at head, O(n) for search
Space complexity: O(n)
Linked List Functions
insert()
delete()
search()
Indexed Data Structures
These data structures let you access elements quickly by using an index.
Heap Queue Data Type
A heap queue is a priority queue based on a heap. It’s useful for managing tasks or scheduling items based on priority.
Heap Queue Type Complexity
Time complexity: O(log n) for insert/remove
Space complexity: O(n)
Heap Queue Functions
heapq.heappush()
heapq.heappop()
heapq.heapify()
Heap Queue Examples
heapq.heappush([], 3) => [3]
heapq.heappush([], 1) => [1, 3]
heapq.heappop([1, 3]) => 1
User-Defined Data Structures
When Python’s built-in structures aren’t enough, that’s when you roll up your sleeves and create something custom. User-defined data structures are flexible, just like your code.
Hierarchical Data Structures
These are the structures that organize data in a tree. You can think of them like a family tree, with each node pointing to its children.
Graph Data Type
Graphs are collections of nodes connected by edges. They’re great for modeling networks, routes, and relationships.
Graph Type Complexity
Time complexity: O(1) for edge lookup
Space complexity: O(n + m), where n is the number of nodes and m is the number of edges
Graph Functions
add_node()
add_edge()
remove_edge()
Graph Examples
graph = {1: [2, 3], 2: [4], 3: [4], 4: []}
Tree Data Type
A tree organizes data in a branching structure, where each node has a parent and may have children. It’s hierarchical like a graph, but simpler.
Tree Type Complexity
Time complexity: O(log n) for search
Space complexity: O(n)
Tree Functions
add_child()
remove_child()
Tree Examples
tree = {'A': ['B', 'C'], 'B': ['D'], 'C': [], 'D': []}
Trie Data Type
A trie is a tree where each node represents part of a string. A trie stores strings in a tree-like structure. It’s perfect for quick searches, especially for tasks like autocomplete.
Trie Type Complexity
Time complexity: O(m) for search, where m is the word length
Space complexity: O(n), where n is the number of words
Trie Functions
insert()
search()
Trie Examples
trie = {'c': {'a': {'t': {'#': True}}, 'o': {'w': {'#': True}}}}
Binary Tree Data Type
A binary tree is a tree where each node has at most two children. It's a simpler structure than general trees, but just as useful.
Binary Tree Type Complexity
Time complexity: O(log n) for balanced search
Space complexity: O(n)
Binary Tree Functions
insert()
delete()
Binary Tree Examples
binary_tree = {'A': {'left': 'B', 'right': 'C'}, 'B': {'left': 'D', 'right': 'E'}, 'C': {}}
Binary Search Tree Data Type
A binary search tree is like a binary tree but with a twist: it keeps the elements in sorted order to allow fast lookups.
Binary Search Tree Type Complexity
Time complexity: O(log n) for search/insert
Space complexity: O(n)
Binary Search Tree Functions
insert()
search()
delete()
Binary Search Tree Examples
binary_search_tree = {'root': 'M', 'left': {'root': 'G', 'left': 'E', 'right': 'I'}, 'right': {'root': 'S', 'left': 'Q', 'right': 'Z'}}
Hashed Data Structures
Hashed data structures use a hash function to manage data. They’re like a fast lane for data access.
Hash Map Data Type
A hash map stores data in key-value pairs, allowing for quick access.
Hash Map Type Complexity
Time complexity: O(1) for access
Space complexity: O(n)
Hash Map Functions
put()
get()
remove()
Hash Map Examples
hash_map = {'a': 1, 'b': 2}
Hash Set Data Type
A hash set stores unique elements using a hash function.
Hash Set Type Complexity
Time complexity: O(1) for add/remove
Space complexity: O(n)
Hash Set Functions
add()
remove()
Hash Set Examples
hash_set = {1, 2, 3}
Third-party Data Structures
Third-party data structures are the tools you grab when the built-in stuff doesn’t fit your needs.
Sorted Containers Data Structures
The sortedcontainers library gives you sorted structures with fast access times.
SortedDict Data Type
A SortedDict is a dictionary that keeps its keys in sorted order.
SortedDict Type Complexity
Time complexity: O(log n) for insert/search
Space complexity: O(n)
SortedDict Functions
get()
setitem()
pop()
SortedDict Examples
from sortedcontainers import SortedDict
sorted_dict = SortedDict({2: 'b', 1: 'a'})
SortedSet Data Type
A SortedSet is a set that keeps its elements in order.
SortedSet Type Complexity
Time complexity: O(log n) for insert/search
Space complexity: O(n)
SortedSet Functions
add()
remove()
SortedSet Examples
from sortedcontainers import SortedSet
sorted_set = SortedSet([3, 1, 2])
sorted_set.add(4) => SortedSet([1, 2, 3, 4])
Illustrations
Python Data Types & Data Structures
Python Primitive Atomic Data Types
Python Composed Abstract Data Types
Python Composed Concrete Built-In Sequential Data Structures
Python Composed Concrete Built-In Linked Data Structures
Python Composed Concrete Built-In Indexed Data Structures
Python Composed Concrete User-Defined Hierarchical Data Structures
Python Composed Concrete User-Defined Hashed Data Structures
Python Composed Concrete User-Defined Third-Party Sorted Containers Data Structures
Next Steps: Print and Review
Alright, here’s the deal: You’ve got the basics of Python data types and data structures. Now, it’s time to put it to work. Grab this guide and print it out. The illustrations? Print those too. They’re not just for decoration—they’re a map for your study.
Print, Study, and Nail It
You’re not going to remember everything in one go. That’s fine. Print this guide, toss it on your desk, keep it by your side. Use it as a reference while you dig into the code. And those illustrations? They’ll help you see the whole picture. It’s all about having the right tools when you need them.
Keep the Guide Close
This isn’t some "read once and forget" thing. Keep this guide nearby. You’ll use it over and over, especially when you're working through more complex problems or starting new projects. Think of it as your Python toolbox—keep it handy and ready to go.
And remember, when it starts to click, you’ll see how these structures fit into everything. So print it, study it, and make sure you’re ready for what comes next.
Share Your Thoughts: Python Data Types & Data Structures
Drop your thoughts in the comments. What's your favorite way to learn Python data types and data structures?
Mike Vincent is an American software engineer and writer based in Los Angeles. Mike writes about technology leadership and holds degrees in Linguistics and Industrial Automation. More about Mike Vincent
Top comments (0)