Grouping connections between users in a network based on number of mutuals

Question

I have a list of tuples. Each tuple represents a person in a social network. The first item is their id or "name". The second is a dictionary; each key is another person in the network with whom they have mutual connections, and its value is how many mutuals they have together.

network = [
    (6, {3: 3, 4: 3, 7: 2, 1: 3, 11: 2}),
    (1, {7: 3, 11: 4, 6: 3, 4: 3}),
    (4, {3: 2, 6: 3, 1: 3, 11: 2, 12: 3}),
    (2, {9: 4, 8: 2, 10: 2, 5: 2}),
    (12, {3: 2, 4: 3}),
    (3, {5: 2, 8: 2, 12: 2, 4: 2, 7: 2, 6: 3}),
    (10, {2: 2, 9: 3, 8: 3, 5: 2}),
    (5, {3: 2, 8: 3, 9: 4, 10: 2, 2: 2}),
    (13, {}),
    (8, {2: 2, 9: 3, 10: 3, 3: 2, 5: 3}),
    (7, {3: 2, 6: 2, 1: 3}),
    (11, {1: 4, 6: 2, 4: 2}),
    (9, {2: 4, 8: 3, 10: 3, 5: 4}),
]

If two people have 1, 2, or 3 mutuals, they might know each other. If they have 4 mutuals, they probably know each other. I want to process this list so that I can determine who might/probably knows whom, resulting in output like this:

Name: 1
    Might know: 4, 6, 7
    Probably knows: 11
Name: 2
    Might know: 5, 8, 10
    Probably knows: 9
Name: 3
    Might know: 4, 5, 6, 7, 8, 12
    Probably knows: 
Name: 4
    Might know: 1, 3, 6, 11, 12
    Probably knows: 
Name: 5
    Might know: 2, 3, 8, 10
    Probably knows: 9
Name: 6
    Might know: 1, 3, 4, 7, 11
    Probably knows: 
Name: 7
    Might know: 1, 3, 6
    Probably knows: 
Name: 8
    Might know: 2, 3, 5, 9, 10
    Probably knows: 
Name: 9
    Might know: 8, 10
    Probably knows: 2, 5
Name: 10
    Might know: 2, 5, 8, 9
    Probably knows: 
Name: 11
    Might know: 4, 6
    Probably knows: 1
Name: 12
    Might know: 3, 4
    Probably knows: 

Here is my code I'm currently using to process it:

might = []
probably = []
for person in network:
    name = person[0]
    connections = person[1]
    for other_name, mutuals in connections.items():
        if mutuals > 3:
            probably.append(str(other_name))
        else:         
            might.append(str(other_name))

But I only end up with my two lists:

['3', '4', '7', '1', '11', '7', '6', '4', '3', '6', '1', '11', '12', '8', '10',
 '5', '3', '4', '5', '8', '12', '4', '7', '6', '2', '9', '8', '5', '3', '8',
 '10', '2', '2', '9', '10', '3', '5', '3', '6', '1', '6', '4', '8', '10']

['11', '9', '9', '1', '2', '5']

How can I associate these with the proper names?

Answer 1

Your desired output is essentially a dictionary, so it makes sense to build it as such. Each key will be a name; each value will be another dictionary, with keys 'might' and 'probably'. (Its values are both lists.)

output = {}
for name, connections in network:
    # If we've not added this name yet, create a blank entry:
    if name not in output:
        output[name] = {'probably': [], 'might': []}
    
    # Now loop through the connected people and add to the correct list:
    for other_name, mutuals in connections.items():
        if mutuals > 3:
            output[name]['probably'].append(other_name)
        else:
            output[name]['might'].append(other_name)

At this point, we can use Python's pprint function to check we're on the right track. (It's much more readable than print for nested structures like this.)

from pprint import pprint
pprint(output)

Output

{1: {'might': [7, 6, 4], 'probably': [11]},
 2: {'might': [8, 10, 5], 'probably': [9]},
 3: {'might': [5, 8, 12, 4, 7, 6], 'probably': []},
 4: {'might': [3, 6, 1, 11, 12], 'probably': []},
 5: {'might': [3, 8, 10, 2], 'probably': [9]},
 6: {'might': [3, 4, 7, 1, 11], 'probably': []},
 7: {'might': [3, 6, 1], 'probably': []},
 8: {'might': [2, 9, 10, 3, 5], 'probably': []},
 9: {'might': [8, 10], 'probably': [2, 5]},
 10: {'might': [2, 9, 8, 5], 'probably': []},
 11: {'might': [6, 4], 'probably': [1]},
 12: {'might': [3, 4], 'probably': []},
 13: {'might': [], 'probably': []}}

(Note that pprint automatically sorts the keys for display: they're not actually in that order.)

Now all we need to do is format it for display, however we please. I've left the names as integers up until this point, so that we can sort them correctly (and not have 11 end up before 2, as would happen when sorting strings). If those assignments look complicated, have a look at str.join and list comprehensions. And you may or may not know about f-strings, which are also quite handy (and don't require variables to even be strings!)

for name, contents in sorted(output.items()):
    print(f'Name: {name}')

    might = ', '.join([str(i) for i in sorted(contents['might'])])
    print(f'\tMight know: {might}')

    probably = ', '.join([str(i) for i in sorted(contents['probably'])])
    print(f'\tProbably knows: {probably}')

Output:

Name: 1
    Might know: 4, 6, 7
    Probably knows: 11
Name: 2
    Might know: 5, 8, 10
    Probably knows: 9
Name: 3
    Might know: 4, 5, 6, 7, 8, 12
    Probably knows: 
Name: 4
    Might know: 1, 3, 6, 11, 12
    Probably knows: 
Name: 5
    Might know: 2, 3, 8, 10
    Probably knows: 9
Name: 6
    Might know: 1, 3, 4, 7, 11
    Probably knows: 
Name: 7
    Might know: 1, 3, 6
    Probably knows: 
Name: 8
    Might know: 2, 3, 5, 9, 10
    Probably knows: 
Name: 9
    Might know: 8, 10
    Probably knows: 2, 5
Name: 10
    Might know: 2, 5, 8, 9
    Probably knows: 
Name: 11
    Might know: 4, 6
    Probably knows: 1
Name: 12
    Might know: 3, 4
    Probably knows: 
Name: 13
    Might know: 
    Probably knows: