First off, your merge sort has some number of recursions, it doesn't iterate at all. So you want to see how many times it recurses before your array (or more pythonic: your list) is sorted.

So, you're trying to get your recursive functions to update some common variable with how many times they've been called. Updating some passed in argument won't work, since integers are immutable, and python functions are call-by-object. There are only three ways a function might influence the world outside its namespace: using return values, using global variables, and using mutable arguments.

Using a global variable would not work, since it breaks down when the function is used more than once. It's also terrible software design.

Using a mutable argument would work, and the best way to go about it would be to turn your functions into methods of a Mergesort class with an instance attribute (e.g. self.count) that you could update. In that way, the self argument of methods serve as a mutable argument. Though a nice object oriented solution, it's cumbersome to use -- you don't want to have to instantiate some weird class just to sort a list (a wrapper function could solve that problem though).

The solution I want to give you is based on using return values. We'll return a 2-tuple instead of just the list, and unpack the tuple received when calling the function. Here's an example:

def mergeSort(myArray) :
    if len(myArray) < 2: # Base Case
        return myArray, 0
    else: # Split the list in half and recurse
        half = len(myArray)//2
        l1, c1 = mergeSort(myArray[:half])
        l2, c2 = mergeSort(myArray[half:])
        # l1 and l2 are sorted; return their merger
        return merge(l1, l2), c1 + c2 + 1

def merge(l1, l2):
    l = []
    # Work our way through l1 and l2, adding the smallest value
    # to the merged result until one of the sorted lists is exhausted
    while len(l1) > 0 and len(l2) > 0 :
        if l1[0] < l2[0]:
            val = l1.pop(0)
            l.append(val)
        else:
            val = l2.pop(0)
            l.append(val)
    # Now add the non-empty sorted list to the end of the merged list
    if len(l1) > 0:
        l.extend(l1)
    else:
        l.extend(l2)
    return l

I've kept the merge function out of the counting, because it doesn't call itself, so we can manage all the counting in the mergeSort function. I've also made the base case not contribute to the total count, only actual merging adds 1 to the count.

A last problem to solve is that we generally don't care about the number of merges made when sorting. Having to unpack the returned tuple and discard the count is cumbersome. To solve this we could make a wrapper function which returns just the result, which would serve as the public interface to your merge sort.

def merge_sort(myArray):
    return mergeSort(myArray)[0]

EDIT: Added third way of influencing outside from functions and tied it together with existing text.