Built-in Data Structures In Python
Tags: datascience, python, beginners, webdev
Published: 2021-12-14 11:59:00

##Introduction
Python has always been classified as a general-purpose programming language due to it's versatility, from web dev to data science.
However, data has become a lifestyle and has to be considered during systems design. All the data collected needs to be store and accessed efficiently. To attain this , data structures come in hand.

### 1. What's a Data structure ?
A data structure is a specialized format for organizing, processing, retrieving and storing data.

####Types of Data Structures
__1. Built-in__

As the name suggest, Built-in data structures are predefined data structures that come along with python.Can be accessed from any python environment.
__a.Lists__
They are used to store data of different data types in a sequential manner.Every member of the list are assigned unique address called index.The first member of a list is assigned number 0. Members of the list can accessed in two ways; Positive indexing(the most common method) and Negative indexing.All this will be demonstrated in examples.
List are created by assigning square rackets to a variable and add a values accordingly.
__Implementation__
```python
#creating empty values
cars = []
print(cars)
#adding elements to a list
cars = ["Audi",3.2,"Subaru",5,"Romeo",432.789]
print(cars)
```
```python
Output:
[]
["Audi",3.2,"Subaru",5,"Romeo",432.789]
```
###List Methods
These are built-in operations for manipulating lists. We shall explore them with examples.

| Methods | Description                          |
----------|---------------------------------     |
|append()|Adds an element at the end of the list |
|clear()|Removes all the elements from the list  |
|copy()|Returns a copy of the list               |
|count()|Returns the number of elements with the specified value
|extend()|Add the elements of a list (or any iterable), to the end of the current list|
|index()|Returns the index of the first element with the specified value|
|insert()|Adds an element at the specified position|
|pop()|Removes the element at the specified position|
|remove()|Removes the first item with the specified value|
|reverse()|Reverses the order of the list|
|sort()|Sorts the list|

Example
```python
cars = ["Audi",3.2,"Subaru",5,"Romeo",432.789]
print(cars)
# append 
cars.append("Toyota")
print(cars)
#copy
cars_1 = cars.copy()
print(cars_1)
# clear
cars_1.clear()
print(cars_1)
# count
print(cars.count("Audi"))
# Extend
fruit = ["kiwi","cherry","grapes"]
city = ["morotro","iraq","texas","qalit"]
fruit.extend(city)
print(fruit)
# index
cars = ["Audi",3.2,"Subaru",5,"Toyota","Romeo",432.789]
print(cars.index("Toyota"))
#insert
fruits = ['apple', 'banana', 'cherry']
fruits.insert(1, "orange")
print(fruits)
#pop
fruits = ['apple', 'banana', 'cherry']
fruits.pop(1)
print(fruits)
```
```python
output:
["Audi",3.2,"Subaru",5,"Romeo",432.789]
["Audi",3.2,"Subaru",5,"Romeo",432.789,"Toyota"]
["Audi",3.2,"Subaru",5,"Romeo",432.789]
[]
1
["kiwi","cherry","grapes","morotro","iraq","texas","qalit"]
4
['apple','orange','banana', 'cherry']

['apple','cherry']

```
__b.Tuples__

These are data structure that store an ordered sequence of values. Tuples are immutable. This means you cannot change the values in a tuple. Tuples are defined with parenthesis.

##NOTE
+ Tuples allow duplicate values
+ it is not necessary to enclose the tuple 
elements in parentheses
+ Tuples allow use of heterogeneous data

__Implementation__
```python
realk = ("Texas","Estonia","Monaco")
print(realk)
# duplicate values
realk1 = ("Texas","Estonia","Monaco","Texas")
print(realk1)
# No parentheses
realk = 'Texas','Estonia','Monaco'
print(realk)
# Heterogeneous data
employee=(1, 'Steve', True, 25, 12000)
print(employee)
```
```python
output:
('Texas','Estonia','Monaco')
('Texas','Estonia','Monaco','Texas')
('Texas','Estonia','Monaco')
(1, 'Steve', True, 25, 12000)

```
####Tuples Operations
Tuple is unchangeable. So, once a tuple is created, any operation that seeks to change its contents is not allowed. For instance, trying to modify or delete an element of any tuple will result in an error.

|Operator	|
----------------|
|The + operator returns a tuple containing all the elements of the first and the second tuple object.|
Example
```python	
t1=(1,2,3)
t2=(4,5,6)         
t1+t2              
(1, 2, 3, 4, 5, 6) 
t2+(7,)            
(4, 5, 6, 7)
```
|Operator	|
----------------|
|The * operator Concatenates multiple copies of the same tuple.	|
Example
```python
>>> t1=(1,2,3)
>>> t1*4                             
(1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3)
```
|Operator	|
----------------|
|The [] operator Returns the item at the given index. A negative index counts the position from the right side.	|
Example
```python
>>> t1=(1,2,3,4,5,6)     
>>> t1[3]                
4                        
>>> t1[-2]               
5
```
|Operator	|
----------------|
|The [:] operator returns the items in the range specified by two index operands separated by the : symbol.
If the first operand is omitted, the range starts from zero. If the second operand is omitted, the range goes up to the end of the tuple.	|
```python
>>> t1=(1,2,3,4,5,6) 
>>> t1[1:3]              
(2, 3)                   
>>> t1[3:]               
(4, 5, 6)                
>>> t1[:3]               
(1, 2, 3)
```
|Operator	|
----------------|
|The in operator returns true if an item exists in the given tuple.|

Example
```python	
>>> t1=(1,2,3,4,5,6) 
>>> 5 in t1
True                
>>> 10 in t1 
False
```
|Operator	|
----------------|
|The not in operator returns true if an item does not exist in the given tuple.|	

Example
```python
>>> t1=(1,2,3,4,5,6) 
>>> 4 not in t1 
False                    
>>> 10 not in t1
True
```

__c.Dictionary__

Dictionaries are used to store data values in key:value pairs.

**Characteristics of Dictionaries**
+ They are ordered:The items have a defined order, and that order will not change.
+ They are Changeable: that we can change, add or remove items after the dictionary has been created.
+ They do not allow duplicates: cannot have two items with the same key
+ The values of a dictionaries can be of any data type.

*NB: As of Python version 3.7, dictionaries are ordered. In Python 3.6 and earlier, dictionaries are unordered.*

**Dictionary methods**

|Method	|Description|
|--------|-----------|
|clear() |Removes all the elements from the dictionary|
Example
```python 
members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
members.clear()
print(members)

Output:
{}
``` 
|Method	|Description|
|--------|-----------|
|copy()|Returns a copy of the dictionary|
Example
```python 
members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
copy_members = members.copy()
print(copy_members)

Output:
{'sales':'Rhorda','Accounts':'Mustafa','Technical':'Naliaka'}
``` 
|Method	|Description|
|--------|-----------|
|fromkeys()|Returns a dictionary with the specified keys and value.Can be used to make dictionary with the same values|
Example
```python 
departmet = ("account","IT","Engineering")
members = ("Tityo")
dict_1 = dict.fromkeys(departmet,members)
print(dict_1)

Output:
{'account': 'Tityo', 'IT': 'Tityo', 'Engineering': 'Tityo'}
``` 
|Method	|Description|
|--------|-----------|
|get()|Returns the value of the specified key|
Example
```python 
members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
Acc_1 = members.get("Accounts")
print(Acc_1)

Output:
Mustafa
``` 
|Method	|Description|
|--------|-----------|
|items()|Returns a list containing a tuple for each key value pair.The view object contains the key-value pairs of the dictionary, as tuples in a list.
|
Example
```python 
members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
Acc_1 = members.items()
print(Acc_1)

Output:
dict_items([('sales', 'Rhorda'), ('Accounts', 'Mustafa'), ('Technical', 'Naliaka')])

``` 
|Method	|Description|
|--------|-----------|
|keys()|Returns a list containing the dictionary's keys.The view object contains the keys of the dictionary, as a list.|
Example
```python 
members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
Acc_1 = members.keys()
print(Acc_1)

Output:
dict_items(['sales','Accounts','Technical'])
``` 
|Method	|Description|
|--------|-----------|
|pop()|Removes the element with the specified key|
Example
```python 
members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
Remove_member = members.pop("sales")
print(Remove_member)

Output:
{'Accounts':'Mustafa','Technical':'Naliaka'}
``` 
|Method	|Description|
|--------|-----------|
|popitem()|Removes the last inserted key-value pair|
**NB:Before Python 3.7, the popitem() method removes a random item.**
Example
```python 
members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
Remove_member = members.popitem()
print(Remove_member)

Output:
{'Accounts':'Mustafa','Accounts': 'Mustafa'}
``` 
|Method	|Description|
|--------|-----------|
|setdefault()|Returns the value of the specified key. If the key does not exist: insert the key, with the specified value|
Example
```python 
members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
Remove_member = members.setdefault("sales","phagra")
print(Remove_member)
Output:
Rhorda
``` 
|Method	|Description|
|--------|-----------|
|update()|Updates the dictionary with the specified key-value pairs.The specified items can be a dictionary, or an iterable object with key value pairs.|
Example
```python 
members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
New_member = members.update({"Engineering":"phagra"})
print(New_member)
Output:
{'sales':'Rhorda','Accounts':'Mustafa','Technical':'Naliaka','Engineering':'phagra'}
``` 
|Method	|Description|
|--------|-----------|
|values()|Returns a list of all the values in the dictionary.The view object contains the values of the dictionary, as a list.The view object will reflect any changes done to the dictionary|
Example
```python 
members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
member_values = members.values()
print(member_values)
Output:
dict_values(['Rhorda','Mustafa','Naliaka'])
``` 
__d.Sets__
A set is an unordered collection of items.

__Characteristics of Sets__
+ Every set element is unique (no duplicates)
+ They must be unchangeable.
+ It is created by placing all the items (elements) inside curly braces {}, separated by comma, or by using the built-in set() function.

*Set Methods*

|Method|Description|
|------|-----------|
|add()|Adds an element to the set|

**Example**
```python
x = {"facebook", "instagram", "whatsapp"}
x.add("twitter")
print(x)

Output:
{'facebook', 'instagram', 'whatsapp','twitter'}
```

|Method|Description|
|------|-----------|
clear()|Removes all the elements from the set|

**Example**
```python
x = {"facebook", "instagram", "whatsapp"}
x.clear()
print(x)

Output:
set()
```
|Method|Description|
|------|-----------|
|copy()|Returns a copy of the set|

**Example**
```python
x = {"facebook", "instagram", "whatsapp"}
y = x.copy()
print(y)

Output:
{'facebook','instagram', 'whatsapp'}
```

|Method|Description|
|------|-----------|
|difference()|Returns a set containing the difference between two or more sets|

|Method|Description|
|------|-----------|
|difference_update()|Removes the items in this set that are also included in another, specified set|

|Method|Description|
|------|-----------|
|discard()|Remove the specified item|

|Method|Description|
|------|-----------|
|intersection()|Returns a set, that is the intersection of two other sets|

|Method|Description|
|------|-----------|
|intersection_update()|Removes the items in this set that are not present in other, specified set(s)|

|Method|Description|
|------|-----------|
|isdisjoint()|Returns whether two sets have a intersection or not|

|Method|Description|
|------|-----------|
|issubset()|Returns whether another set contains this set or not|

|Method|Description|
|------|-----------|
|issuperset()|Returns whether this set contains another set or not|


|Method|Description|
|------|-----------|
|pop()|Removes an element from the set randomly|

**Example**
```python
x = {"facebook", "instagram", "whatsapp"}
x.pop()
print(x)

Output:
{'instagram','whatsapp'}
```

|Method|Description|
|------|-----------|
|remove()|Removes the specified element|

**Example**
```python
x = {"facebook", "instagram", "whatsapp"}
x.remove("facebook")
print(x)

Output:
{'instagram','whatsapp'}
```
|Method|Description|
|------|-----------|
|symmetric_difference()|Returns a set with the symmetric differences of two sets|

**Example**
```python
x = {"facebook", "instagram", "whatsapp"}
y = {"google", "microsoft", "facebook"}

x.symmetric_difference(y)
print(x)

Output:
{'instagram','whatsapp','google','microsoft'}
```

|Method|Description|
|------|-----------|
|symmetric_difference_update()|inserts the symmetric differences from this set and another|
**Example**
```python
x = {"facebook", "instagram", "whatsapp"}
y = {"google", "microsoft", "facebook"}

x.symmetric_difference_update(y)
print(x)

Output:
{'instagram','whatsapp','google','microsoft'}
```
|Method|Description|
|------|-----------|
|union()|Return a set containing the union of sets|
*NB:You can specify as many sets you want, separated by commas.
It does not have to be a set, it can be any iterable object.
If an item is present in more than one set, the result will contain only one appearance of this item.*

**Example**
```python
x = {"facebook", "instagram", "whatsapp"}
y = {"google", "microsoft", "apple"}
w = {"google","twitch","whatsapp"}
x.union(y,w)
print(x)

Output:
{'facebook','instagram','microsoft','apple','whatsapp','google','twitch'}
```

|Method|Description|
|------|-----------|
|update()|Update the set with the union of this set and others|
*Example*
```python
x = {"facebook", "instagram", "whatsapp"}
y = {"google", "microsoft", "apple"}
x.update(y)
print(x)

Output:
{'facebook','instagram','whatsapp','google','microsoft','apple'}
```

In my next article, I will be discussing User-defined Data Structures in python. Stay tuned by following me.
Your comment is highly-valued

*RESOURCES*
+ https://www.programiz.com/python-programming/set
+ https://www.w3schools.com/python/ref_dictionary_values.asp