Finalize the Personality Insights results by computing the shared personality traits between the two Twitter users.

Gaining Insights

The `flatten()` function flattens the results from a user and store the results in a <a href="https://docs.python.org/2.7/tutorial/datastructures.html#dictionaries" target="_blank">dictionary</a>. The next step is to write a function that can compare two dictionaries (the user's and the celebrity's). 

To compare them we will start with one of the returned results (let's say your traits) and then compare them with celebrity's traits. Then, we'll compute the "distance" between the traits and finally create a new dictionary that stores the trait and distance. 
	
```py
def compare(dict1, dict2):
    compared_data = {}
    for keys in dict1:
        if dict1[keys] != dict2[keys]:
        		compared_data[keys]=abs(dict1[keys] - dict2[keys])
    return compared_data
```

Again, It's not important to understand exactly how the `compare()` function works. What's important is to make sure we include it as part of our application so that we can view PI results.

The compare() Function

Finally, to view the results, we'll have to sort them and then display the top 5 traits from the sorted results.

These will be the top 5 traits you share with the celebrity you selected for the application.

```py
sorted_result = sorted(compared_results.items(), key=operator.itemgetter(1))

for keys, value in sorted_result[:5]:
    print keys,
    print(user[keys]),
    print ('->'),
    print (celebrity[keys]),
    print ('->'),
    print (compared_results[keys])
```

Sorting and Outputting the Results

Congratulations! You built a fully functional, Watson-powered application that does the following:

* Queries the Twitter API
* Queries the Watson Personality Insights API
* Compares two bodies of text (tweets) from two Twitter users
* Displays the top 5 personality traits shared between the two Twitter users

In this course, you used the Personality Insights API &mdash; one of the many APIs available in the Watson Developer Cloud. Be sure to check out the additional APIs and learn about how they can serve your application's needs.

If you'd like to learn more about Bluemix, additional Watson Developer Cloud services, and view more courses and Watson use cases, please visit IBM's <a href="https://www.ibm.com/marketplace/learning-lab/us/en-us" target="_blank">Learning Lab</a>.

Conclusion

Now let's use the two functions we added earlier to format our results.

First, we'll use the `flatten()` function to flatten the JSON structure that the `analyze()` function returns, like so:

```py
#First, flatten the results from the Watson PI API
user = flatten(user_result)
celebrity = flatten(celebrity_result)
```

Then, we'll use the `compare()` function to compare the user and celebrity in order to gain insights on their personalities.

```py
#Then, compare the results of the Watson PI API by calculating the distance between traits
compared_results = compare(user,celebrity)
```

Flattening & Comparing

The `analyze()` function we just created will return the results from the Personality Insight (PI) API in <a href="http://www.json.org/" target="_blank">JSON</a> format. Whenever we use the `analyze()` function, we'll need to parse and flatten the JSON results to make use of them later.

By default, PI creates a tree structure for various categories. These categories are broken into Personality, Values, and Needs. These are then are broken into subcategories, and finally, broken into the actual traits. 

For this application, we'll compare the traits by flattening the structure and then extracting only the traits.
	
The `flatten()` function below will flatten the JSON structure that the `analyze()` function returns from PI.

```py
def flatten(orig):
    data = {}
    for c in orig['tree']['children']:
        if 'children' in c:
            for c2 in c['children']:
                if 'children' in c2:
                    for c3 in c2['children']:
                        if 'children' in c3:
                            for c4 in c3['children']:
                                if (c4['category'] == 'personality'):
                                    data[c4['id']] = c4['percentage']
                                    if 'children' not in c3:
                                        if (c3['category'] == 'personality'):
                                                data[c3['id']] = c3['percentage']
    return data
```

It's not important to understand exactly how the `flatten()` function works. What's important is to make sure we include it as part of our application so that we can properly process PI results.

The flatten() Function

Now that we have two Twitter usernames, we can use the `analyze()` function that we created earlier to retrieve some data from Twitter, like so:

```py
user_result = analyze(user_handle)
celebrity_result = analyze(celebrity_handle)
```

Analyze

With all of our functionality in place, we now need two Twitter users to compare. We'll manually enter the Twitter usernames by creating empty variables that you can fill in, like so: 

```py
user_handle = "@Codecademy"
celebrity_handle = "@IBM"
```

Twitter Handles

In this unit, we'll be adding the code that will analyze the Twitter data we retrieve from Twitter users.

At the moment, however, our **Celebrity Match** application can be tough to read or understand for other developers. Let's start by making our code easier to use (and easier to read). 