Data_structures_PythonApplication.py

#Lists and Multidimensional Lists

#list

lot = ['Iphone','Airpods','Macbook','Ipad']
print(lot[0])
print(lot[1])
print(lot[2])
print(lot[3])

lot.append("Ipod") # adds item to end of the list
lot.insert(2,"Apple Watch") # adds item to specific position in the list forcing other items to shift to the right
lot.pop(1) # removes item in postion 1
lot.remove('Ipad') # removes a specific item without needing to know its postion
print(lot.count('Iphone')) # Returns how many instances of 'Iphone there are in the list
print(lot.index('Macbook')) # returns the position of Macbook
print(lot)

new_lot = lot.copy() # Makes a copy of the whole list
print(f"new_lot: ",new_lot)
lot.reverse() # reverses the order of items in the list
print(lot)
lot.sort() # sorts each item alphabetically 
print(lot)

tech = ['Speaker','TV','Console']
lot.extend(tech) # extends the lot list by adding on the tech list to the end
print(lot)

lot.clear() # gets rid of every item in the list
print(lot)


print()
#-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
print("----------------------------------------------------------------------------------------------------------------------")
print("2D List")
# 2D List
# Multidimensional lists are like lists inside lists 
# To access a 2D list you need two indices (row and spot)
#[row][spot]
lot_2d =  [ ['GT86','Vanquish','Roma'],# row 0
                ['Urus','DB11'] ]#row 1

print(lot_2d) # prints whole list 
print()

print(lot_2d[1])# prints row 1 of whole list only
print()

print(lot_2d[0][0])
print(lot_2d[0][1])
print(lot_2d[0][2])
print(lot_2d[1][0])
print(lot_2d[1][1])

print()
#-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
print("----------------------------------------------------------------------------------------------------------------------")
#rows & columns 
# can format 2d list in different ways
#[row][column]
print("2D list: Rows & Columns")
row_column = [    #col 0          col 1
                 ['X5'         ,'Phantom'], # row 0
                 ['Adventador', 'Shelby' ], # row 1
                 ['Roadster',    'G-Wagon'],# row 2
                 ['Veyron',      'Charger'],# row 3
                 ['GR86']                   # row 4
              ] 


print(row_column) # prints list by rows
print()
for car in row_column: # prints list by collumns 
    print(car)

print()

print(row_column[0][0])#row,col
print(row_column[1][0])#row,col
print(row_column[2][0])#row,col
print(row_column[3][0])#row,col
print(row_column[4][0])#row,col
print(row_column[0][1])#row,col
print(row_column[1][1])#row,col
print(row_column[2][1])#row,col
print(row_column[3][1])#row,col


print()
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
print("----------------------------------------------------------------------------------------------------------------------")
# 3D List
# To access an item in a 3d list you need 3 indices(floor,row and spot)
# [floor][row][spot]
print("3D List")
lot_3d =[              
       # floor 0
           [                #row 0                       #row 1
               ['X5','Phantom','Veyron','GR86'], ['Supra','350Z','Vantage']
           ], 
       # floor 1
           [                #row 0                       #row 1
               ['Adventador','Shelby','Charger'], ['911','Skyline']
           ],
        # floor 2
           [              #row 0                    #row 1
               ['Roadster','G-Wagon'],             ['GTR']
           ] 
           
                                                       ]  


print("      ------------------------------------------------")
print(f"      |{lot_3d[2][0][0]},{lot_3d[2][0][1]}         |{lot_3d[2][1][0]}                 | Floor 2")
print("      ------------------------------------------------")
print(f"      |{lot_3d[1][0][0]},{lot_3d[1][0][1]},{lot_3d[1][0][2]}|{lot_3d[1][1][0]},{lot_3d[1][1][1]}         | Floor 1")
print("      ------------------------------------------------")
print(f"      |{lot_3d[0][0][0]},{lot_3d[0][0][1]},{lot_3d[0][0][2]},{lot_3d[0][0][3]}   |{lot_3d[0][1][0]},{lot_3d[0][1][1]},{lot_3d[0][1][2]}  | Floor 0")
print("      ------------------------------------------------")
print("      |   Row 0                 |   Row 1            |")
print("      ------------------------------------------------")

print()

# iterates through each floor and all the rows to print eacch car
for floor in lot_3d: # in each floor
    for row in floor: # in each row on every floor
        for car in row: # for each car in each row on each floor
            print(car)
     
print()
#-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
print("--------------------------------------------------------------------------------------------------------------------")

# Tuples
# A tuple is an immutable sequence of ordered objects
# a tuple cannot be changed
# better for simplicity
print("Tuple")

my_tuple = ('a','b','c',1,2,3)
print(my_tuple)
print(my_tuple[2])
# my_tuple[2] = 'd' will cause error as tuples cannot be changed
print(my_tuple.index(2)) # returns position of 2 in the tuple
# cannot be modifed so has limmited methods

print()
#-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
print("--------------------------------------------------------------------------------------------------------------------")

# Queues 
# Queues have a fifo structure (first in, first out)
# As queues are a dynamic data structure which stores data in the heap/ memory by default the queue would have infinite space 
# or until computer memory is full


print("Python Queues")
from email.encoders import encode_quopri
from os import name
import queue
from traceback import print_tb #as queues are not a standard data type it has to be imported
q = queue.Queue(maxsize=6) # the queue is limited to holding 6 items

print(q.empty()) # checks if queue is empty and returns true
print(q.full()) # checks uf queue is full and returns true 
q.put('bag1')
print(q.get())# gets the item at the front of the queue, if queue is empty nothing happens
print(q.empty()) # will return true as the item left the queue when it was returned
q.put('bag2')
q.put('bag3')
q.put('bag4')
q.put('bag5')
print(q.qsize())

q.maxsize == 6

print(q.get()) # will return bag2 since it was added first
q.put('bag6')
q.put('bag7')
q.put('bag8')

print(q.qsize())
print(q.full())

print()

#----------------------------------------------------------------------------------------------------------------------------------------------------------
print("--------------------------------------------------------------------------------------------------------------------")
#Manual Queues
# As python doesn't have arrays queues can be manually made using lists

print(" Manual Queues")
manual_queue = [1,2,3]

print(manual_queue)
print()

def enqueue(item):
    
    if len(manual_queue) < 6:
        manual_queue.append(item)
        print("Joining: ",item)
        print(manual_queue)
        
        
    else:
        print("queue full")
 



def dequeue():

       if len(manual_queue) > 0:
         exiting = manual_queue.pop(0)
         print("Leaving: ",exiting)
         print(manual_queue)

       else:
        print("Queue Empty")


for i in range(4,7): # updates the queue 6 times so every time an item leaves another joins 
    dequeue()
    enqueue(i)
    


#----------------------------------------------------------------------------------------------------------------------------------------------------------
print("--------------------------------------------------------------------------------------------------------------------")
# Circular Queues 
# A queue connects the last position with the first position, 
# It reuses empty space 

front = -1 # starts at - 1 as 0 is a position in a list
rear = -1
length = 6
circularqueue = [None] * length

print("Circular Queues")
print(circularqueue)
print()

count = 0 
def circ_enqueue(front, rear, length, item):
    global count

    if isfull(): # checks if its full before adding any items
     print("Queue Full")
     print()
        
    else: 
      
       if rear == -1:     # starts front and rear at 0 when item is ready to join
            rear = 0
            front = 0
            circularqueue[rear] = item # adds item to the queue where the rear pointer is
            count += 1
            print("Joining:", item)
       else:
            rear = (rear + 1) % length # moves rear pointer forward using modulus 
            circularqueue[rear] = item
            count += 1 # to count how many times items are added 
            print("Joining:", item)
            
            

       print(circularqueue)  

    return front, rear # returns the position of front and rear every time


def circ_dequeue(front, rear, length):
    global count
    
    if isempty(): # checks if queue is empty before removing anything 
      print(" Queue Empty")
      print()
     
    else:    
     print("Leaving:", circularqueue[front])
     circularqueue[front] = None
     count -= 1 # count goes down each time item leaves queue
     front = (front + 1) % length # moves the front pointer forward

     print(circularqueue)

    return front, rear

def isempty(): # if count is 0, no items added 
   if count == 0:
    return True
  

def isfull(): # when count is the same as length queue is full
    if count == length:
        return True


for i in range(1,8): # a loop to add 6 items to the queue + 1 to add to a full queue 
    front, rear = circ_enqueue(front, rear, length, i) 

for i in range(1,8): # a loop to remove 6 items from the queue + 1 to remove from an empty queue 
    front, rear = circ_dequeue(front, rear, length)


#----------------------------------------------------------------------------------------------------------------------------------------------------------
print("--------------------------------------------------------------------------------------------------------------------")
# Sets
# Sets are unordered data structures with unqiue elements
print("Sets")

uni = set(['Bill','Katy','Verne','Dillon',
           'Bruce','Olivia','Richard','Jim'])

print(uni)
print(len(uni))

coworker = set(['Aaron','Bill','Brandon','David',
                'Frank','Connie','Kyle','Olivia'])

print(coworker)
print(len(coworker))

family = set(['Garry','Landon','Larry','Mark',
              'Olivia','Katy','Rae','Tom'])

print(family)
print(len(family))

friends = uni.union(coworker,family)
print(friends)
print(len(friends)) # returns the total number of people in the union of the 3 sets minus any duplicates

print(uni.intersection(coworker,family)) # returns the elements that are in all 3 sets

print()
#print(friends)
invite = friends.difference(family) # creates a new set excluding everyone from the family set
print(invite)

print()
invite = invite.symmetric_difference(uni) # Returns a set containing elements that are in either invite or uni, but not in both.

print(invite)

print()
print("Verne" in family) # returns True if element is in the set otherwise returns False

family.add("Verne")
print(family)
family.add("Olivia") # Nothing will change within the set when adding an element that is already in the set, as sets can't have duplicates
print(family)
family.pop() # removes first element
print(family)
#family.remove("Mark")
print(family)

print()
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b", "a"}

z = x.issubset(y) # if all items in set x are in set y, return True

print(z) 

#----------------------------------------------------------------------------------------------------------------------------------------------------------
print("--------------------------------------------------------------------------------------------------------------------")
# Dictionaries
# A dctionary stores data as key-value pairs
# Python uses a hash function on keys to calculate an index for storing and retrieving values

print("Dictionaries")

                #Keys   # Values
name_number = {'Aaron' : 5556069,
               'Bill'  : 5559824,
               'Dad'   : 5552603,
               'David' : 5558331,
               'Dillon': 5553538,
               'Jim'   : 5555547,
               'Mum'   : 5552603,
               'Olivia': 5556397,
               'Verne' : 5555309}

print(name_number['Bill']) 
print(hash('Bill')) # shows how python stores it

name_number['Amanda'] = 5551212 # adds to dictionary
print(name_number['Amanda'])

#name_number['David'] = 5550902 # overites existing David key as Dictionaries cannot have duplicate keys
#name_number['David'] = (5558331,5550902) # allows the David key to hold more than one value
#name_number['David (Amanda)' = 5550902] # now you can differentiate between the 2 David keys

def duplicate_key(newKey): # To avoid duplicate keys
    if newKey in name_number:
        newKey = input(f"{newKey} already exists, please enter a new name:  ") # lets user change name
        name_number[newKey] = 5550902
    else:
        name_number[newKey] = 5550902
    print()
    print(name_number)

# The Order of key-value pairs is based on their insertion order
def  caller_id(lookup_number): # finding Keys using Values
    for name, number in name_number.items():
        if number == lookup_number:
            print(f"{name = }, {number = } ")
            # return                             # if you only want to find the first value 
        
#duplicate_key("Aaron")
#caller_id(5552603)