Count number of matching nodes in a Binary tree
I'll leave the comments on build_tree() as they stand in my other answer, and focus on your match_count() method:


Bad parameters for method? – It feels a little constructed, and special, to test for two key values. Why not one, or three, or an arbitrary number? Or a range?
Not optimal method name? – To me, it sounds a little strange with match_count. I just think of safety matches... I think I would prefer just count() (or count_matching()). Do note that when using count() we kind of hide/reimplement the default count() of Python. If your binary tree was within a class (as in my test cases) that could work nicely, but outside of classes it should probable be avoided and you should rather use the count_matching or match_count name.
Consider use of local variables – I don't oppose to using local variables like count_left and count, but in this rather simple case you could actually do:

def count(node, key1, key2):
    """Counts the number of node that matches key1 or key2 in the subtree.""" 
    if node is None:
        return 0

    return ( (node.key == key1 or node.key == key2)
             + match_count(node.left, key1, key2)
             + match_count(node.right, key1, key2) )



Use predicates to generalize method

If you look at the accepted answer of "Most pythonic way of counting matching elements in something iterable", they suggest some neat ways of handling your issue at hand. In fact your match_count() can be replaced with the itertools.quantify recipe.

def quantify(seq, pred=None):
    "Count how many times the predicate is true in the sequence"
    return sum(imap(pred, seq))


You could either use this directly, and reuse any of the order traversals, like in:

def count(node, pred=None):
    """Count how many times the predicate is true in binary tree."""
    return sum(imap(pred, inorder(node)))


Another version would be to use the predicate similar to the first count() version above:

def count(node, pred=None):
    """Count how many times the predicate is true in binary tree."""
    if node is None:
        return 0

    return (not pred or pred(node.key)) + count(node.left, pred) + count(node.right, pred)


Have added a not pred in front of the test to allow for using this method with default parameter of None in which case it ends up counting all elements in binary tree. 

This general approach opens up for counting whatever you feel like, but you need to call it slightly different. Here are some examples:

# Two variants to test against two different key values 
# Note that the lambda function will receive the node.key value
count(root, lambda x: x == 'D' or x=='E')
count(root, lambda x: x in 'DE')

# or use a designated method (accepting
def is_vowel(char):
    return char in 'AEIOU'
count(root, is_vowel)  


Complexity considerations

Time complexity of any of these implementations (including your original one) will be \$O(n)\$. Slightly different memory complexity, but neither algorithm will use much extra memory (with the exception when using a list implementation of inorder() which duplicates the binary tree into a list thusly requiring more memory).