python reverse dictionary based on exist function

Question

I am trying to reverse dictionary. I have a dictionary called person_to_networks. This function works fine, but my reverse function gives me an error. It says 'function' object is not subscriptable. The text file contains person's name, networks and friends' names. Here is the text

def person_to_networks(profiles_file):
    """
    (file open for reading) -> dic of {str: list of str}

    """
    # initialize data to be processed

This is invert function :

def invert_networks_dict(person_to_networks):
     """
    (dict of {str: list of str}) -> dict of {str: list of str}
    Return a "network to people" dictionary based on the given 
    "person to networks" dictionary.

    """

I appreciate your help in advance!

Answer 1

It looks like you are passing the person_to_network() function object as an argument to the invert_networks_dict() function. You are then treating the person_to_network variable inside the local scope of the function as both a dictionary object and a callable function object.

Consequently you are raising an object not subscriptable exception, as functions are not subscriptable in Python (e.g. they do not support the __getitem__() method like dictionaries do). More on the what it means to be subscriptable here

So I expect what you want to do is assign the dictionary returned from calling the person_to_network() function into a new variable.

def invert_networks_dict(person_to_networks):
    """
    (dict of {str: list of str}) -> dict of {str: list of str}
    Return a "network to people" dictionary based on the given 
    'person to networks' dictionary.
    """

    networks_to_person = {}
    person_to_network_dict = person_to_networks(profiles_file)
    for person in person_to_network_dict:
        networks = person_to_networks_dict[person]
        # etc

Note you don't need to pass the person_to_networks() function object to the invert_networks_dict() function. If Python doesn't find a variable match in the local function scope, it looks into any enclosing functions and then the global scope to find a match.

>>> def foo():
        print "foo"

>>> def bar():
        foo()

>>> bar()
foo

More on namespaces and scoping rules here.

Answer 2

Your first error is that you use the function person_to_networks as the dictionary name as well. You should give it a different name. Currently, when it is used as an argument, python sees that it has been defined as a function and tries to use it as such. I have changed the name below from person_to_networks (which is the name of the function) to person_dict to show what needs to be done for that. In that case you would call the two functions separately and pass the resulting dictionary in to the invert function. If you want to just call the invert function, pass in the pointer to the person_to_networks() function and call it to set the dictionary value, then use the dictionary value.

Note that the way you have it makes person the dictionary and not the key from that dictionary.

Note the line that I have put the ** indicator around below. This will reset the networks_to_person[networks] value so that you wipe out the previous value. The if will then append the same value to the dictionary. Also, you should make the initial value [person] so that future values can be appended. Also you may want to check that you have not already put person in that value of networks.

def invert_networks_dict(person_to_networks):
  """
  (dict of {str: list of str}) -> dict of {str: list of str}
  Return a "network to people" dictionary based on the given 
  "person to networks" dictionary.

  """
  networks_to_person = {}
  person_dict = person_to_networks(profiles_file)
  for person in person_dict:
    networks = person_dict[person] # networks is a list of values under the person key
    # **networks_to_person[networks] = person**  # This should not be here
    for network in networks: # Now put the person under each network in networks list
      if network not in networks_to_person: #Now use each network as a key
        networks_to_person[network] = [person]
      else:
        networks_to_person[network].append(person) # Note that append needs ()

This means that every key value would have been the value [person, person] assuming you have fixed the first value to be [person] and not person.