Artikelinhalt

Wen erreichen Sie mit den Freunden und Freunden Ihrer Freunde? Diese Person und diese Person sind an einem überraschenden Ort verbunden! Da ist so etwas.

In diesem Artikel habe ich versucht, die Menschen zu visualisieren, die sich auf Twitter folgen.

Was ich getan habe

Es gibt zwei wichtige Dinge, die ich getan habe.

Informieren Sie sich über die Benutzer, denen Sie folgen
Visualisieren

Erhalten Sie Informationen zu Benutzern, denen Sie folgen

import json
import config
from requests_oauthlib import OAuth1Session
from time import sleep
from mongo_dao import MongoDAO
import datetime

# API-Schlüsseleinstellung (definiert in einer anderen Datei config.py)
CK = config.CONSUMER_KEY
CS = config.CONSUMER_SECRET
AT = config.ACCESS_TOKEN
ATS = config.ACCESS_TOKEN_SECRET

# Authentifizierungsprozess
twitter = OAuth1Session(CK, CS, AT, ATS)  

mongo = MongoDAO("db", "followers_info")

 get_friends_url = "https://api.twitter.com/1.1/friends/list.json" # Holen Sie sich das Konto, dem Sie folgen
 get_user_info_url = "https://api.twitter.com/1.1/users/show.json" # Benutzerinformationen abrufen
count = 200
targets = ['yurinaNECOPLA']
registed_list = []
 Tiefe = 2 # Tauchtiefe
 max_friends_count = 1000 # Es gibt viele Leute, die Konten folgen. Wenn es also eine bestimmte Anzahl überschreitet, wird es ausgeschlossen

# Stellen Sie fest, ob die Anzahl der Folgekonten eine bestimmte Anzahl überschreitet
def judge_friends_count(screen_name):
    params = {'screen_name': screen_name}
    while True:
        res = twitter.get(get_user_info_url, params=params)
        result_json = json.loads(res.text)
        if res.status_code == 200:
 #Die Anzahl der Personen, denen Sie folgen, ist "friends_count", die Anzahl der Personen, denen Sie folgen, ist "follers_count".
            if result_json['friends_count'] > max_friends_count:
                return False
            else:
                return True
        elif res.status_code == 429:
 # Sie können Anfragen nur 15 Mal in 15 Minuten senden. Warten Sie also, bis Sie das Limit erreicht haben
            now = datetime.datetime.now()
 print (now.strftime ("% Y /% m /% d% H:% M:% S") + 'Warte auf Verbindungslimit')
 Schlaf (15 * 60) # 15 Minuten warten
        else:
            return False

# Holen Sie sich Follower für den angegebenen Bildschirmnamen
def get_followers_info(screen_name):
    followers_info = []
    params = {'count': count,'screen_name': screen_name}
    while True:
        res = twitter.get(get_friends_url, params=params)
        result_json = json.loads(res.text)

        if res.status_code == 200 and len(result_json['users']) != 0:
                for user in result_json['users']:
 Von den von #API erhaltenen Informationen werden nur die erforderlichen Informationen im Diktatformat festgelegt (ID wird in diesem PG nicht verwendet ...)
                    followers_info.append({'screen_name': user['screen_name'], 'id': user['id']})
 Stellen Sie die folgende Erfassungsposition im Parameter # ein
                params['cursor'] = result_json['next_cursor']
 #Verarbeitung, wenn das Verbindungslimit der API überschritten wird
        elif res.status_code == 429:
            now = datetime.datetime.now()
 print (now.strftime ("% Y /% m /% d% H:% M:% S") + 'Warte auf Verbindungslimit')
 Schlaf (15 * 60) # 1 Minute warten
        else:
            break
    return followers_info

# Ruft eine Liste mit nur screen_name aus der Liste von dict ab
def followers_list(followers_info):
    followers_list = []
    for follower in followers_info:
        followers_list.append(follower['screen_name'])
    return followers_list

# Rekursive Verarbeitung
def dive_search(target_list, d):
    for name in target_list:
        if name in registed_list or not judge_friends_count(name):
            continue
        print(name)
        followers_info = get_followers_info(name)
        mongo.insert_one({'screen_name': name, 'followers_info': followers_info})
        registed_list.append(name)
        if depth > d:
            dive_search(followers_list(followers_info), d + 1)
        else:
            return
    
dive_search(targets, 0)

Entscheiden Sie in diesem Programm das Startkonto. (Ausgehend von dem Konto von Yurina Aoshima, einer Idolgruppe namens // Necopla //)

Danach wird es rekursiv gemäß dem folgenden Ablauf verarbeitet. ① Informieren Sie sich über die Benutzer, denen Sie folgen ② Registrieren Sie die Informationen von ① in mongoDB ③ Holen Sie sich die in ① erfassten Benutzerinformationen nacheinander und führen Sie sie von ① aus

Durch Ändern des Tiefenwerts können Sie ändern, wie viel Sie rekursiv tauchen.

Wenn es 2 ist, ist es ein Bild, um Freunde von Freunden zu bekommen. Ich wollte wirklich mehr Daten erhalten, aber die API zum Abrufen von Follow-bezogenen Informationen kann nur 15 Anfragen in 15 Minuten senden. Das Startkonto folgt derzeit 100 Konten, aber selbst wenn ich mit diesem Konto angefangen habe, dauerte es ungefähr 3 Stunden, um den Vorgang abzuschließen. Außerdem trat unterwegs der Fehler "Die vorhandene Verbindung wurde vom Remote-Host zwangsweise getrennt" auf, und der Vorgang schlug fehl.

Zu diesem Zeitpunkt sind nur etwa 60 der 100 Benutzerkonten, denen ich folge, abgeschlossen. Selbst wenn es funktioniert hat, hat es ungefähr 6 Stunden gedauert.

Der folgende Code wird für die Datenregistrierung bei mongoDB verwendet.

MongoDao

Visualisieren

Wie im vorherigen Abschnitt erwähnt, kann nicht gesagt werden, dass alle Daten gesammelt wurden, aber lassen Sie uns dies vorerst mit den gesammelten Daten visualisieren.

Die zur Visualisierung verwendete Bibliothek war NetworkX. Die Installation kann mit dem folgenden Befehl erfolgen.

pip install networkx

import json
import networkx as nx
import matplotlib.pyplot as plt
from requests_oauthlib import OAuth1Session
from mongo_dao import MongoDAO

mongo = MongoDAO("db", "followers_info")
start_screen_name = 'yurinaNECOPLA'

# Erstellen Sie ein neues Diagramm
G = nx.Graph()
 # Knoten hinzufügen
G.add_node(start_screen_name)

depth = 3
processed_list = []

def get_followers_list(screen_name):
    result = mongo.find(filter={"screen_name": screen_name})
    followers_list = []
    try:
        doc = result.next()
        if doc != None:
            for user in doc['followers_info']:
                followers_list.append(user['screen_name'])
        return followers_list
    except StopIteration:
        return followers_list

def dive(screen_name, d):
    if depth > 0:
        if screen_name in processed_list:
            return
        followers_list = get_followers_list(screen_name)
        for screen_name in followers_list:
            f = get_followers_list(follower)
            if start_screen_name in f:
                G.add_edge(screen_name, follower)
                processed_list.append(screen_name)
                dive(follower, d + 1)
    else:
        return

dive(start_screen_name, 0)

# Diagramm erstellen. figsize ist die Größe der Figur
plt.figure(figsize=(10, 8))
 
# Bestimmen Sie das Layout der Figur. Je kleiner der Wert von k ist, desto dichter ist die Zahl
pos = nx.spring_layout(G, k=0.8)
 
# Zeichnen von Knoten und Kanten
# _color: Geben Sie die Farbe an
# Alpha: Transparenz festlegen
nx.draw_networkx_edges(G, pos, edge_color='y')
nx.draw_networkx_nodes(G, pos, node_color='r', alpha=0.5)
 
# Knotennamen hinzufügen
nx.draw_networkx_labels(G, pos, font_size=10)
 
# Einstellung, dass die X-Achse und die Y-Achse nicht angezeigt werden
plt.axis('off')

plt.savefig("mutual_follow.png ")
# Zeichnen Sie ein Diagramm
plt.show()

Das Verfahren und die Logik zum Abrufen von Followern sind ähnlich. Es erhält rekursiv Follower und fügt Kanten hinzu, wenn Konten gefunden werden, die aufeinander folgen.

Ergebnis

Es stellte sich heraus, dass es so etwas war.

Ich verstehe den detaillierten Mechanismus der Bibliothek nicht, aber Konten mit vielen Verbindungen sind überfüllt. Dieses überfüllte Konto ist ein Idol, das zum selben Büro gehört, daher war ich mit dem Ergebnis zufrieden.

Impressionen

Das Ergebnis war sehr interessant. Da das Ausstellungslimit für Twitter-API-Anforderungen 15 / min beträgt, konnten wir die Datenmenge nicht wesentlich erhöhen. Wenn Sie Zeit finden und mehr Daten sammeln können, können Sie möglicherweise die Verbindung von Freunden von Freunden und Freunden von Freunden sehen.