You have been provided a code for creating a deck of cards: deck$\_$of$\_$cards.py

from random import shuffle as s

class Deck:

$\_$suits $=["$Diamonds$",$ "Clubs", "Hearts", "Spades"$]$

def $\_\_$init$\_\_($self$)$:

cards $=[]$

for s in self.$\_$suits: # Fill the deck with standard playing cards

for val in range$(1,14)$:

cards.append$($self$.\_$Card$($s$,$ val$))$

self.cards $=$ cards

def $\_\_$iter$\_\_($self$)$:

return self.cards.$\_\_$iter$\_\_()$

def $\_\_$str$\_\_($self$)$: #TODO Fix this to state whether or not the deck is sorted

or shuffled;

return 'A deck of $\{$self$.$size$\}$ cards'.format$($self$=$self$)$

@property # Property to get the length of the cards list

def size$($self$)$:

return len$($self$.$cards$)$

@property #TODO Implement a method to determine if the cards are sorted;

def is$\_$sorted$($self$)$:

pass

def sort$($self$)$: #TODO Implement a method to sort cards by suit and value;

pass

def shuffle$($self$)$: # Method to put cards list in random order

shuffled$\_$deck $=$ s$($self$.$cards$)$

return shuffled$\_$deck

def search$($self$)$: #TODO Implement a public search method;

card $=$ self.$\_$describe$\_$card$()$

def $\_$describe$\_$card$($self$)$: # User facing private function to create a card to

search for

print$("$What suit is the card?"$)$ # Pick a suit

prompt $=""$

i $=1$

for suit in self.$\_$suits: # Build prompt to pick suit

prompt $+=\text{'}\{\}.\{\}$

$\text{'}.$format$($i$,$ suit$)$

i $+=1$

while True:

s $=$ int$($input$($prompt$))$ # Collect user info for suit

v $=$ int$($input$("$Enter a number from $1$ to $13(1=$ Ace, $11=$ Jack, $12=$

Queen, $13=$ King$)$: $"))$ # Collect user info for value

if s in $[1,2,3,4]$ and v in $[$x for x in range$(1,14)]$:

card $=$ self.$\_$Card$($self$.\_$suits$[$s $-1],$ v$)$

print$($card$)$ #TODO Remove this; only here for debugging.

break

print$("$Invalid card, try again"$)$ # If invalid try again

return card

class $\_$Card: # Private inner class to create a Card

def $\_\_$init$\_\_($self$,$ suit, value$)$: # Need a suit and a value. Will be two

integers. $0-3$ for suit and $1-13$ for value

self.suit $=$ suit

self.value $=$ value

def $\_\_$str$\_\_($self$)$: # Print override

return $\text{'}\{$self$.$value$\_$name$\}$ of $\{$self$.$suit$\}\text{'}.$format$($self$=$self$)$

def $\_\_$eq$\_\_($self$,$ card$)$: # Equals override

if self.suit $!=$ card.suit:

return False

if self.value $!=$ card.value:

return False

return True

@property # Get proper suit name

def suit$\_$name$($self$)$:

if self.suit $==\_$suits$[0]$:

return $0$

elif self.suit $==\_$suits$[1]$:

return $1$

elif self.suit $==\_$suits$[2]$:

return $2$

elif self.suit $==\_$suits$[3]$:

return $3$

else:

raise ValueError$()$

@property # Get proper value name

def value$\_$name$($self$)$:

if self.value $==1$:

return "Ace"

elif self.value $==11$:

return "Jack"

elif self.value $==12$:

return "Queen"

elif self.value $==13$:

return "King"

else:

return self.value

if $\_\_$name$\_\_==\text{'}\_\_$main$\_\_\text{'}$: # Main method

deck $=$ Deck$()$ # Create empty Deck object

deck.shuffle$()$

deck.search$()$

In addition you have been given a few different codes for sorting elements in a list: quick$\_$sort.py$,$ bubble$\_$sort.py$,$ insert$\_$sort.py$,$ and selection$\_$sort.py$.$ What you have been

tasked to do is:

Utilize one of the above sorting algorithms to sort the cards in the deck

Both by suit and by value.

The suits should be ordered in the same order in which the deck is created $($see line $6$ of deck$\_$of$\_$cards.py$)$

Create a property that determines whether or not the deck is sorted.

Create a search method that allows a user to describe a card and will return the location $($array index$)$ of the card.

This search can easily be made to be high intelligent

What can you do to make this search a constant time look up$?$

Finish all other leftover TODO's in the code as described.