Your code looks well-formatted, it's easy to read and to follow, and the explanation you gave matches the code exactly. Well done. :)

for item in my_list:

This statement looks strange since in the body of this for loop, you neither use item nor my_list. You can express the idea of that code more directly:

for _ in range(len(my_list)):

The variable _ is just a normal variable, and you could even access its value. By convention though, the variable _ means an unused variable.

Or, alternatively, you could express it even shorter:

while len(unsorted_list) > 0:

This wording matches the body of the loop, where you remove an element from unsorted_list in each iteration. This is good. It's still quite long though, therefore the idiomatic way to test whether a list is empty is:

while unsorted_list:

This makes your code:

def my_sort(my_list):
    unsorted_list = [*my_list]
    sorted_list = []
    while unsorted_list:
        shortest_num = inf
        for num in unsorted_list:
            if num < shortest_num:
                shortest_num = num
        unsorted_list.remove(shortest_num)
        sorted_list.append(shortest_num)
    return sorted_list

This code can be made much shorter since Python has a built-in function called min. By using it you can transform your code to:

def my_sort(my_list):
    unsorted_list = [*my_list]
    sorted_list = []
    while unsorted_list:
        shortest_num = min(unsorted_list)
        unsorted_list.remove(shortest_num)
        sorted_list.append(shortest_num)
    return sorted_list

This is already much shorter than before, and you don't need to import math.inf anymore, which is good, since it was a placeholder anyway that was not really necessary from a high-level point of view.

This is about as elegant as it gets. You should not use this sorting algorithm for sorting large data since for a list of \$n\$ elements it requires \$ n + n \cdot (\frac n2 + \frac n2 + 1) \$ steps, or a bit more compressed, it has the time complexity \$\mathcal O(n^2)\$. There are faster sorting algorithms out there. These are more complicated to implement, but once they are implemented and tested, they are as easy to use as your algorithm.