Thing to keep in mind:
The logical or could be used to implement the suggestion algorithm very compactly. Alternately, if/elif/else constructs could be used.
Step 2: Create a 'best_words' dictionary where the 'key' is a suggestion and the 'value' is the probability of that word in your vocabulary. If the word is not in the vocabulary, assign it a probability of 0.
Step 3: Select the n best suggestions. There may be fewer than n.

To Do:
Complete the function get_corrections to 100% pass test one, giving exactly what it wants(not more, not less):
# UNIT TEST COMMENT: Candidate for Table Driven Tests
# UNQ_C10 GRADED FUNCTION: get_corrections
def get_corrections(word, probs, vocab, n=2, verbose = False):
    '''
    Input: 
        word: a user entered string to check for suggestions
        probs: a dictionary that maps each word to its probability in the corpus
        vocab: a set containing all the vocabulary
        n: number of possible word corrections you want returned in the dictionary
    Output: 
        n_best: a list of tuples with the most probable n corrected words and their probabilities.
    '''
    
    suggestions = []
    n_best = []
    
    ### START CODE HERE ###
    #Step 1: create suggestions as described above    
    suggestions = None
                    
    #Step 2: determine probability of suggestions
    
    #Step 3: Get all your best words and return the most probable top n_suggested words as n_best
    
    n_best = None
    
    ### END CODE HERE ###
    
    if verbose: print("entered word = ", word, "\nsuggestions = ", suggestions)

    return n_best


Test 1:
# Test your implementation - feel free to try other words in my word
my_word = 'dys' 
tmp_corrections = get_corrections(my_word, probs, vocab, 2, verbose=True) # keep verbose=True
for i, word_prob in enumerate(tmp_corrections):
    print(f"word {i}: {word_prob[0]}, probability {word_prob[1]:.6f}")

# CODE REVIEW COMMENT: using "tmp_corrections" insteads of "cors". "cors" is not defined
print(f"data type of corrections {type(tmp_corrections)}")


Expected Output of Test 1:
Note: This expected output is for my_word = 'dys'. Also, keep verbose=True
entered word =  dys 
suggestions =  {'days', 'dye'}
word 0: days, probability 0.000410
word 1: dye, probability 0.000019
data type of corrections <class 'list'>

Helper functions available:
# UNIT TEST COMMENT: Candidate for Table Driven Tests
# UNQ_C8 GRADED FUNCTION: edit_one_letter
def edit_one_letter(word, allow_switches = True):
    """
    Input:
        word: the string/word for which we will generate all possible wordsthat are one edit away.
    Output:
        edit_one_set: a set of words with one possible edit. Please return a set. and not a list.
    """
    
    edit_one_set = set()
    
    alphabet = 'abcdefghijklmnopqrstuvwxyz'  
    
    # 1. Substitution
    for i in range(len(word)):
        for letter in alphabet:
            if letter != word[i]:  # Avoid substituting with the same letter
                new_word = word[:i] + letter + word[i + 1:]
                edit_one_set.add(new_word)
    
    # 2. Insertion
    for i in range(len(word) + 1):
        for letter in alphabet:
            new_word = word[:i] + letter + word[i:]
            edit_one_set.add(new_word)
    
    # 3. Deletion
    for i in range(len(word)):
        new_word = word[:i] + word[i + 1:]
        edit_one_set.add(new_word)
    
    # 4. Switching (if allowed)
    if allow_switches:
        for i in range(len(word) - 1):
            # Swap characters at positions i and i+1
            new_word = word[:i] + word[i + 1] + word[i] + word[i + 2:]
            edit_one_set.add(new_word)
    
    # return this as a set and not a list
    return set(edit_one_set)

# UNIT TEST COMMENT: Candidate for Table Driven Tests
# UNQ_C9 GRADED FUNCTION: edit_two_letters
def edit_two_letters(word, allow_switches=True):
    '''
    Input:
        word: the input string/word 
    Output:
        edit_two_set: a set of strings with all possible two edits
    '''
    
    edit_two_set = set()
    
    # Include the original word (zero edits)
    edit_two_set.add(word)
    
    # Generate all one-edit-away words
    one_edits = edit_one_letter(word, allow_switches=allow_switches)
    edit_two_set.update(one_edits)
    
    # Generate all two-edits-away words
    for e1 in one_edits:
        two_edits = edit_one_letter(e1, allow_switches=allow_switches)
        edit_two_set.update(two_edits)
    
    # Return the set containing words zero, one, or two edits away
    return edit_two_set