I've taken a stab at converting your algorithm to my data, and this is what I arrived at. The result for the second testcase is still different

def find_partners(people, prefs_women, prefs_men):
    from collections import OrderedDict
    choices_women = OrderedDict(((key, None )for key in prefs_women))
    choices_men = OrderedDict(((key, None) for key in prefs_men))
    
    for k in choices_men:
        hub = k
        while(hub is not None):
            hub = find_woman(choices_women, choices_men, hub, prefs_women, prefs_men)
#             print(hub, choices_women)
    return choices_women, choices_men

if(__name__ == "__main__"):
    input = iter(input_str.split('\n')).__next__
    from collections import OrderedDict
    test_cases = int(input())
    for _ in range(test_cases):
        people = int(input())
        women = OrderedDict(parse_people(input, people))
        men = OrderedDict(parse_people(input, people))
        choices_women, choices_men = find_partners(people, men, women)
        
        for man, woman in choices_men.items():
            print(man, ' ', woman)

After some thinking, I've taken a stab at your algorithm, converting the list-based approach to a dict-based one

parsing people

changed the input to a lookup table:

def parse_people(input, people):
    for _ in range(people):
        person, *prefs = map(int, input().split())
        yield person, {k: i for i, k in enumerate(prefs)}

def find_partners(people, prefs_women, prefs_men):
    from collections import OrderedDict
    choices_women = OrderedDict(((key, None ) for key in prefs_women))
    choices_men = OrderedDict(((key, None) for key in prefs_men))
    
    for k in choices_men:
        hub = k
        while(hub is not None):
            hub = find_woman(choices_women, choices_men, hub, prefs_women, prefs_men)
#             print(hub, choices_women)
    return choices_women, choices_men

if(__name__ == "__main__"):
    input = iter(input_str.split('\n')).__next__
    from collections import OrderedDict
    test_cases = int(input())
    for _ in range(test_cases):
        people = int(input())
        women = OrderedDict(parse_people(input, people, 'woman', 'man'))
        men = OrderedDict(parse_people(input, people, 'man', 'woman'))
#         print('-----preferences: ', women, men)
        choices_women, choices_men = find_partners(people, women, men)
        
        for man, woman in choices_men.items():
            print(man, ' ', woman)

1   3
2   2
3   1
4   4
1   4
2   5
3   1
4   3
5   7
6   6
7   2

bughunting

Since the names of the men and women are the same, to hunt for a bug I changed the parse_people temporary to this:

def parse_people(input, people, sex1='man', sex2 = 'woman'):
    for _ in range(people):
        # person, *prefs = map(int, input().split())
        person, *prefs = input().split()
        # yield person, {k: i for i, k in enumerate(prefs)}
        yield sex1 + '_' + person, {sex2 + '_' + k: i for i, k in enumerate(prefs)}

for a more verbose output. This way I found out I had changed the order of women and men somewhere

Actual algorithm

I've taken a stab at converting your algorithm to my data, and this is what I arrived at. The result for the second testcase is still different

Find the partners

the part in your main routine, the main difference is that I work with an OrderedDict as lookup table, instead of a list, and I use None as sentinel value instead of 0

def find_partners(people, prefs_women, prefs_men):
    from collections import OrderedDict
    choices_women = OrderedDict(((key, None )for key in prefs_women))
    choices_men = OrderedDict(((key, None) for key in prefs_men))
    
    for k in choices_men:
        hub = k
        while(hub is not None):
            hub = find_woman(choices_women, choices_men, hub, prefs_women, prefs_men)
#             print(hub, choices_women)
    return choices_women, choices_men

finding the woman

Here I just tried to convert your code to the different indexing and lookup. By changing the comparison, you can omit the continue statement

def find_woman(choices_women, choices_men, index_man, prefs_women, prefs_men):
    for woman in prefs_men[index_man]:
        hub = choices_women[woman]
        if hub is None:
            choices_women[woman] = index_man
            choices_men[index_man] = woman
            return None
        elif prefs_women[woman][index_man] <= prefs_women[woman][hub]:
            choices_men[hub] = None
            choices_women[woman] = index_man
            choices_men[index_man] = woman
            return hub

combining it

if(__name__ == "__main__"):
    input = iter(input_str.split('\n')).__next__
    from collections import OrderedDict
    test_cases = int(input())
    for _ in range(test_cases):
        people = int(input())
        women = OrderedDict(parse_people(input, people))
        men = OrderedDict(parse_people(input, people))
        choices_women, choices_men = find_partners(people, men, women)
        
        for man, woman in choices_men.items():
            print(man, ' ', woman)

I adapted my earlier version slightly

NB: for Python 3.6, you can use dict instead of OrderedDict, but that is an implementation detail