[PYTHON] L'analyse de réseau est une structure de lien Web ①

introduction

La structure de liens du Web est un réseau à grande échelle auquel vous pouvez facilement jouer. Récupération répétée de l'URL liée à partir du HTML avec ʻurllibetBeautifulSoup` pour créer une matrice de contiguïté de page Web. Cela peut prendre plus de 12 heures, alors essayez-le avec votre cœur. Le code source etc. est disponible sur Author GitHub. L'analyse utilisant NetworkX est décrite dans L'analyse de réseau est une structure de lien sur le web②.

Aperçu du programme

1. Spécifiez la page de démarrage pour commencer en suivant le lien
2. Spécifiez le nombre de fois pour suivre le lien (combien de fois vous pouvez aller de la page d'accueil au plus court)
3. Suivez le lien le nombre de fois spécifié
4. Obtenez tous les liens limités aux URL obtenues le nombre de fois spécifié
5. Créez une matrice adjacente

Préparation

import.py

from urllib.request import urlopen
from bs4 import BeautifulSoup

import networkx as nx

from tqdm import tqdm_notebook as tqdm
import numpy as np
import pandas as pd
pd.options.display.max_colwidth = 500

import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline

import re

urllib.request Une bibliothèque qui récupère des données sur un site Web (Il n'y a pas de bon site de référence ...) BeautifulSoup Module qui analyse les fichiers html à partir des informations de balise Référence: Qiita: Beautiful Soup in 10 minutes networkx Module d'analyse de réseau. Sera expliqué dans le prochain article. tqdm Affiche une barre de progression avec l'instruction for. Lorsque vous utilisez jupyter notebook, notez que tqdm_notebook est importé. Référence: Qiita: Afficher la barre de progression dans Jupyter Notebook pd.options.display.max_colwidth = 500 Dans pandas, augmentez la largeur maximale de chaque colonne. N'omettez pas les URL très longues.

url_prepare.py

start_url = "https://zozo.jp/"
# the page to begin with

explore_num = 2
# how many times do you explore new links

url_list = [start_url]
# list of the URL of all the pages. The components will be added.
link_list=[]
# list of lists [out_node, in_node]. The components will be added.

#prepare a file name to save figures and csv files
fname = re.split('[/.]', start_url)
if fname[2]=="www":
    fname = fname[3]
else:
    fname = fname[2]

start_url Spécifiez la page pour commencer à suivre le lien.

explore_num Spécifiez le nombre de fois où vous devez suivre le lien (combien de fois vous pouvez aller à partir de la page d'accueil au plus court).

url_list Un tableau qui stocke toutes les URL des sites Web que vous visitez. Correspond à l'indice de la matrice adjacente ultérieure.

link_list Un tableau qui stocke toutes les paires d'URL de liens. Un tableau de tableaux dont les éléments sont «[URL où le lien sort, URL où le lien entre]». Correspond à chaque élément de la matrice adjacente suivante.

fname Le nom du fichier pour enregistrer le graphique seaborn et les données de la table pandas plus tard

Fonction d'analyse de la structure des liens

Voici la fonction qui suit réellement le lien. link_explore est une fonction qui recherche tous les liens. Prend un tableau d'URL à rechercher en tant qu'argument. link_cruise est une fonction qui recherche des liens vers un site donné uniquement. Prend une matrice adjacente comme argument.

link_explore.py

def link_explore(link_list, url_list, now_url_list):
    # link_list: list of the URL of all the pages
    # url_list: list of lists [out_node, in_node]
    # next_url_list: list of the URL to explore in this function
    print(f"starting explorting {len(now_url_list)} pages")
    next_url_list=[]
    
    for url in now_url_list:
        
        try:
            with urlopen(url, timeout=10) as res:
                html = res.read().decode('utf-8', 'ignore')
                soup = BeautifulSoup(html, "html.parser")

        except:
            print("x", end="")
            continue
            #print(f"\n{url}")
            
        else:
            for a in soup.find_all("a"):
                link = a.get("href")

                if link!=None and len(link)>0:
                    if link[0]=="/":
                        link = url+link[1:]

                    if link[0:4] == "http":
                        if link[-1]=="/":
                            next_url_list.append(link)
                            link_list.append([url,link])
                            
            print("o", end="")
        
    next_url_list = list(set(next_url_list))
        
    url_list += next_url_list
    url_list = list(set(url_list))
        
    return link_list, url_list, next_url_list

link_cruise.py

def link_cruise(adj, url_list, now_url_list):
    # adj: adjacency matrix
    # next_url_list: list of the URL to explore in this function
    #print(f"starting cruising {len(now_url_list)} pages")
    next_url_list=[]
    
    for url in tqdm(now_url_list):
        
        try:
            with urlopen(url, timeout=10) as res:
                html = res.read().decode('utf-8', 'ignore')
                soup = BeautifulSoup(html, "html.parser")
                
        except:
            continue
            
        else:
            for a in soup.find_all("a"):
                link = a.get("href")

                if link!=None and len(link)>0:
                    if link[0]=="/":
                        link = url+link[1:]

                    if link[0:4] == "http":
                        if link[-1]=="/":
                            if link in url_list:
                                if adj[url_list.index(url),url_list.index(link)] == 0:
                                    next_url_list.append(link)
                                    adj[url_list.index(url),url_list.index(link)] = 1
            #print("o", end="")
        
    next_url_list = list(set(next_url_list))
        
    #print("")
    return adj, next_url_list

Courir

Suivez le lien le nombre de fois donné par ʻexplore_num. Affiche ʻo si le décodage HTML lié réussit, et affiche x s'il échoue.

explore_exe.py

next_url_list = url_list
for i in range(explore_num):
    print(f"\nNo.{i+1} starting")
    link_list, url_list, next_url_list = link_explore(link_list, url_list, next_url_list)
    print(f"\nNo.{i+1} completed\n")

↓ Cela ressemble à ceci ↓.

Créez une matrice adjacente.

make_adj.py

adj = np.zeros((len(url_list),len(url_list)))

for link in tqdm(link_list):
    try:
        adj[url_list.index(link[0]),url_list.index(link[1])] = 1
    except:
        pass

La recherche après ʻexplore_num` est limitée aux pages qui ont déjà été visitées. Répétez la recherche jusqu'à ce que toutes les pages soient visitées.

cruise_exe.py

while (len(next_url_list)>0):
    adj, next_url_list = link_cruise(adj, url_list, next_url_list)

Achevée!

Suite

• L'analyse de réseau est une structure de liens sur le Web ②