Accediendo a la API de Twitter con Python

Una cosa que disfrutan los desarrolladores de Python es sin duda la gran cantidad de recursos desarrollados por su gran comunidad. Interfaces de programación de aplicaciones construidas con Python (...

Introducción

Una cosa que disfrutan los desarrolladores de Python es sin duda la gran cantidad de recursos desarrollados por su gran comunidad. Las interfaces de programación de aplicaciones (API) creadas con Python son algo común para los sitios web. Es difícil imaginar que algún servicio web popular no haya creado una biblioteca API de Python para facilitar el acceso a sus servicios. Se pueden encontrar algunas ideas de dichas API para algunos de los servicios web más populares [aquí] (http://www.pythonforbeginners.com/api/list-of-python-apis). De hecho, "envoltura de Python" es un término más correcto que "API de Python", porque una API web normalmente proporciona una interfaz de programación de aplicaciones general, mientras que las bibliotecas específicas del lenguaje de programación crean código para "envolver" en funciones fáciles de usar. De todos modos, usaremos ambos términos indistintamente a lo largo de este artículo.

En esta publicación de blog nos concentramos en la API de Twitter, mostramos cómo funciona la configuración de sus credenciales con Twitter y comparamos algunos envoltorios de Python basados ​​en la participación de la comunidad. Luego mostramos algunos ejemplos del uso de la API de Twitter para buscar tweets y crear una secuencia de tweets en tiempo real sobre un tema en particular. Finalmente, exploraremos los datos guardados.

Descripción general de la API de Twitter

Hay muchas API en la plataforma de Twitter con las que los desarrolladores de software pueden interactuar, con la máxima posibilidad de crear sistemas totalmente automatizados que interactuarán con Twitter. Si bien esta característica podría beneficiar a las empresas al obtener información de los datos de Twitter, también es adecuada para proyectos, investigación y diversión a menor escala. Estas son algunas de las API más notables proporcionadas por Twitter:

  • Tweets: búsqueda, publicación, filtrado, participación, transmisión, etc.
  • Anuncios: gestión de campañas y audiencias, analítica.
  • Mensajes directos (aún en Beta): envío y recepción, respuestas directas, mensajes de bienvenida, etc.
  • Cuentas y usuarios (Beta): gestión de cuentas, interacciones de usuarios.
  • Medios: subir y acceder a fotos, videos y GIF animados.
  • Tendencias: temas de actualidad en un lugar determinado.
  • Geo: información sobre lugares conocidos o lugares cercanos a una ubicación.

Hay muchas más posibilidades con las API de Twitter, que no están incluidas en esta lista. Twitter también está ampliando constantemente su gama de servicios al agregar nuevas API de vez en cuando y actualizar las existentes.

Obtener credenciales

Antes de utilizar la API de Twitter, primero necesita una cuenta de Twitter y haber obtenido algunas credenciales. El proceso de obtención de credenciales podría cambiar con el tiempo, pero actualmente es el siguiente:

  • Visite la página de Administración de aplicaciones en https://apps.twitter.com/ e inicie sesión con su cuenta de Twitter
  • Haga clic en el botón "Crear nueva aplicación", complete los detalles y acepte los Términos de servicio
  • Vaya a la sección "Claves y tokens de acceso" y tome nota de su clave y secreto de consumidor
  • En la misma sección haz clic en el botón "Crear mi token de acceso"
  • Tome nota de su token de acceso y secreto del token de acceso

Y eso es todo. La clave/secreto del consumidor se utiliza para autenticar la aplicación que utiliza la API de Twitter, mientras que el token/secreto de acceso autentica al usuario. Todos estos parámetros deben tratarse como contraseñas y no deben incluirse en su código como texto sin formato. Una forma adecuada es almacenarlos en un archivo JSON "twitter_credentials.json" y cargar estos valores desde su código cuando sea necesario.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
import json

# Enter your keys/secrets as strings in the following fields
credentials = {}
credentials['CONSUMER_KEY'] = ...
credentials['CONSUMER_SECRET'] = ...
credentials['ACCESS_TOKEN'] = ...
credentials['ACCESS_SECRET'] = ...

# Save the credentials object to file
with open("twitter_credentials.json", "w") as file:
    json.dump(credentials, file)

Envolturas de Python

Python es uno de los lenguajes de programación con mayor número de envoltorios desarrollados para la API de Twitter. Por lo tanto, es difícil compararlos si no los ha usado durante algún tiempo. Posiblemente, una buena manera de elegir la herramienta adecuada es profundizar en su documentación y observar las posibilidades que ofrecen y cómo encajan con las especificaciones de su aplicación. En esta parte, compararemos los diversos envoltorios de API utilizando la participación de la comunidad de Python en sus proyectos de GitHub. Algunas métricas adecuadas para la comparación serían: número de contribuyentes, número de [estrellas] recibidas(https://help.github.com/articles/about -estrellas/), número de vigilantes, madurez de la biblioteca en el intervalo de tiempo desde el primer lanzamiento, etc.

Tabla 1: Bibliotecas de Python para la API de Twitter ordenadas por número de estrellas recibidas.


Biblioteca # contribuyentes # estrellas # observadores Madurez lloriqueo 135 4732 249 ~ 8.5 años Herramientas de Python para Twitter 60 2057 158 ~ 7 years python-twitter 109 2009 148 ~ 5 años twython 73 1461 100 NA API de Twitter 15 424 49 ~ 4,5 años TwitterBúsqueda 8 241 29 ~ 4.5 años


La tabla anterior enumera algunas de las bibliotecas de Python más populares para la API de Twitter. Ahora usemos uno de ellos para buscar tweets, obtener algunos datos y explorar.

Ejemplos de Twython

Hemos seleccionado la biblioteca twython debido a sus diversas funciones alineadas con diferentes API de Twitter, su madurez, aunque no hay información sobre cuándo es la primera se publicó el lanzamiento, hay información de que la versión 2.6.0 apareció hace unos 5 años y su soporte para la transmisión de tweets. En nuestro primer ejemplo usaremos la API de búsqueda para buscar tweets que contengan la cadena "learn python", y más adelante mostraremos un ejemplo más realista utilizando la [API de transmisión] de Twitter (https://developer.twitter.com/en/docs/tweets/filter-realtime/api-reference).

API de búsqueda

En este ejemplo, crearemos una consulta para la API de búsqueda con una palabra clave de búsqueda "aprender python", que devolverá los tweets públicos más populares en los últimos 7 días. Tenga en cuenta que, dado que nuestra palabra clave se compone de dos palabras, "aprender" y "python", ambas deben aparecer en el texto del tweet y no necesariamente como una frase continua. Primero, instalemos la biblioteca. La forma más sencilla es usar pip, pero también se enumeran otras opciones en los documentos de instalación.

1
$ pip install twython

En el siguiente paso, importaremos la clase Twython, instanciaremos un objeto de ella y crearemos nuestra consulta de búsqueda. Usaremos solo cuatro argumentos en la consulta: q, result_type, count y lang, respectivamente para la palabra clave de búsqueda, el tipo, el recuento y el idioma de los resultados. Twitter también define otros argumentos para afinar la consulta de búsqueda, los cuales se pueden encontrar aquí.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
# Import the Twython class
from twython import Twython
import json

# Load credentials from json file
with open("twitter_credentials.json", "r") as file:
    creds = json.load(file)

# Instantiate an object
python_tweets = Twython(creds['CONSUMER_KEY'], creds['CONSUMER_SECRET'])

# Create our query
query = {'q': 'learn python',
        'result_type': 'popular',
        'count': 10,
        'lang': 'en',
        }

Finalmente, podemos usar nuestro objeto Twython para llamar al método search, que devuelve un diccionario de search_metadata y status: los resultados consultados. Solo veremos la parte de los estados y guardaremos una parte de toda la información en un marco de datos pandas para presentarla en una tabla.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
import pandas as pd

# Search tweets
dict_ = {'user': [], 'date': [], 'text': [], 'favorite_count': []}
for status in python_tweets.search(**query)['statuses']:
    dict_['user'].append(status['user']['screen_name'])
    dict_['date'].append(status['created_at'])
    dict_['text'].append(status['text'])
    dict_['favorite_count'].append(status['favorite_count'])

# Structure data in a pandas DataFrame for easier manipulation
df = pd.DataFrame(dict_)
df.sort_values(by='favorite_count', inplace=True, ascending=False)
df.head(5)
  date                             favorite_count   text                                                  user

1 viernes 12 de enero 21:50:03 +0000 2018 137 2017 fue el año de Python. Nos dispusimos a dejar… Codecademy 3 Mon Jan 08 23:01:40 +0000 2018 137 Guía paso a paso para aprender #Python para #DataS... KirkDborne 4 Mon Jan 08 11:13:02 +0000 2018 109 Resetter es una nueva herramienta escrita en Python y p... linuxfoundation 8 Sat Jan 06 16:30:06 +0000 2018 96 Estamos orgullosos de anunciar que esta semana tenemos... DataCamp 2 dom 07 de enero 19:00:36 +0000 2018 94 Aprende a programar en Python con Python por... humilde

Así que tenemos algunos tweets interesantes. Tenga en cuenta que estos son los tweets más populares que contienen las palabras "aprender" y "python" en los últimos 7 días. Para explorar datos en el historial, deberá comprar el plan Premium o Enterprise de la API de búsqueda.

API de transmisión

Si bien el ejemplo anterior mostró una búsqueda única, un caso más interesante sería recopilar un flujo de tweets. Esto se hace usando la API de transmisión de Twitter, y Twython tiene una manera fácil de hacerlo a través de la TwythonStreamer clase. Tendremos que definir una clase MyStreamer que herede TwythonStreamer y luego anular los métodos on_success y on_error, de la siguiente manera.

El método on_success se llama automáticamente cuando Twitter nos envía datos, mientras que on_error cada vez que ocurre un problema con la API (más comúnmente debido a restricciones de las API de Twitter). El método agregado save_to_csv es una forma útil de almacenar tweets en un archivo.

Similar al ejemplo anterior, no guardaremos todos los datos en un tweet, sino solo los campos que nos interesan, como: hashtags utilizados, nombre de usuario, ubicación del usuario y el texto del tweet en sí. . Hay mucha información interesante en un tweet, así que siéntete libre de experimentar con ella. Tenga en cuenta que almacenaremos la ubicación del tweet como presente en el perfil del usuario, que podría no corresponder a la ubicación actual o real del usuario que envía el tweet. Esto se debe a que solo una pequeña parte de los usuarios de Twitter proporciona su ubicación actual, generalmente en la clave de “coordenadas” de los datos del tweet.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
from twython import TwythonStreamer
import csv

# Filter out unwanted data
def process_tweet(tweet):
    d = {}
    d['hashtags'] = [hashtag['text'] for hashtag in tweet['entities']['hashtags']]
    d['text'] = tweet['text']
    d['user'] = tweet['user']['screen_name']
    d['user_loc'] = tweet['user']['location']
    return d
    
    
# Create a class that inherits TwythonStreamer
class MyStreamer(TwythonStreamer):     

    # Received data
    def on_success(self, data):

        # Only collect tweets in English
        if data['lang'] == 'en':
            tweet_data = process_tweet(data)
            self.save_to_csv(tweet_data)

    # Problem with the API
    def on_error(self, status_code, data):
        print(status_code, data)
        self.disconnect()
        
    # Save each tweet to csv file
    def save_to_csv(self, tweet):
        with open(r'saved_tweets.csv', 'a') as file:
            writer = csv.writer(file)
            writer.writerow(list(tweet.values()))

Lo siguiente que debe hacer es crear una instancia de un objeto de la clase MyStreamer con nuestras credenciales pasadas como argumentos, y usaremos el método filter para recopilar solo los tweets que nos interesan. Crearemos nuestro filter con el argumento track que proporciona las palabras clave de filtro, en nuestro caso "python". Además del argumento pista, hay más posibilidades para afinar el filtro, enumeradas en los [parámetros básicos de transmisión](https://developer.twitter.com/en/docs/tweets/filter-realtime/guides/ basic-stream-parameters), tales como: recopilar tweets de usuarios seleccionados, idiomas, ubicaciones, etc. Las versiones pagas de Streaming API proporcionarían muchas más opciones de filtrado.

1
2
3
4
5
# Instantiate from our streaming class
stream = MyStreamer(creds['CONSUMER_KEY'], creds['CONSUMER_SECRET'], 
                    creds['ACCESS_TOKEN'], creds['ACCESS_SECRET'])
# Start the stream
stream.statuses.filter(track='python')

Con el código anterior, recopilamos datos de alrededor de 10 000 tweets que contenían la palabra clave "python". En la siguiente parte, haremos un breve análisis de los hashtags incluidos y las ubicaciones de los usuarios.

Breve análisis de datos

La API de Twitter es algo poderoso, muy adecuado para investigar la opinión pública, análisis de mercado, acceso rápido a noticias y otros casos de uso que su creatividad puede soportar. Después de recopilar cuidadosamente los tweets, algo común es analizar los datos, donde el análisis de opinión juega un papel crucial en la extracción sistemática de información subjetiva del texto. De todos modos, el análisis de sentimientos es un campo enorme que debe abordarse en una pequeña parte de una publicación de blog, por lo que en esta parte solo haremos un análisis de datos básicos con respecto a la ubicación y los hashtags utilizados por las personas que tuitean "python".

Tenga en cuenta que el objetivo de estos ejemplos es solo mostrar para qué se pueden usar los datos de la API de Twitter: nuestra pequeña muestra de tweets no debe usarse para inferir conclusiones, porque no es un buen representante de toda la población de tweets. , ni sus tiempos de recolección eran independientes y uniformes.

Primero, importemos nuestros datos del archivo "saved_tweets.csv" e imprimamos algunas filas.

1
2
3
import pandas as pd
tweets = pd.read_csv("saved_tweets.csv")
tweets.head()
  hashtags                                      text                                                   user            location

0 ['IBM'] RT @freschesolution: Únase a nosotros MAÑANA con @OC... rbrownpa NaN 1 [] pylocus 1.0.1: Paquete de localización https://t.… pypi_updates2 NaN 2 [] low-push-processor 0.0.10: Low push ev... pypi_updates2 NaN 3 ['Python', 'python', 'postgresql'] ¡#Python Digest está disponible! https://t.co/LEmyR3yDMh... horstwilmes Zúrich 4 ['NeuralNetworks', 'Python', 'KDN'] RT @kdnuggets: Una guía para principiantes de #NeuralNet... giodegas L'Aquila, ITALIA

¿Cuáles son los hashtags más comunes que van con nuestra palabra clave "python"? Dado que todos los datos en nuestro DataFrame se representan como cadenas que incluyen corchetes en la columna hashtags, para obtener una lista de hashtags, debemos pasar de una lista de cadenas a una lista de listas y a una lista de hashtags. . Luego, usaremos la clase Contador para contar las entradas de hashtags en nuestra lista e imprimiremos una lista ordenada de los 20 hashtags más comunes.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from collections import Counter
import ast

tweets = pd.read_csv("saved_tweets.csv")

# Extract hashtags and put them in a list
list_hashtag_strings = [entry for entry in tweets.hashtags]
list_hashtag_lists = ast.literal_eval(','.join(list_hashtag_strings))
hashtag_list = [ht.lower() for list_ in list_hashtag_lists for ht in list_]

# Count most common hashtags
counter_hashtags = Counter(hashtag_list)
counter_hashtags.most_common(20)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
[('python', 1337),
 ('datascience', 218),
 ('bigdata', 140),
 ('machinelearning', 128),
 ('deeplearning', 107),
 ('django', 93),
 ('java', 76),
 ('ai', 76),
 ('coding', 68),
 ('100daysofcode', 65),
 ('javascript', 64),
 ('iot', 58),
 ('rstats', 52),
 ('business', 52),
 ('tech', 48),
 ('ruby', 45),
 ('programming', 43),
 ('cybersecurity', 43),
 ('angularjs', 41),
 ('pythonbot_', 41)]

A continuación, podemos usar la ubicación del usuario para responder: ¿qué áreas del mundo tuitean más sobre "python"? Para este paso, usaremos el método geocode de la biblioteca geopía que devuelve las coordenadas de una ubicación de entrada determinada. Para visualizar un mapa de calor mundial de tweets, usaremos la biblioteca gmplot. Un recordatorio: nuestros pequeños datos no son un verdadero representante del mundo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
from geopy.geocoders import Nominatim
import gmplot

geolocator = Nominatim()

# Go through all tweets and add locations to 'coordinates' dictionary
coordinates = {'latitude': [], 'longitude': []}
for count, user_loc in enumerate(tweets.location):
    try:
        location = geolocator.geocode(user_loc)
        
        # If coordinates are found for location
        if location:
            coordinates['latitude'].append(location.latitude)
            coordinates['longitude'].append(location.longitude)
            
    # If too many connection requests
    except:
        pass
    
# Instantiate and center a GoogleMapPlotter object to show our map
gmap = gmplot.GoogleMapPlotter(30, 0, 3)

# Insert points on the map passing a list of latitudes and longitudes
gmap.heatmap(coordinates['latitude'], coordinates['longitude'], radius=20)

# Save the map to html file
gmap.draw("python_heatmap.html")

El código anterior produjo el mapa de calor en la siguiente figura, que muestra una mayor actividad en los tweets "python" en EE. UU., Reino Unido, Nigeria e India. Una desventaja del enfoque descrito es que no hicimos ninguna limpieza de datos; resultó que había muchos tweets generados por máquinas provenientes de una sola ubicación, o múltiples ubicaciones que producían un mismo tweet. Por supuesto, estas muestras deben descartarse para obtener una imagen más realista de la distribución geográfica de los humanos que tuitean "python". Una segunda mejora sería simplemente recopilar más datos durante períodos más largos e ininterrumpidos.

Tweet mapa de calor{.img-responsive}

Recursos

¿Quiere obtener más información sobre el uso de Python para acceder a la API de Twitter? Intente consultar un curso como Byte-Sized-Chunks: análisis de sentimiento de Twitter en Python para profundizar en utilizando la API de Twitter para proyectos de ciencia de datos con Python.

Conclusiones

En esta publicación de blog, presentamos una parte bastante modesta de la API de Twitter. En general, Twitter es una herramienta muy poderosa para comprender la opinión pública, realizar investigaciones y análisis de mercado y, por lo tanto, sus API son una excelente manera para que las empresas creen herramientas automatizadas para obtener información relacionada con su ámbito de trabajo. No solo las empresas, sino también las personas pueden usar las API para crear aplicaciones creativas.

También enumeramos algunos de los contenedores de Python más populares, pero es importante tener en cuenta que diferentes contenedores implementan diferentes posibilidades de las API de Twitter. Por lo tanto, uno debe elegir un envoltorio de Python de acuerdo con su propósito. Los dos ejemplos que mostramos con las API de búsqueda y transmisión describieron brevemente el proceso de recopilación de tweets y algunas de las posibles ideas que podrían extraer. ¡Siéntase libre de crear uno usted mismo!

Referencias