You could try this. I don't actually have Python on the machine that I on right now, so I couldn't test it. But it's a different angle than what you are taking and it's a bit shorter. Have fun! You're writing some complicated code. :)

def mini_swaps(list_one, list_two):
    # Add a running tally
    wrong_count = 0

    # Iterate over the items
    for item in list_one:
        # Index the item in both lists
        list_one_index = list_one.index(item)
        list_two_index = list_two.index(item)

        # If the item is not in the same place in both lists
        if list_two_index != list_one_index:
            # Add one to the tally
            wrong_count += 1

    # Since you're swapping these around, every swap will correct 2
    # items; so divide the count by two.
    return wrong_count / 2

P.S. Python convention is to use snake casing for everything except class names. Just FYI.

The problem with the swapping

The reason that your original swap and your commented swap in your update aren't working is because the list gets modified during the assignments.

When you write a, b = b, a it seems as if the assignments happen in parallel but really a gets assigned a value first and then b gets assigned a value.

In the following code, I'll use your lst3 example and we'll assume that we're on the 3rd iteration and k = 2

lst3 = [0, 1, 3, 2]
k = 2
lst3[k], lst3[lst3[k]] = lst3[lst3[k]], lst3[k]

At this point your code is supposed to swap the 3 and 2.

After the right side of the assignment is evaluated you can think of the code like this: (using the current value for k)

lst3[2] = 2
lst3[lst3[2]] = 3

After the first assignment the list has been modified and now looks like this [0, 1, 2, 2]

That means lst3[2] is 2 and you have lst3[2] = 3 for the second assignment.

The 2nd assignment is supposed to assign the 3 to index 3 but it ends up going into index 2 making it look like nothing happened.

As you've discovered, you need to use another variable to prevent this from happening.

is not vs. !=

In your original code you used is not which is comparing identities not values. != is the correct way to compare if values are not equal which you did use in your updated code.

A possible problem with how you are sorting.

I don't think your method of sorting is guaranteed to fully sort the list.

Consider the list [5, 4, 3, 2, 0, 1]. It takes 4 swaps as far as I can tell. Try this out on your working code. I think it's going to report 3 swaps with a final not fully sorted list of [1, 0, 2, 3, 4, 5], meaning 1 more swap was needed.

I would look into implementing an already proven sorting algorithm. You can find a list here: https://en.wikipedia.org/wiki/Sorting_algorithm

You've reframed the problem as sorting lst3 with a minimum number of swaps. I think a possible problem you're going to run into is whether or not any of the sorting algorithms guarantee a minimum number of swaps for any possible list.

You could try starting with selection sort: https://en.wikipedia.org/wiki/Selection_sort

Selection sort is inefficient for large lists but it does seem to try to minimize the number of swaps taking place.

There's an implementation of it on that page which I think is in C code but you can convert it to python code and wrap it into a function. Add a counter to it and increment it whenever a swap takes place.

I worked out selection sort for a few examples with pencil and paper and it does seem to produce the minimum number of swaps but I don't know if it always will.

Creating the list of indexes and then sorting them may be the wrong approach to take here if there's no way to prove that you'll always get the minimum number of swaps.