Accediendo a la API de Twitter con Python

    Introducción

    Una cosa que disfrutan los desarrolladores de Python es seguramente la gran cantidad de recursos desarrollados por su gran comunidad. Las interfaces de programación de aplicaciones (API) creadas por Python son algo común en los sitios web. Es difícil imaginar que cualquier servicio web popular no haya creado una biblioteca de API de Python para facilitar el acceso a sus servicios. Se pueden encontrar algunas ideas de tales API para algunos de los servicios web más populares aquí. De hecho, «envoltorio de Python» es un término más correcto que «API de Python», porque una API web normalmente proporcionaría una interfaz de programación de aplicaciones general, mientras que las bibliotecas específicas del lenguaje de programación crean código para «envolverlo» 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 API de Twitter, muestre cómo va la configuración de sus credenciales con Twitter y compare algunos envoltorios de Python según el compromiso de la comunidad. Luego, mostramos algunos ejemplos del uso de la API de Twitter para buscar tweets y crear un flujo de tweets en tiempo real sobre un tema en particular. Finalmente, exploraremos los datos guardados.

    Una 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 función podría beneficiar a las empresas al extraer 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 (todavía 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: carga y acceso a fotos, videos y GIF animados.
    • Tendencias: temas de actualidad en una ubicación determinada.
    • 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á expandiendo constantemente su gama de servicios agregando nuevas API de vez en cuando y actualizando 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, haga clic en el botón «Crear mi token de acceso»
    • Tome nota de su token de acceso y secreto de 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.

    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)
    

    Envoltorios de Python

    Python es uno de los lenguajes de programación con mayor número de desarrollos envoltorios para la API de Twitter. Por lo tanto, es difícil compararlos si no los ha usado durante algún tiempo. Posiblemente una buena forma de elegir la herramienta adecuada es profundizar en su documentación y ver las posibilidades que ofrecen y cómo encajan con las características específicas de su aplicación. En esta parte, compararemos los distintos contenedores 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 recibidos estrellas, número de observadores, madurez de la biblioteca en el período 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# observadoresMadurez
    tweepy1354732249~ 8.5 años
    Herramientas de Twitter de Python602057158~ 7 años
    python-twitter1092009148~ 5 años
    twython731461100N / A
    TwitterAPI1542449~ 4.5 años
    TwitterSearch824129~ 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 el biblioteca twython debido a sus diversas características alineadas con diferentes API de Twitter, su madurez, aunque no hay información sobre cuándo se publicó su primer lanzamiento, hay información de que la versión 2.6.0 apareció hace unos 5 años y su compatibilidad con la transmisión de tweets. En nuestro primer ejemplo usaremos el API de búsqueda para buscar tweets que contengan la cadena «aprender python», y más adelante mostraremos un ejemplo más realista usando Twitter API de transmisión.

    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ía los tweets públicos más populares de 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 el documentos de instalación.

    $ pip install twython
    

    En el siguiente paso, importaremos la clase Twython, crearemos una instancia de un objeto 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, que se pueden encontrar aquí.

    # 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 search método, que devuelve un diccionario de search_metadata y statuses – los resultados consultados. Solo miraremos el statuses parte, y guarde una parte de toda la información en un pandas marco de datos, para presentarlo en una tabla.

    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)
    

    .dataframe thead tr: hijo único th {text-align: right; }

    .dataframe thead th {
        text-align: left;
    }
    
    .dataframe tbody tr th {
        vertical-align: top;
    }

    date favorite_count text user
    1

    3

    4

    8

    2

    Fri Jan 12 21:50:03 +0000 20181372017 was the Year of Python. We set out to lea…Codecademy
    Mon Jan 08 23:01:40 +0000 2018137Step-by-Step Guide to Learn #Python for #DataS…KirkDBorne
    Mon Jan 08 11:13:02 +0000 2018109Resetter is a new tool written in Python and p…linuxfoundation
    Sat Jan 06 16:30:06 +0000 201896We’re proud to announce that this week we have…DataCamp
    Sun Jan 07 19:00:36 +0000 201894Learn programming in Python with the Python by…humble

     

    So we got some interesting tweets. Note that these are the most popular tweets containing the words «learn» and «python» in the past 7 days. To explore data back in history, you’ll need to purchase the Premium or Enterprise plan of the Search API.

     

    Streaming API

     

    While the previous example showed a one-off search, a more interesting case would be to collect a stream of tweets. This is done using the Twitter Streaming API, and Twython has an easy way to do it through the TwythonStreamer class. We’ll need to define a class MyStreamer that inherits TwythonStreamer and then override the on_success and on_error methods, as follows.

     

    The on_success method is called automatically when twitter sends us data, while the on_error whenever a problem occurs with the API (most commonly due to constraints of the Twitter APIs). The added method save_to_csv is a useful way to store tweets to file.

     

    Similar to the previous example, we won’t save all the data in a tweet, but only the fields we are interested in, such as: hashtags used, user name, user’s location, and the text of the tweet itself. There’s a lot of interesting information in a tweet, so feel free to experiment with it. Note that we’ll store the tweet location as present on the user’s profile, which might not correspond to the current or real location of the user sending the tweet. This is because only a small portion of Twitter users provide their current location – usually in the coordinates key of the tweet data.

     

    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 del MyStreamer clase con nuestras credenciales pasadas como argumentos, y usaremos el filter para recopilar solo los tweets que nos interesan. Crearemos nuestro filtro con el track argumento que proporciona las palabras clave de filtro, en nuestro caso «python». junto al track argumento, hay más posibilidades de ajustar su filtro, que se enumeran en el parámetros básicos de transmisión, como: recopilar tweets de usuarios seleccionados, idiomas, ubicaciones, etc. Las versiones pagas de la API Streaming proporcionarían muchas más opciones de filtrado.

    # 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 para alrededor de 10,000 tweets que contienen 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 respaldar. Una cosa común que se puede hacer, después de haber recopilado cuidadosamente sus tweets, es analizar los datos, donde el análisis de sentimientos 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 algunos análisis de datos básicos sobre la ubicación y los hashtags utilizados por las personas que twittean «python».

    Tenga en cuenta que el objetivo de estos ejemplos es solo mostrar para qué se podrían 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 su los tiempos de recogida fueron independientes y uniformes.

    Primero, importemos nuestros datos del archivo «Saved_tweets.csv» e imprimamos algunas filas.

    import pandas as pd
    tweets = pd.read_csv("saved_tweets.csv")
    tweets.head()
    

    .dataframe thead tr: hijo único th {text-align: right; }

    .dataframe thead th {
        text-align: left;
    }
    
    .dataframe tbody tr th {
        vertical-align: top;
    }

    hashtags text user location
    0

    1

    2

    3

    4

    [‘IBM’]RT @freschesolution: Join us TOMORROW with @OC…rbrownpaNaN
    []pylocus 1.0.1: Localization Package https://t….pypi_updates2NaN
    []humilis-push-processor 0.0.10: Humilis push ev…pypi_updates2NaN
    [‘Python’, ‘python’, ‘postgresql’]#Python Digest is out! https://t.co/LEmyR3yDMh…horstwilmesZürich
    [‘NeuralNetworks’, ‘Python’, ‘KDN’]RT @kdnuggets: A Beginners Guide to #NeuralNet…giodegasL’Aquila, ITALY

     

    What are the most common hashtags that go with our keyword «python»? Since all the data in our DataFrame are represented as strings including brackets in the hashtags column, to get a list of hashtags we’ll need to go from a list of strings, to a list of lists, to a list of hashtags. Then we’ll use the Counter class to count the hashtags entries in our list, and print a sorted list of 20 most common hashtags.

     

    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)
    
    [('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 geocode método del geopy biblioteca que devuelve las coordenadas de una ubicación de entrada determinada. Para visualizar un mapa de calor mundial de tweets, usaremos el gmplot biblioteca. Un recordatorio: nuestros pequeños datos no son un representante real del mundo.

    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 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 varias 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 seres humanos que tuitean «python». Una segunda mejora sería simplemente recopilar más datos durante períodos más largos e ininterrumpidos.

    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 alcance de trabajo. No solo las empresas, sino también las personas pueden utilizar 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 los diferentes contenedores implementan diferentes posibilidades de las API de Twitter. Por lo tanto, se debe elegir un contenedor 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éntete libre de crearlos tú mismo!

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *