Data Structures
Tags: python, dsa, programming
Published: 2022-10-18 15:04:30

A structure is an arrangement and organization of related elements in a system.
Data is translated information for processing.

A data structure is a fundamental way of organizing data for efficient access dependent on the situation.

## Types Of Data Structures
### Lists
A list is an ordered collection of data which can store elements of the same type and different type.

```python

# how to create a list, using square brackets
list1 = [ ] #empty list
list2 =[1,2,3,4,5]
list3 =[1, 'e', 'g', 6.5, 8, 'i']
print(list2,list3)
#output [1, 2, 3, 4, 5] [1, 'e', 'g', 6.5, 8, 'i']
```
List elements are accessed by the assigned index. The index starts from '0' and ends at 'N - 1', where N is the total number of elements.

```python
print(list3[2]) #goes to item at index 2 in list 3
#g
```
#### Slicing Lists
To slice a list you use the `:` operator. To slice the list the start index is included while the last index is excluded. 

```python
# List slicing, syntax list[ Initial : End : IndexJump ]
my_list = ['d','a','t','a','s','t','r','u','c','t','u','r','e','s']

# elements from index 2 to index 5
print(my_list[2:5])#last item excluded
print(my_list[2:6])#last item included

# elements from index 4 to end
print(my_list[4:])

# elements beginning to end
print(my_list[:])

"""
output
['t', 'a', 's']
['t', 'a', 's', 't']
['s', 't', 'r', 'u', 'c', 't', 'u', 'r', 'e', 's']
['d', 'a', 't', 'a', 's', 't', 'r', 'u', 'c', 't', 'u', 'r', 'e', 's']
"""
```
Elements of a list can be changed, hence the term lists are mutable.
To change an item we can use the assignment operator `=`.
```python
nums1 = [2, 4, 6, 8]

# modifying the 1st item    
nums1[0] = 1            

print(nums1)

# change 2nd to 4th items
nums1[1:4] = [3, 5, 7]  

print(nums1)   

# output
# [1, 4, 6, 8]
# [1, 3, 5, 7]   
```
To add a value to a list we use the append() method, for multiple values we use the extend() method. Concatenation of lists is when two or more lists are combined together. To concatenate use the ` + ` operator

```python
# Appending and Extending lists in Python
nums = [1, 4, 5]

nums.append(8)

print(nums)

nums.extend([10, 11, 13])

print(nums)

nums.extend([20,15,14,16,18])

print(nums)

# output
# [1, 4, 5, 8]
# [1, 4, 5, 8, 10, 11, 13]
# [1, 4, 5, 8, 10, 11, 13, 20, 15, 14, 16, 18]
```

### List comprehensions
This is a simple way to create a new list from a existing one.
Syntax is `[expression for item in list]`.


```python
#an example of list comprehension and if statement
nums2 = [ x for x in range(10) if x % 2 == 0]
print(nums2)
#[0, 2, 4, 6, 8]

```

To iterate through lists we use the `for` statement, and `not in` statements. Other list properties can be found [here](https://www.programiz.com/python-programming/list)

### Dictionaries
Dictionaries are collections with `key:value` pairs.
To create a dictionary use the `{}`, curly braces. To access elements we use the keys inside square brackets`[]`, or the `get()` method.

```python
#empty dict
shuri = {}

# get vs [] for retrieving elements
shuri = {'title': 'ray', 'number': 16}

# Output: ray
print(shuri['title'])

# Output: 16
print(shuri.get('number'))
```
To add or change items in a dictionary use an assignment operator `=`. If the key exists, the value is updated, whereas if the key is not available, both the key and value are added.

```python
shuri = {'title': 'ray', 'number': 16}
#adding a value 
shuri['color'] = 'purple'

print(shuri)
#update the value
shuri['title'] = 'sheldon'

print(shuri)

# output
# {'title': 'ray', 'number': 16, 'color': 'purple'}
# {'title': 'sheldon', 'number': 16, 'color': 'purple'}
```
`pop()` method is used to remove an item from the dictionary using the key provided. `popitem()` method removes and returns the `key:value` pair. To remove all items we use `clear()` method and to remove the whole dictionary we use the `del` keyword.

```python
shuri = {'title': 'ray', 'number': 16, 'street':'kes', 'pages':123}
#adding a value 
shuri['color'] = 'purple'

print(shuri)
#update the value
shuri['title'] = 'sheldon'

print(shuri.pop('street'))

print(shuri)

print(shuri.popitem())

print(shuri)

#clear all the items
print(shuri.clear())

# delete the dictionary itself
del shuri

# output
# {'title': 'ray', 'number': 16, 'street': 'kes', 'pages': 123, 'color': 'purple'}
# kes
# {'title': 'sheldon', 'number': 16, 'pages': 123, 'color': 'purple'}
# ('color', 'purple')
# {'title': 'sheldon', 'number': 16, 'pages': 123}
# None
```
 
### Sets
Sets are created by either using the `set()` function or `{}` with items separated by commas. To add an item on a set use the `add()` method, for multiple items use `update()` method.
Sets do not store duplicates.

Items can be removed by using `discard()` and `remove()`.
The main difference between discard and remove is that remove raises an error if the element is not in the set while discard leaves the set the same.
```python
#create a set
shuri = set()
#add value to the set
shuri.add(4)
print(shuri)
#update values to the set
shuri.update([5,5,6], [7,11,12])
print (shuri)
shuri.discard(7)
shuri.remove(4)
print(shuri)

#other way to create a set
sam = {1,5,6}
print(sam)

# output
# {4}
# {4, 5, 6, 7, 11, 12}
# {5, 6, 11, 12}
```

#### Set Operations
Union is merging two sets to one using the `|` operator.
Intersection is the common items in the sets. Can be done in two methods using the `intersection()` function or `&` operator.
Difference of the set is a set of elements in the first set but not in the second set or vice versa. We use the `-` operator. This can also be achieved using the `difference()` method.
Symmetric difference is set of elements in the first and second set but not in both. We use the `^` operator or the `symmetric_difference()` method.
```python
#create a set
shuri = set()
#add value to the set
shuri.add(4)
print(shuri)
#update values to the set
shuri.update([5,5,6], [7,11,12])
print (shuri)
shuri.discard(7)
shuri.remove(4)
print(shuri)

#other way to create a set
sam = {1,5,6}
print(sam)

#union
print(sam|shuri)

#intersection
print(sam & shuri)

print(sam.intersection(shuri))

#difference
print(sam-shuri)
print(shuri.difference(sam))

#symmetric difference
print(sam^shuri)
print(shuri.symmetric_difference(sam))
```

## Conclusion
I hope you learned the different data structures, how to create and manipulate them.


### Read more from these resources
[Programiz](https://www.programiz.com/python-programming/list)
[DSA, Geeks for Geeks](https://www.geeksforgeeks.org/python-data-structures/#amp_tf=From%20%251%24s&aoh=16660244244881&referrer=https%3A%2F%2Fwww.google.com&ampshare=https%3A%2F%2Fwww.geeksforgeeks.org%2Fpython-data-structures%2F)
[List comprehensions](https://www.programiz.com/python-programming/list-comprehension)
[Lambda functions](https://www.programiz.com/python-programming/anonymous-function)
[List slicing](https://www.geeksforgeeks.org/python-list-slicing/)
[Dictionaries](https://www.programiz.com/python-programming/dictionary)
[Set](https://www.programiz.com/python-programming/set)