Introduction
Data structures are simply the different ways of organizing and storing data in our computers so as to perform operations on the data.
Bult-in Data Structures
Data structures allow us to organize, store, and manage data for efficient access and modification.
List
A list is defined using square brackets and holds data that is separated by commas. It is a type of data used to represent/ store a list of objects in a single variable . It can contain a mix of different data types. We use print()function to print the output on the terminal.
Lists are indexed from 0
Example of a list in Python is as shown below.
mylist=["Faith",32,"Kenya"]
print (mylist)
Output:
[‘Faith’,32,’Kenya’]
The append() method adds an item to the end of the list.
mylist.append(3)
print(mylist)
The insert() method adds an item at a specific place in the list
mylist.insert(0, 38)
The pop() method removes last element from list
numbers.pop()
print(mylist)
To access an element on the list
print(numbers[0])
To check index of an item
fruits = ['apple', 'banana', 'orange', 'grape']
index = fruits.index('banana')
print(index)
Tuple
A tuple is an ordered collection of items. It is a data type for immutable ordered sequences of elements I.e
you can’t add and remove elements from tuples, or sort them in place
A tuple is used to store a sequence of objects.
Tuples are indexed from 0.
We can create tuples using the method below:
positions = (4,9,18)
print(positions)
To access tuples using their index we use the method shown below:
print(positions [2])
To create a list of tuples we use the method shown below:
positions = [(4,9,18), (30,15, 19)]
Set
Set is a mutable and unordered collection of unique elements. It can permit us to remove duplicate quickly from a list.
A set is mutable, it can be changed or modified once created.
Removing duplicates from a list
numbers = [9, 16, 3, 4, 9, 3]
unique_numbers = set(numbers)
print(unique_numbers)
Union of sets
first_set = {3, 4}
second_set = {5, 6}
print(first | second)
Intersection of sets
print(first_set & second_set)
Difference between two sets
print(first_set - second_set)
Symmetric difference
print(first_set ^ second_set)
Iterating over elements in a set
numbers = {3, 7}
for x in numbers:
print(x)
output
3
7
Dictionary
Dictionary is a mutable and unordered data structure. It permits storing a pair of items (i.e. keys and values).
We can use strings, numbers or tuples as keys.
The value can be any data type.
We can assign one value to multiple keys.
We can create dictionaries using dict() method.
Creating a dictionary
user = {"name": "Faith", "age":32, "hobbies": ["cooking", "singing"]}
print(user)
Accessing a specific key
print(user["name"])
Specifying a default value for keys that do not exist
print(user.get("email", "Invalid key"))
Adding a key to the dictionary
user["email"] = "lobbystar@gmail.com"
print(user.get("email"))
Changing value of a key
user[name] = "Liam"
print(user)
To modify several or all values
user.update({"name": "David", "age": 21, "email": "kingdavid@gmail.com"})
To delete a key
del user["hobbies"]
print(user)
Looping through keys and values
for key, value in user.items():
print(key, value)
User-defined data structures
These are data structures that are not supported by Python, but can be programmed by the user to function similarly to Python built-in data structures.
We will look at stacks, queues and linked lists.
Stack
A stack is a linear data structure that follows the LIFO(Last In First Out) principle.. So, the last element inserted will be removed as the first. The operations are:
• Push → inserting an element into the stack
• Pop → deleting an element from the stack
The conditions to check:
• overflow condition → this condition occurs when we try to put one more element into a stack that is already having maximum elements.
• underflow condition →this condition occurs when we try to delete an element from an empty stack.
Stacks in Python can be implemented using lists, Collections.deque, queue.LifoQueue
Functions we can perform on stacks
append/ push() -to add an item on top of the stack.
pop() -to remove an item on top of the stack.
peek/ top() - to view the top element of the stack.
size()-returns the size of the stack.
[-1] -to get the item that is on top of the stack. It only works if our stack is not empty.
empty()-to return whether the stack is empty.
Queue
A queue is a linear data structure that follows FIFO(First In First Out) principle.
Insertion and deletion in queues happens on the rear-end and front-end.
In Python, queues can be implemented using lists, collection.deque, queue.Queue
Two ends:
• front → points to starting element
• rear → points to the last element
There are two operations:
• enqueue → inserting an element into the queue. It will be done at the rear.
• dequeue → deleting an element from the queue. It will be done at the front.
There are two conditions:
• overflow → insertion into a queue that is full
• underflow → deletion from the empty queue
Linked list
A linked list is a data structure for storing a collection of items.
A linked list can be visualized as several boxes connected to each other.
The data used in linked lists can be strings, numbers, characters, etc.
Linked lists can be used to implement stacks, queues and graphs.
Algorithms
Algorithms are instructions that are formulated in a finite and sequential order to solve problems.
When we write an algorithm, we have to know what is the exact problem, determine where we need to start and stop and formulate the intermediate steps.
Algorithms are also the operations that we can perform on different data structures and the set of instructions for executing them.
To learn more about algorithms click here
You can also read this article to learn more about data structures.
Top comments (0)