【コピペOK】Pythonで楽々スクレイピング！SimpleScraper自作クラスで簡単Webページ解析

url = 'https://kakaku.com/item/K0001521843/spec/#tab'
ss = SimpleScraper()
ss.request(url,folder="p:/html")

print(ss.get_text())
ss.seek("前週比")
res = ss.get(sword="<>",eword="円")
print(res)

import os
import sys
sys.path.append(os.path.join(os.path. dirname(__file__), '../libs'))
from simple_scrape import SimpleScraper

ss = SimpleScraper(wait=(2,5))
soup = ss.request('https://kakaku.com/item/K0001521843/spec/#tab')

ss = SimpleScraper(wait=(2,5))
soup = ss.request("https://kakaku.com/item/K0001521843/spec/#tab",folder="d:/myfolder")

ss = SimpleScraper(wait=(2,5))
ss.site_save("p:/url","https://kakaku.com/pc/note-pc/itemlist.aspx?pdf_pg={0}",1,10)

ss = SimpleScraper()
soup = ss.request_from_file("p:/html/https___kakaku.com_item_K0001521843_spec_#tab.html")

ss = SimpleScraper(wait=(2,5))
ss.request('https://kakaku.com/item/K0001521843/spec/#tab')
for tag in ss.get_image_tags():
    print(tag)

ss = SimpleScraper(wait=(2,5))
ss.request('https://kakaku.com/item/K0001521843/spec/#tab')
for url in ss.get_image_urls():
    print(url)

ss = SimpleScraper(wait=(2,5))
ss.request('https://kakaku.com/item/K0001521843/spec/#tab')
for tag in ss.get_link_tags():
    print(tag)

ss = SimpleScraper(wait=(2,5))
ss.request('https://kakaku.com/item/K0001521843/spec/#tab')
for url in ss.get_link_urls():
    print(url)

ss = SimpleScraper(wait=(2,5))
ss.request('https://kakaku.com/item/K0001521843/spec/#tab')
for table in ss.get_tables():
    print(table)

ss = SimpleScraper(wait=(2,5))
ss.request('https://kakaku.com/item/K0001521843/spec/#tab')
urls = ss.get_image_urls() # 画像のリンク取得
ss.download_image(urls ,"d:/img",min_size=(100, 100),file_extension="jpg")

ss = SimpleScraper(wait=(1,5))
ss.request('https://kakaku.com/item/K0001521843/spec/#tab')
print(ss.get_text())

ss = SimpleScraper(wait=(1,5))
ss.request('https://kakaku.com/item/K0001521843/spec/#tab')
ss.get_text()                      # テキストに変換
ss.seek("<22:0>")                  # <22:0> という文字列を検索
res = ss.get(start=">",end="<")    # ">" を始点、"<" を終点として、その範囲内の文字列を取得　
print(res)

import os
import re
import random
import time
from PIL import Image
from io import BytesIO
from str_util import StrUtil
import pandas as pd
import requests
from bs4 import BeautifulSoup

class SimpleScraper():
    def __init__(self, url=None,wait=(1,1)):
        """
        SimpleScraperクラスのコンストラクタ

        Parameters:
        url (str, optional): スクレイピング対象のURL。指定しない場合はNone。デフォルトはNone。
        """
        self.url = url
        self.soup = None
        self.html = None
        self.rows = []
        self.current = 0
        self.folder = None
        self.wait = wait

    def request(self, url,folder=None,encoding='utf-8',wait=None):
        """
        指定したURLからコンテンツを取得する関数

        Parameters:
        url (str, optional): 取得するコンテンツのURL。指定する場合はNone以外を指定。
        folder (str, optional): HTMLファイルを保存するフォルダーのパス。
        encoding (str): 保存するファイルのエンコーディング。
        wait (tubpe): 取得前に待機する秒数、または秒数の最小と最大。

        Returns:
        BeautifulSoup: 取得したコンテンツのBeautifulSoupオブジェクト
        str: 取得に失敗した場合はエラーメッセージを返す
        None: 例外が発生した場合はNoneを返す
        """
        try:
            self.sleep(self.wait if wait is None else wait)

            if folder != None:
                if not os.path.exists(folder):
                    os.makedirs(folder)
                    self.folder = folder

            print(f"reauest->{url}")

            self.url = url
            response = requests.get(url)
            if response.status_code == 200:
                response.encoding = response.apparent_encoding
                self.html = response.text
                self.soup = BeautifulSoup(response.content, 'html.parser', from_encoding=response.apparent_encoding)
                if folder != None:
                    path = os.path.join(folder,self._make_path(self.url)) + ".html"
                    with open(path, 'w', encoding=encoding) as f:
                        f.write(self.html)
                return self.soup
            else:
                return "Failed to retrieve the content from the URL"
        except Exception as e:
            return None

    def sleep(self,wait=(1,1)):
        """
        指定した値の範囲で乱数を発生させ、その秒数だけ待機する
        Parameters:
        wait (int,int): 待機するランダム値の最小値と最大値。

        Returns:
        """
        # 最小値から最大値までの乱数を生成
        if isinstance(wait, int):
            random_seconds = wait
        else:
            if wait[0] == wait[1]:
                random_seconds = wait[0]
            else:
                random_seconds = random.uniform(wait[0], wait[1])

        print(f"sleep {random_seconds} sec")
        # 乱数の秒数だけ待機する
        time.sleep(random_seconds) 

    def site_save(self,folder,url,start,end,encoding="utf-8",wait=None):
        """
        指定されたURL範囲のHTMLをダウンロードし、指定されたフォルダに保存します。

        Parameters:
            folder (str): 保存先のフォルダパス
            url (str): ダウンロードするURLのフォーマット (例: "https://example.com/page_{}.html")
            start (int): 開始番号
            end (int): 終了番号
            encoding (str, optional): ファイルのエンコーディング. Defaults to "shift-jis".
            wait (float, optional): 各リクエスト間の待ち時間 (秒). Defaults to None.
        """
        for no in range(start,end + 1):
            self.request(url.format(no),folder,encoding=encoding,wait=wait)

    def request_from_file(self, file_path, encoding='utf-8'):
        """
        指定したファイルからHTMLを読み込む関数

        Parameters:
        file_path (str): 読み込むHTMLファイルのパス。
        encoding (str): ファイルのエンコーディング。

        Returns:
        BeautifulSoup: 読み込んだHTMLのBeautifulSoupオブジェクト
        str: 読み込みに失敗した場合はエラーメッセージを返す
        None: 例外が発生した場合はNoneを返す
        """
        try:
            if os.path.exists(file_path):
                with open(file_path, 'r', encoding=encoding) as f:
                    self.html = f.read()
                    self.soup = BeautifulSoup(self.html, 'html.parser')
                    self.url = file_path  # URLの代わりにファイルパスを設定
                    return self.soup
            else:
                return "File does not exist."
        except Exception as e:
            print(f"An error occurred: {e}")
            return None

    def get_image_tags(self):
        """
        Imageタグを取得するメソッド
        Returns:
        list: Imageタグのリスト
              例： [('パソコン', 'https://img1.kakaku.k-img.com/images/icon_pc.gif'),～]
        """
        # BeautifulSoupのfind_allメソッドでImageタグを取得
        image_tags = self.soup.find_all('img')
        # テキストとイメージのURLをタプルのリストに変換
        self.rows = [(tag.get('alt', ''), tag['src']) for tag in image_tags]
        return self.rows

    def get_link_tags(self):
        """
        リンクの文字列とURLをタプルで取得するメソッド
        Returns:
        list: リンクの文字列とURLのタプルのリスト
              例：[('ノートパソコン', 'https://kakaku.com/pc/note-pc/'),～]
        """
        link_tags = self.soup.find_all('a')
        self.rows = [(tag.text, tag.get('href')) for tag in link_tags]
        return self.rows
    
    def get_image_urls(self):
        """
        画像のURLを取得するメソッド
        Returns:
        list: 画像のURLのリスト
              例：['https://img1.kakaku.k-img.com/images/icon_pc.gif',～]
        """
        image_tags = self.soup.find_all('img')
        self.rows = [tag['src'] for tag in image_tags]
        return self.rows

    def get_link_urls(self):
        """
        リンクタグを取得するメソッド
        Returns:
        list: リンクタグのリスト
              例：['https://kakaku.com/pc/gaming-note/',～]
        """
        # BeautifulSoupのfind_allメソッドでリンクタグを取得
        link_tags = self.soup.find_all('a')
        # リンクタグを文字列のリストに変換
        self.rows = [tag.get('href') for tag in link_tags]
        return self.rows

    def get_tables(self):
        """
        テーブルデータを取得するメソッド
        Returns:
        list: テーブルデータのリストのリスト
              例：[['<1:1:D>', '', '', '', '', '', '', ''],～]
        """
        tables = self.soup.find_all('table')
        all_data = []
        table_number = 1

        for table in tables:
            rows = table.find_all('tr')
            row_number = 1
            for row in rows:
                th_tags = row.find_all('th')
                td_tags = row.find_all('td')

                # HTMLタグや改行を取り除く
                if th_tags:
                    all_data.append([f"<{table_number}:{row_number}:H>"] + [ele.get_text(strip=True) for ele in th_tags])
                    row_number += 1
                if td_tags:
                    all_data.append([f"<{table_number}:{row_number}:D>"] + [ele.get_text(strip=True) for ele in td_tags])
                    row_number += 1

            table_number += 1

        self.rows = all_data
        return self.rows

    def get_html(self):
        """
        HTMLを取得するメソッド
        Returns:
        list: HTMLの行ごとのリスト
        """
        self.rows = StrUtil.split_newline(self.html)
        return self.rows

    def get_text(self, separator="<>",is_number=True):
        """
        テキストを取得するメソッド
        Parameters:
        separator (str, optional): HTMLタグを処理しやすいよう、置き換える文字列。デフォルトは"<>"
        Returns:
        list: テキストの行ごとのリスト
              例：[['<1:0>', '<2:0>', '<3:0>', '<4:0>価格',<4:1>','<5:0>スペック',～ ]
        """
        text = self.soup.get_text(separator=separator)
        lines = StrUtil.split_newline(text)
        self.rows = self._replace_separator(lines,separator) if is_number else lines
        return self.rows

    def _replace_separator(self, lines, separator="<>"):
        """
        セパレータで区切られた部分を、行番号とカウント数を付加する

        Args:
            lines (list): テキストの行のリスト
            separator (str, optional): セパレータ文字列. Defaults to "<>".

        Returns:
            list: 変換後の行のリスト
        """

        return [
            "".join(
                f"{separator[0]}{index}:{count}{separator[1]}{part}"
                for count, part in enumerate(line.split(separator)[1:])
            )
            for index, line in enumerate(lines)
            if line
        ]
    
    def download_image(self, image_urls, output_folder, min_size=(100, 100), file_extension=None):
        """
        画像をダウンロードするメソッド

        Parameters:
        image_urls (list): ダウンロードする画像のURLのリスト
        output_folder (str): 画像を保存するフォルダーのパス
        min_size (tuple): ダウンロードする画像の最小サイズ (width, height)
        file_extension (str): 保存する画像の拡張子
        """
        # 出力先フォルダーが存在しない場合は作成
        if not os.path.exists(output_folder):
            os.makedirs(output_folder)

        for url in image_urls:
            try:
                # ファイルの拡張子を取得
                if file_extension is not None:
                    url_extension = url.split('.')[-1].lower()
                    if url_extension != file_extension.lower().replace('.',''):
                        continue

                # 画像を取得
                response = requests.get(url)
                if response.status_code == 200:
                    # 画像のサイズをチェック
                    image = Image.open(BytesIO(response.content))
                    width, height = image.size

                    # 指定サイズを超える場合のみダウンロード
                    if width >= min_size[0] and height >= min_size[1]:
                        # ファイル名を作成
                        filename = self._make_path(url)  # 不正な文字を'_'に置換
                        filename = f"{filename}.{file_extension}"  # 拡張子を追加
                        file_path = os.path.join(output_folder, filename)

                        # 画像を保存
                        image.save(file_path)
                        print(f"Downloaded: {file_path}")
                    else:
                        print(f"Skipped (too small): {url} (size: {width}x{height})")
                else:
                    print(f"Failed to download: {url}")
            except Exception as e:
                print(f"Error downloading {url}: {e}")

    def _make_path(self,url):
        return re.sub(r'[<>:"/\\|?*]', '_', url)  # 不正な文字を'_'に置換

    def seek(self, keyword,pos=None):
        """
        posで指定した行番号を起点にキーワードを含む行を検索し、見つかった行番号を返を返すと共にカレント行番号を更新する。
        pos を None にすると、直前の検索位置から検索を開始する。
        Keywordを None にすると、前回検索したキーワードを引き継ぐ。
        Keywordが見つからない場合、-1 を返す

        Parameters:
        keyword (str, optional): 検索するキーワード。
        pos (int, optional): 検索を開始する位置。指定しない場合はNone。

        Returns:
        int: キーワードが見つかった行番号（カレント行番号）。
        """
        pos = self.current if pos is None else pos

        for i in range(pos, len(self.rows) - pos):
            if keyword in self.rows[i]:
                self.current = i
                return i
        return -1

    def get(self, pos=None, offset=0, limit=1, start=None, end=None, omit="",trim="<>"):
        """
        pos + offset で指定した行位置に対して、sword と eword で囲まれた範囲を取り出す関数。
        pos に Noneを指定すると、カレント位置が指定される。
        limit を指定すると、指定した行位置を起点に limit で指定した行を１つの文字列に結合して返す。

        Parameters:
        pos (int, optional): 取得を開始する位置。指定しない場合はNone。
        offset (int, optional): 取得位置のオフセット。デフォルトは0。
        limit (int, optional): 取得する行数の制限。デフォルトは1。
        start (str, optional): 開始キーワード。指定しない場合はNone。
        end (str, optional): 終了キーワード。指定しない場合はNone。
        omit (str, optional): 除外する条件。指定しない場合はNone。
        trim (str, optional): 削除したい前後の文字。（stripに渡す文字列と同じ）
    
        Returns:
        str: 取得した行の文字列
        """
        res = ""
        pos = self.current if pos is None else pos
        pos += offset
        count = len(self.rows)
        if pos < count:
            if start is None:
                return self.rows[pos]
            limit += pos
            limit = limit if limit < count else count
            for line in self.rows[pos:limit]:
                res += StrUtil.between(line.strip(trim), start, end)

        return res.replace(omit,"")