Learn how to obtain Twitter API credentials, interact with the Twitter API using Python, and retrieve information from public Twitter accounts, like tweets.

Using the Twitter API

Before we can interact with the Twitter API, we'll need to import the following Python packages:

* `sys` - a basic interpreter that can handle low level functions of the computer's operating system.

* `operator` - a package that allows arithmetic and comparison functions, such as comparing two strings or multiplying two numbers.

* `requests` - a package that makes it easy to make HTTP requests, so we dont have to code any HTTP interactions.

* `json` - the most widely used format for data exchange on the Internet today. This package makes it easier to work with <a href="http://www.json.org/" target="_blank">JSON</a> objects in Python.

* `twitter` - the package needed to interact with the Twitter API.

* `watson_developer_cloud` - the package needed to interact with the Personality Insights API.

These Python packages are dependencies for the `python-twitter` and `watson-developer-cloud` packages we manually installed earlier. Without them, the `python-twitter` and `watson-developer-cloud` packages won't function correctly. 

The packages will also help us directly communicate with the Twitter API and format the results we'll display to users.

Import Packages

We've done a lot of work, but we still haven't seen any data from Twitter. Let's fix that!

The `GetUserTimeline()` method returns will return data from Twitter in the form of a <a href="https://docs.python.org/2.7/tutorial/datastructures.html" target="_blank">Python list</a>, so we can use a <a href="https://www.codecademy.com/en/courses/python-beginner-en-cxMGf/1/5?curriculum_id=4f89dab3d788890003000096" target="_blank">for loop</a> to print out the tweets from the data we retrieved.

For example:

```py
statuses = twitter_api.GetUserTimeline(screen_name=handle, count=200, include_rts=False)

for status in statuses:
    print status
```

Understanding Twitter Results I 

Great! But to retrieve data from Twitter, we need to make an actual call to the API. So far, we've only created the object (`twitter_api`)that _represents_ the Twitter API we'll interact with.

To make the call, we'll do the following:

1. Create a `handle` variable (will be set to a Twitter username)
2. Call the `GetUserTimeline()` method on the `twitter_api` object we created in the last exercise and pass in the following three arguments to the method:

* Twitter handle of the celebrity
* The number of desired Tweets (`count`)
* A retweet flag (`include_rts` is set to `false` in order to avoid retrieving retweets)

3\. Create a `statuses` variable set to the code from Step 2 above

Here's an example:

```py
# This example uses Codecademy's twitter handle
handle = "@Codecademy"

statuses = twitter_api.GetUserTimeline(screen_name=handle, count=200, include_rts=False)
```

Querying Twitter II

To interact with the Twitter API, we first need to create an <a href="https://en.wikipedia.org/wiki/Instance_(computer_science" target="_blank">instance</a> of the Twitter package we imported earlier.  

We can do this by calling the `.Api()` method on the `twitter` package and setting it equal to a variable, like `twitter_api`. The function also takes the four credentials you retrieved earlier as arguments, like so: 

```py
twitter_api = twitter.Api(consumer_key=twitter_consumer_key, consumer_secret=twitter_consumer_secret, access_token_key=twitter_access_token, access_token_secret=twitter_access_secret)
```

Querying Twitter I

In this unit, we'll begin writing code for the **Celebrity Match** application.

We'll start by using the Twitter API to retrieve tweets from two different Twitter users and compare them.

Twitter is one of the most popular social media tools, which makes it easy to retrieve authored content, but you can also use other authored content, like blogs, papers, articles, and more. 

Overview

Now that we have the basic setup in our file, it's time to start retrieving some data from Twitter. 

Before we can interact with the Twitter API, we need to authenticate with the Twitter API. To do this, make sure you have your Twitter credentials handy:

1. Start by navigating to <a href="https://apps.twitter.com" target="_blank">https://apps.twitter.com</a> (make sure you are logged in to Twitter, or create an account first)
2. Click on "Create New App"
3. Fill out the "Application Details"
4. Navigate to the "Keys and Access Tokens" tab
5. Take note of your `Consumer Key (API Key)` and `Consumer Secret (API Secret)`
6. Click on "Create my access token" under "Token Actions" at the bottom of the page
7. Take note of your `Access Token` and `Access Token Secret`

Once you have the credentials, add them to the correct variables in the following lines of code:

```py
twitter_consumer_key = ''
twitter_consumer_secret = ''
twitter_access_token = ''
twitter_access_secret = ''
```

These credentials will allow us to call the Twitter API using the Twitter package we imported earlier.

Authenticating with Twitter

The data we retrieve from Twitter doesn't include just tweets, it also contains a lot of <a href="https://en.wikipedia.org/wiki/Metadata" target="_blank">metadata</a>.

Unfortunately, the metadata contains information that we won't use (i.e., when the  tweet was created, how many people "favorited" it, what hashtags were used, what other Twitter users were mentioned, what language the tweet is in, and the actual text of the tweet). 

We're really only interested in one specific piece of data: the actual _text_ of the tweets. 

We can modify our code to print only the text we need, like so: 

```py
for status in statuses:
    print status.text
```

Understanding Twitter Results II

Great! Now that we have the text we need, it's time to prepare it so that we can send it to the Personality Insights (PI) API for analysis.

First, we'll <a href="https://www.codecademy.com/en/courses/python-beginner-sRXwR/3/1?curriculum_id=4f89dab3d788890003000096" target="_blank">concatenate</a> the text into one long string and then send it off to PI be analyzed. We'll save the long string into a variable called `text`.

We also only want the tweets that are in English, so we'll need to filter by language.

**Note:** The text retrieved from Twitter is in <a href="https://en.wikipedia.org/wiki/Unicode" target="_blank">Unicode</a> format, but we need <a href="https://en.wikipedia.org/wiki/UTF-8" target="_blank">UTF-8</a> format, so we'll need to encode it. Thankfully, the `encode()` method in Python solves that problem, so we'll use that. 

Here's how the modified code looks:

```py
statuses = twitter_api.GetUserTimeline(screen_name=handle, count=200, include_rts=False)

text = ""

for status in statuses:
    if (status.lang =='en'): #English tweets
        text += status.text.encode('utf-8')
```

The code above does the following:

1. Creates an empty `text` variable we'll save tweets into
2. Filters out English tweets
3. Appends UTF-8 encoded tweets to the `text` variable using the `+=` operator