[Python] J'ai essayé de visualiser la relation de suivi de Twitter
Contenu de l'article
Qui allez-vous atteindre avec les amis et amis de vos amis? Cette personne et cette personne sont connectées dans un lieu surprenant! Il y a quelque chose comme ça.
Dans cet article, j'ai essayé de visualiser les personnes qui se suivent sur Twitter.
Ce que j'ai fait
J'ai fait deux choses principales.
- Obtenez des informations sur les utilisateurs que vous suivez --Visualiser
Obtenez des informations sur les utilisateurs que vous suivez
import json
import config
from requests_oauthlib import OAuth1Session
from time import sleep
from mongo_dao import MongoDAO
import datetime
# Paramètre de clé API (défini dans un autre fichier config.py)
CK = config.CONSUMER_KEY
CS = config.CONSUMER_SECRET
AT = config.ACCESS_TOKEN
ATS = config.ACCESS_TOKEN_SECRET
# Processus d'authentification
twitter = OAuth1Session(CK, CS, AT, ATS)
mongo = MongoDAO("db", "followers_info")
get_friends_url = "https://api.twitter.com/1.1/friends/list.json" # Obtenez le compte que vous suivez
get_user_info_url = "https://api.twitter.com/1.1/users/show.json" # Obtenir des informations sur l'utilisateur
count = 200
targets = ['yurinaNECOPLA']
registed_list = []
profondeur = 2 # Profondeur de la plongée
max_friends_count = 1000 # Il y a beaucoup de gens qui suivent des comptes, donc s'il dépasse un certain nombre, il sera exclu
# Déterminer si le nombre de comptes suivis dépasse un certain nombre
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:
#Le nombre de personnes que vous suivez est "friends_count", le nombre de personnes que vous suivez est "followers_count"
if result_json['friends_count'] > max_friends_count:
return False
else:
return True
elif res.status_code == 429:
# Vous ne pouvez envoyer des demandes que 15 fois en 15 minutes, alors attendez si vous atteignez la limite
now = datetime.datetime.now()
print (now.strftime ("% Y /% m /% d% H:% M:% S") + 'attendre la limite de connexion')
dormir (15 * 60) # attendre 15 minutes
else:
return False
# Obtenir des abonnés pour le nom_écran spécifié
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']:
Parmi les informations obtenues à partir de #API, seules les informations nécessaires sont définies au format dict (id n'est pas utilisé dans cette PG ...)
followers_info.append({'screen_name': user['screen_name'], 'id': user['id']})
Définissez la position d'acquisition suivante dans le paramètre #
params['cursor'] = result_json['next_cursor']
#Processing lorsque la limite de connexion de l'API est dépassée
elif res.status_code == 429:
now = datetime.datetime.now()
print (now.strftime ("% Y /% m /% d% H:% M:% S") + 'attendre la limite de connexion')
sleep (15 * 60) # attendez 1 minute
else:
break
return followers_info
# Obtenir une liste de uniquement screen_name de la liste de dict
def followers_list(followers_info):
followers_list = []
for follower in followers_info:
followers_list.append(follower['screen_name'])
return followers_list
# Traitement récursif
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)
Dans ce programme, décidez du compte de départ. (À partir du compte de Yurina Aoshima, un groupe d'idols appelé // Necopla //)
Après cela, il sera traité de manière récursive selon le flux suivant. ① Obtenez des informations sur les utilisateurs que vous suivez ② Enregistrez les informations de ① dans mongoDB ③ Obtenez les informations utilisateur acquises dans ① une par une et exécutez à partir de ①
En modifiant la valeur de la profondeur, vous pouvez modifier le nombre de plongées récursives.
Si c'est 2, c'est une image pour se faire des amis d'amis. Je voulais vraiment obtenir plus de données, mais l'API pour obtenir des informations liées au suivi ne peut envoyer que 15 demandes en 15 minutes. Le compte de départ suit actuellement 100 comptes, mais même si j'ai commencé avec ce compte, il a fallu environ 3 heures pour terminer le processus. De plus, l'erreur «La connexion existante a été déconnectée de force par l'hôte distant» s'est produite en cours de route et le processus a échoué.
À ce stade, seuls environ 60 des 100 comptes d'utilisateurs que je suis sont terminés. Même si cela a fonctionné, je pense que cela a pris environ 6 heures.
Le code suivant est utilisé pour l'enregistrement des données dans mongoDB.
Visualiser
Comme mentionné dans la section précédente, on ne peut pas dire que toutes les données ont été collectées, mais pour le moment, visualisons-les avec les données collectées.
La bibliothèque utilisée pour la visualisation était NetworkX. L'installation peut être effectuée avec la commande suivante.
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'
# Créer un nouveau graphique
G = nx.Graph()
#Ajouter un nœud
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)
# Créer un diagramme. figsize est la taille de la figure
plt.figure(figsize=(10, 8))
# Déterminez la disposition de la figure. Plus la valeur de k est petite, plus le chiffre est dense
pos = nx.spring_layout(G, k=0.8)
# Dessin de nœuds et d'arêtes
# _color: spécifiez la couleur
# alpha: spécification de la transparence
nx.draw_networkx_edges(G, pos, edge_color='y')
nx.draw_networkx_nodes(G, pos, node_color='r', alpha=0.5)
# Ajouter un nom de nœud
nx.draw_networkx_labels(G, pos, font_size=10)
# Réglage de ne pas afficher l'axe X et l'axe Y
plt.axis('off')
plt.savefig("mutual_follow.png ")
# Dessinez un diagramme
plt.show()
La procédure et la logique pour obtenir des abonnés sont similaires. Il obtient récursivement des abonnés et ajoute des bords lorsqu'il trouve des comptes qui se suivent.
résultat
Il s'est avéré être quelque chose comme ça.
Je ne comprends pas le mécanisme détaillé de la bibliothèque, mais il existe de nombreux comptes avec de nombreuses connexions. Ce compte bondé est une idole appartenant au même bureau, donc j'étais satisfait du résultat.
Impressions
Le résultat était assez intéressant. Étant donné que la limite d'émission des demandes de l'API Twitter est de 15 / min, nous n'avons pas pu augmenter beaucoup la quantité de données. Si vous pouvez trouver du temps et collecter plus de données, vous pourrez peut-être voir la connexion d'amis d'amis et d'amis d'amis.
Recommended Posts