My solution with references below: Apply fuzzy matching across a dataframe column and save results in a new column

df.loc[:,'fruits_copy'] = df['fruits']

compare = pd.MultiIndex.from_product([df['fruits'],
                                      df['fruits_copy']]).to_series()

def metrics(tup):
    return pd.Series([fuzz.ratio(*tup),
                      fuzz.token_sort_ratio(*tup)],
                     ['ratio', 'token'])

compare.apply(metrics)

                       ratio  token
apple      apple         100    100
           apples         91     91
           orange         36     36
           apple tree     67     67
           oranges        33     33
           mango          20     20
apples     apple          91     91
           apples        100    100
           orange         33     33
           apple tree     62     62
           oranges        46     46
           mango          18     18
orange     apple          36     36
           apples         33     33
           orange        100    100
           apple tree     25     25
           oranges        92     92
           mango          55     55
apple tree apple          67     67
           apples         62     62
           orange         25     25
           apple tree    100    100
           oranges        24     24
           mango          13     13
oranges    apple          33     33
           apples         46     46
           orange         92     92
           apple tree     24     24
           oranges       100    100
           mango          50     50
mango      apple          20     20
           apples         18     18
           orange         55     55
           apple tree     13     13
           oranges        50     50
           mango         100    100

I would suggest reading your Excel file with pandas and pd.read_excel(), and then using fuzzywuzzy to perform your matching, for example:

import pandas as pd
from fuzzywuzzy import process, fuzz

df = pd.DataFrame([['9Com(panynAm9e00'],
        ['NikE4'],
        ['Mitrosof2']],
        columns=['Name'])

known_list = ['Microsoft','Company Name','Nike']

def find_match(x):

  match = process.extractOne(x, known_list, scorer=fuzz.partial_token_sort_ratio)[0]
  return match

df['match found'] = [find_match(row) for row in df['Name']]

Yields:

               Name   match found
0  9Com(panynAm9e00  Company Name
1             NikE4          Nike
2         Mitrosof2     Microsoft

To avoid processing each dish so many times, you can use this to process them only 1 time:

dishes = ["pizza with bacon", "pizza with extra cheese", "vegetarian pizza", "cheese and bacon pizza", "bacon with pizza"]

processedDishes = []

for dish in dishes:
    processedDishes.append(fuzz._process_and_sort(dish, True, True))

for dish1, dish2 in itertools.combinations(enumerate(processedDishes), 2):  
    if fuzz.ratio(dish1[1], dish2[1]) >= 85:
        print(dishes[dish1[0]], dishes[dish2[0]])

You can then combine this with @scnerd solution to add multiprocessing

If you know your data is all the same type, you can further optimize it:

dishes = ["pizza with bacon", "pizza with extra cheese", "vegetarian pizza", "cheese and bacon pizza", "bacon with pizza"]

processedDishes = []
matchers = []

for dish in dishes:
    if dish:
        processedDish = fuzz._process_and_sort(dish, True, True)
        processedDishes.append(processedDish)
        matchers.append(fuzz.SequenceMatcher(None, processedDish))


for dish1, dish2 in itertools.combinations(enumerate(processedDishes), 2):
    matcher = matchers[dish1[0]]
    matcher.set_seq2(dish2[1])
    ratio = int(round(100 * matcher.ratio()))

    if ratio >= 85:
        print(dishes[dish1[0]], dishes[dish2[0]])

Update: checked how these ratios are calculated, here is a more efficient answer that avoids a lot of checks between pairs:

dishes = ["pizza with bacon", "pizza with extra cheese", "vegetarian pizza", "cheese and bacon pizza", "bacon with pizza", "a"]


processedDishes = []
matchers = []

for dish in dishes:
    if dish:
        processedDish = fuzz._process_and_sort(dish, True, True)
        processedDishes.append({"processed": processedDish, "dish": dish})


processedDishes.sort(key= lambda x: len(x["processed"]))

for idx, dish in enumerate(processedDishes):
    length = len(dish["processed"])
    matcher = fuzz.SequenceMatcher(None, dish["processed"])
    for idx2 in range(idx + 1, len(processedDishes)):
        dish2 = processedDishes[idx2]
        if 2 * length / (length + len(dish2["processed"])) < 0.85: # upper bound
            break

        matcher.set_seq2(dish2["processed"])

        if matcher.quick_ratio() >= 0.85 and matcher.ratio() >= 0.85: # should also try without quick_ratio() check
            print(dish["dish"], dish2["dish"])