ਇੱਕ ਡਾਟਾਬੇਸ ਵਿੱਚ ਸਾਰੇ Habr

ਨਮਸਕਾਰ. ਇਸ ਨੂੰ ਲਿਖੇ ਹੋਏ 2 ਸਾਲ ਹੋ ਗਏ ਹਨ। ਆਖਰੀ ਲੇਖ Habr ਨੂੰ ਪਾਰਸ ਕਰਨ ਬਾਰੇ, ਅਤੇ ਕੁਝ ਨੁਕਤੇ ਬਦਲ ਗਏ ਹਨ।

ਜਦੋਂ ਮੈਂ ਹਾਬਰ ਦੀ ਇੱਕ ਕਾਪੀ ਲੈਣਾ ਚਾਹੁੰਦਾ ਸੀ, ਮੈਂ ਇੱਕ ਪਾਰਸਰ ਲਿਖਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਜੋ ਲੇਖਕਾਂ ਦੀ ਸਾਰੀ ਸਮੱਗਰੀ ਨੂੰ ਡੇਟਾਬੇਸ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕਰੇਗਾ। ਇਹ ਕਿਵੇਂ ਹੋਇਆ ਅਤੇ ਮੈਨੂੰ ਕਿਹੜੀਆਂ ਗਲਤੀਆਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪਿਆ - ਤੁਸੀਂ ਕੱਟ ਦੇ ਹੇਠਾਂ ਪੜ੍ਹ ਸਕਦੇ ਹੋ.

TLDR- ਡਾਟਾਬੇਸ ਲਿੰਕ

ਪਾਰਸਰ ਦਾ ਪਹਿਲਾ ਸੰਸਕਰਣ। ਇੱਕ ਧਾਗਾ, ਬਹੁਤ ਸਾਰੀਆਂ ਸਮੱਸਿਆਵਾਂ

ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਮੈਂ ਇੱਕ ਸਕ੍ਰਿਪਟ ਪ੍ਰੋਟੋਟਾਈਪ ਬਣਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ, ਜਿਸ ਵਿੱਚ ਲੇਖ ਨੂੰ ਡਾਉਨਲੋਡ ਕਰਨ ਅਤੇ ਡੇਟਾਬੇਸ ਵਿੱਚ ਰੱਖੇ ਜਾਣ 'ਤੇ ਤੁਰੰਤ ਪਾਰਸ ਕੀਤਾ ਜਾਵੇਗਾ। ਦੋ ਵਾਰ ਸੋਚੇ ਬਿਨਾਂ, ਮੈਂ sqlite3 ਦੀ ਵਰਤੋਂ ਕੀਤੀ, ਕਿਉਂਕਿ. ਇਹ ਘੱਟ ਮਿਹਨਤ ਵਾਲਾ ਸੀ: ਸਥਾਨਕ ਸਰਵਰ, ਬਣਾਏ-ਦਿੱਖ-ਹਟਾਏ ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦੀਆਂ ਚੀਜ਼ਾਂ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ।

one_thread.py

from bs4 import BeautifulSoup
import sqlite3
import requests
from datetime import datetime

def main(min, max):
    conn = sqlite3.connect('habr.db')
    c = conn.cursor()
    c.execute('PRAGMA encoding = "UTF-8"')
    c.execute("CREATE TABLE IF NOT EXISTS habr(id INT, author VARCHAR(255), title VARCHAR(255), content  TEXT, tags TEXT)")

    start_time = datetime.now()
    c.execute("begin")
    for i in range(min, max):
        url = "https://m.habr.com/post/{}".format(i)
        try:
            r = requests.get(url)
        except:
            with open("req_errors.txt") as file:
                file.write(i)
            continue
        if(r.status_code != 200):
            print("{} - {}".format(i, r.status_code))
            continue

        html_doc = r.text
        soup = BeautifulSoup(html_doc, 'html.parser')

        try:
            author = soup.find(class_="tm-user-info__username").get_text()
            content = soup.find(id="post-content-body")
            content = str(content)
            title = soup.find(class_="tm-article-title__text").get_text()
            tags = soup.find(class_="tm-article__tags").get_text()
            tags = tags[5:]
        except:
            author,title,tags = "Error", "Error {}".format(r.status_code), "Error"
            content = "При парсинге этой странице произошла ошибка."

        c.execute('INSERT INTO habr VALUES (?, ?, ?, ?, ?)', (i, author, title, content, tags))
        print(i)
    c.execute("commit")
    print(datetime.now() - start_time)

main(1, 490406)

ਹਰ ਚੀਜ਼ ਕਲਾਸਿਕ ਹੈ - ਅਸੀਂ ਸੁੰਦਰ ਸੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਬੇਨਤੀਆਂ ਅਤੇ ਇੱਕ ਤੇਜ਼ ਪ੍ਰੋਟੋਟਾਈਪ ਤਿਆਰ ਹੈ. ਇਹ ਸਿਰਫ…

• ਪੰਨਾ ਡਾਊਨਲੋਡ ਇੱਕ ਥ੍ਰੈਡ ਵਿੱਚ ਹੈ

• ਜੇਕਰ ਤੁਸੀਂ ਸਕ੍ਰਿਪਟ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਵਿੱਚ ਰੁਕਾਵਟ ਪਾਉਂਦੇ ਹੋ, ਤਾਂ ਸਾਰਾ ਡਾਟਾਬੇਸ ਕਿਤੇ ਨਹੀਂ ਜਾਵੇਗਾ। ਆਖ਼ਰਕਾਰ, ਵਚਨਬੱਧਤਾ ਸਾਰੇ ਪਾਰਸਿੰਗ ਤੋਂ ਬਾਅਦ ਹੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ.
  ਬੇਸ਼ੱਕ, ਤੁਸੀਂ ਹਰੇਕ ਸੰਮਿਲਨ ਤੋਂ ਬਾਅਦ ਡੇਟਾਬੇਸ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਫਿਰ ਸਕ੍ਰਿਪਟ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸਮਾਂ ਬਹੁਤ ਵਧ ਜਾਵੇਗਾ।

• ਪਹਿਲੇ 100 ਲੇਖਾਂ ਨੂੰ ਪਾਰਸ ਕਰਨ ਵਿੱਚ ਮੈਨੂੰ 000 ਘੰਟੇ ਲੱਗੇ।

ਅੱਗੇ ਮੈਂ ਉਪਭੋਗਤਾ ਦਾ ਲੇਖ ਲੱਭਦਾ ਹਾਂ ਸੰਗਠਿਤ, ਜਿਸਨੂੰ ਮੈਂ ਪੜ੍ਹਿਆ ਅਤੇ ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਲਈ ਕੁਝ ਲਾਈਫ ਹੈਕ ਲੱਭੇ:

• ਮਲਟੀਥ੍ਰੈਡਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਨ ਨਾਲ ਕਈ ਵਾਰ ਡਾਊਨਲੋਡਿੰਗ ਤੇਜ਼ ਹੋ ਜਾਂਦੀ ਹੈ।
• ਤੁਸੀਂ ਹਾਬਰ ਦਾ ਪੂਰਾ ਸੰਸਕਰਣ ਨਹੀਂ, ਪਰ ਇਸਦਾ ਮੋਬਾਈਲ ਸੰਸਕਰਣ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ।
  ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਡੈਸਕਟੌਪ ਸੰਸਕਰਣ ਵਿੱਚ ਇੱਕ ਸੰਯੁਕਤ ਲੇਖ ਦਾ ਭਾਰ 378 KB ਹੈ, ਤਾਂ ਮੋਬਾਈਲ ਸੰਸਕਰਣ ਵਿੱਚ ਇਹ ਪਹਿਲਾਂ ਹੀ 126 KB ਹੈ।

ਦੂਜਾ ਸੰਸਕਰਣ. ਬਹੁਤ ਸਾਰੇ ਧਾਗੇ, ਹਬਰ ਤੋਂ ਅਸਥਾਈ ਪਾਬੰਦੀ

ਜਦੋਂ ਮੈਂ python ਵਿੱਚ ਮਲਟੀਥ੍ਰੈਡਿੰਗ ਦੇ ਵਿਸ਼ੇ 'ਤੇ ਇੰਟਰਨੈਟ ਦੀ ਖੋਜ ਕੀਤੀ, ਤਾਂ ਮੈਂ multiprocessing.dummy ਦੇ ਨਾਲ ਸਭ ਤੋਂ ਸਰਲ ਵਿਕਲਪ ਚੁਣਿਆ, ਮੈਂ ਦੇਖਿਆ ਕਿ ਮਲਟੀਥ੍ਰੈਡਿੰਗ ਦੇ ਨਾਲ-ਨਾਲ ਸਮੱਸਿਆਵਾਂ ਸਾਹਮਣੇ ਆਈਆਂ ਹਨ।

SQLite3 ਇੱਕ ਤੋਂ ਵੱਧ ਥ੍ਰੈਡ ਨਾਲ ਕੰਮ ਨਹੀਂ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹੈ.
ਸਥਿਰ check_same_thread=False, ਪਰ ਇਹ ਗਲਤੀ ਸਿਰਫ ਇੱਕ ਨਹੀਂ ਹੈ, ਜਦੋਂ ਡੇਟਾਬੇਸ ਵਿੱਚ ਸੰਮਿਲਿਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਕਈ ਵਾਰ ਗਲਤੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਜੋ ਮੈਂ ਹੱਲ ਨਹੀਂ ਕਰ ਸਕਦਾ ਸੀ.

ਇਸ ਲਈ, ਮੈਂ ਸਿੱਧੇ ਡੇਟਾਬੇਸ ਵਿੱਚ ਲੇਖਾਂ ਦੇ ਤੁਰੰਤ ਸੰਮਿਲਨ ਨੂੰ ਛੱਡਣ ਦਾ ਫੈਸਲਾ ਕਰਦਾ ਹਾਂ ਅਤੇ, ਸੰਯੁਕਤ ਹੱਲ ਨੂੰ ਯਾਦ ਕਰਦੇ ਹੋਏ, ਮੈਂ ਫਾਈਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕਰਦਾ ਹਾਂ, ਕਿਉਂਕਿ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਮਲਟੀ-ਥ੍ਰੈਡਡ ਲਿਖਣ ਵਿੱਚ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ.

ਹੈਬਰ ਤਿੰਨ ਤੋਂ ਵੱਧ ਥਰਿੱਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ 'ਤੇ ਪਾਬੰਦੀ ਲਗਾਉਣਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ.
ਖਾਸ ਤੌਰ 'ਤੇ ਹੈਬਰ ਤੱਕ ਜਾਣ ਦੀਆਂ ਜੋਸ਼ੀਲੀਆਂ ਕੋਸ਼ਿਸ਼ਾਂ ਕੁਝ ਘੰਟਿਆਂ ਲਈ ਆਈਪੀ ਪਾਬੰਦੀ ਦੇ ਨਾਲ ਖਤਮ ਹੋ ਸਕਦੀਆਂ ਹਨ. ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਸਿਰਫ 3 ਥ੍ਰੈਡਸ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਪਵੇਗੀ, ਪਰ ਇਹ ਪਹਿਲਾਂ ਹੀ ਵਧੀਆ ਹੈ, ਕਿਉਂਕਿ 100 ਤੋਂ ਵੱਧ ਲੇਖਾਂ ਨੂੰ ਦੁਹਰਾਉਣ ਦਾ ਸਮਾਂ 26 ਤੋਂ ਘਟਾ ਕੇ 12 ਸਕਿੰਟ ਹੋ ਗਿਆ ਹੈ।

ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ ਇਹ ਸੰਸਕਰਣ ਅਸਥਿਰ ਹੈ, ਅਤੇ ਡਾਉਨਲੋਡਸ ਸਮੇਂ-ਸਮੇਂ 'ਤੇ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਲੇਖਾਂ 'ਤੇ ਡਿੱਗਦੇ ਹਨ.

async_v1.py

from bs4 import BeautifulSoup
import requests
import os, sys
import json
from multiprocessing.dummy import Pool as ThreadPool
from datetime import datetime
import logging

def worker(i):
    currentFile = "files\{}.json".format(i)

    if os.path.isfile(currentFile):
        logging.info("{} - File exists".format(i))
        return 1

    url = "https://m.habr.com/post/{}".format(i)

    try: r = requests.get(url)
    except:
        with open("req_errors.txt") as file:
            file.write(i)
        return 2

    # Запись заблокированных запросов на сервер
    if (r.status_code == 503):
        with open("Error503.txt", "a") as write_file:
            write_file.write(str(i) + "n")
            logging.warning('{} / 503 Error'.format(i))

    # Если поста не существует или он был скрыт
    if (r.status_code != 200):
        logging.info("{} / {} Code".format(i, r.status_code))
        return r.status_code

    html_doc = r.text
    soup = BeautifulSoup(html_doc, 'html5lib')

    try:
        author = soup.find(class_="tm-user-info__username").get_text()

        timestamp = soup.find(class_='tm-user-meta__date')
        timestamp = timestamp['title']

        content = soup.find(id="post-content-body")
        content = str(content)
        title = soup.find(class_="tm-article-title__text").get_text()
        tags = soup.find(class_="tm-article__tags").get_text()
        tags = tags[5:]

        # Метка, что пост является переводом или туториалом.
        tm_tag = soup.find(class_="tm-tags tm-tags_post").get_text()

        rating = soup.find(class_="tm-votes-score").get_text()
    except:
        author = title = tags = timestamp = tm_tag = rating = "Error" 
        content = "При парсинге этой странице произошла ошибка."
        logging.warning("Error parsing - {}".format(i))
        with open("Errors.txt", "a") as write_file:
            write_file.write(str(i) + "n")

    # Записываем статью в json
    try:
        article = [i, timestamp, author, title, content, tm_tag, rating, tags]
        with open(currentFile, "w") as write_file:
            json.dump(article, write_file)
    except:
        print(i)
        raise

if __name__ == '__main__':
    if len(sys.argv) < 3:
        print("Необходимы параметры min и max. Использование: async_v1.py 1 100")
        sys.exit(1)
    min = int(sys.argv[1])
    max = int(sys.argv[2])

    # Если потоков >3
    # то хабр банит ipшник на время
    pool = ThreadPool(3)

    # Отсчет времени, запуск потоков
    start_time = datetime.now()
    results = pool.map(worker, range(min, max))

    # После закрытия всех потоков печатаем время
    pool.close()
    pool.join()
    print(datetime.now() - start_time)

ਤੀਜਾ ਸੰਸਕਰਣ। ਅੰਤਿਮ

ਦੂਜੇ ਸੰਸਕਰਣ ਨੂੰ ਡੀਬੱਗ ਕਰਦੇ ਸਮੇਂ, ਮੈਂ ਖੋਜਿਆ ਕਿ Habr, ਅਚਾਨਕ, ਇੱਕ API ਹੈ ਜੋ ਸਾਈਟ ਦਾ ਮੋਬਾਈਲ ਸੰਸਕਰਣ ਐਕਸੈਸ ਕਰਦਾ ਹੈ. ਇਹ ਮੋਬਾਈਲ ਸੰਸਕਰਣ ਨਾਲੋਂ ਤੇਜ਼ੀ ਨਾਲ ਲੋਡ ਹੁੰਦਾ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਸਿਰਫ਼ json ਹੈ, ਜਿਸ ਨੂੰ ਪਾਰਸ ਕਰਨ ਦੀ ਵੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਅੰਤ ਵਿੱਚ, ਮੈਂ ਆਪਣੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ।

ਇਸ ਲਈ, ਪਾਇਆ ਇਹ ਲਿੰਕ API, ਤੁਸੀਂ ਇਸਨੂੰ ਪਾਰਸ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹੋ।

async_v2.py

import requests
import os, sys
import json
from multiprocessing.dummy import Pool as ThreadPool
from datetime import datetime
import logging

def worker(i):
    currentFile = "files\{}.json".format(i)

    if os.path.isfile(currentFile):
        logging.info("{} - File exists".format(i))
        return 1

    url = "https://m.habr.com/kek/v1/articles/{}/?fl=ru%2Cen&hl=ru".format(i)

    try:
        r = requests.get(url)
        if r.status_code == 503:
            logging.critical("503 Error")
            return 503
    except:
        with open("req_errors.txt") as file:
            file.write(i)
        return 2

    data = json.loads(r.text)

    if data['success']:
        article = data['data']['article']

        id = article['id']
        is_tutorial = article['is_tutorial']
        time_published = article['time_published']
        comments_count = article['comments_count']
        lang = article['lang']
        tags_string = article['tags_string']
        title = article['title']
        content = article['text_html']
        reading_count = article['reading_count']
        author = article['author']['login']
        score = article['voting']['score']

        data = (id, is_tutorial, time_published, title, content, comments_count, lang, tags_string, reading_count, author, score)
        with open(currentFile, "w") as write_file:
            json.dump(data, write_file)

if __name__ == '__main__':
    if len(sys.argv) < 3:
        print("Необходимы параметры min и max. Использование: asyc.py 1 100")
        sys.exit(1)
    min = int(sys.argv[1])
    max = int(sys.argv[2])

    # Если потоков >3
    # то хабр банит ipшник на время
    pool = ThreadPool(3)

    # Отсчет времени, запуск потоков
    start_time = datetime.now()
    results = pool.map(worker, range(min, max))

    # После закрытия всех потоков печатаем время
    pool.close()
    pool.join()
    print(datetime.now() - start_time)

ਇਸ ਵਿੱਚ ਲੇਖ ਅਤੇ ਇਸ ਨੂੰ ਲਿਖਣ ਵਾਲੇ ਲੇਖਕ ਨਾਲ ਸਬੰਧਤ ਖੇਤਰ ਸ਼ਾਮਲ ਹਨ।

API.png

ਮੈਂ ਹਰੇਕ ਲੇਖ ਦੇ ਪੂਰੇ ਜੇਸਨ ਨੂੰ ਡੰਪ ਨਹੀਂ ਕੀਤਾ, ਪਰ ਸਿਰਫ ਉਹਨਾਂ ਖੇਤਰਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਹੈ ਜਿਨ੍ਹਾਂ ਦੀ ਮੈਨੂੰ ਲੋੜ ਹੈ:

• id
• is_tutorial
• ਸਮਾਂ_ਪ੍ਰਕਾਸ਼ਿਤ
• ਦਾ ਸਿਰਲੇਖ
• ਸਮੱਗਰੀ ਨੂੰ
• ਟਿੱਪਣੀਆਂ_ਗਿਣਤੀ
• lang ਉਹ ਭਾਸ਼ਾ ਹੈ ਜਿਸ ਵਿੱਚ ਲੇਖ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ। ਹੁਣ ਤੱਕ, ਇਸ ਵਿੱਚ ਸਿਰਫ en ਅਤੇ ru ਹੈ।
• tags_string - ਪੋਸਟ ਤੋਂ ਸਾਰੇ ਟੈਗ
• ਪੜ੍ਹਨ_ਗਿਣਤੀ
• ਲੇਖਕ
• ਸਕੋਰ - ਲੇਖ ਰੇਟਿੰਗ।

ਇਸ ਤਰ੍ਹਾਂ, API ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਮੈਂ ਸਕ੍ਰਿਪਟ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਟਾਈਮ ਨੂੰ 8 ਸਕਿੰਟ ਪ੍ਰਤੀ 100 url ਤੱਕ ਘਟਾ ਦਿੱਤਾ ਹੈ।

ਸਾਨੂੰ ਲੋੜੀਂਦਾ ਡਾਟਾ ਡਾਊਨਲੋਡ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਸਾਨੂੰ ਇਸ 'ਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਅਤੇ ਇਸਨੂੰ ਡੇਟਾਬੇਸ ਵਿੱਚ ਦਾਖਲ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਮੈਨੂੰ ਇਸ ਨਾਲ ਵੀ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਸੀ:

parser.py

import json
import sqlite3
import logging
from datetime import datetime

def parser(min, max):
    conn = sqlite3.connect('habr.db')
    c = conn.cursor()
    c.execute('PRAGMA encoding = "UTF-8"')
    c.execute('PRAGMA synchronous = 0') # Отключаем подтверждение записи, так скорость увеличивается в разы.
    c.execute("CREATE TABLE IF NOT EXISTS articles(id INTEGER, time_published TEXT, author TEXT, title TEXT, content TEXT, 
    lang TEXT, comments_count INTEGER, reading_count INTEGER, score INTEGER, is_tutorial INTEGER, tags_string TEXT)")
    try:
        for i in range(min, max):
            try:
                filename = "files\{}.json".format(i)
                f = open(filename)
                data = json.load(f)

                (id, is_tutorial, time_published, title, content, comments_count, lang,
                 tags_string, reading_count, author, score) = data

                # Ради лучшей читаемости базы можно пренебречь читаемостью кода. Или нет?
                # Если вам так кажется, можно просто заменить кортеж аргументом data. Решать вам.

                c.execute('INSERT INTO articles VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', (id, time_published, author,
                                                                                        title, content, lang,
                                                                                        comments_count, reading_count,
                                                                                        score, is_tutorial,
                                                                                        tags_string))
                f.close()

            except IOError:
                logging.info('FileNotExists')
                continue

    finally:
        conn.commit()

start_time = datetime.now()
parser(490000, 490918)
print(datetime.now() - start_time)

ਅੰਕੜੇ

ਖੈਰ, ਰਵਾਇਤੀ ਤੌਰ 'ਤੇ, ਅੰਤ ਵਿੱਚ, ਤੁਸੀਂ ਡੇਟਾ ਤੋਂ ਕੁਝ ਅੰਕੜੇ ਕੱਢ ਸਕਦੇ ਹੋ:

• ਸੰਭਾਵਿਤ 490 ਡਾਊਨਲੋਡਾਂ ਵਿੱਚੋਂ, ਸਿਰਫ਼ 406 ਲੇਖ ਹੀ ਡਾਊਨਲੋਡ ਕੀਤੇ ਗਏ ਸਨ। ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ ਹਾਬਰੇ 'ਤੇ ਅੱਧੇ ਤੋਂ ਵੱਧ (228) ਲੇਖ ਲੁਕੇ ਜਾਂ ਮਿਟਾ ਦਿੱਤੇ ਗਏ ਸਨ।
• ਲਗਭਗ ਅੱਧਾ ਮਿਲੀਅਨ ਲੇਖਾਂ ਵਾਲੇ ਪੂਰੇ ਡੇਟਾਬੇਸ ਦਾ ਭਾਰ 2.95 GB ਹੈ। ਸੰਕੁਚਿਤ ਰੂਪ ਵਿੱਚ - 495 MB.
• ਕੁੱਲ ਮਿਲਾ ਕੇ, 37804 ਲੋਕ ਹਾਬਰੇ ਦੇ ਲੇਖਕ ਹਨ। ਮੈਂ ਤੁਹਾਨੂੰ ਯਾਦ ਦਿਵਾਉਂਦਾ ਹਾਂ ਕਿ ਇਹ ਅੰਕੜੇ ਸਿਰਫ ਲਾਈਵ ਪੋਸਟਾਂ ਤੋਂ ਹਨ।
• ਹਾਬਰੇ 'ਤੇ ਸਭ ਤੋਂ ਵੱਧ ਲਾਭਕਾਰੀ ਲੇਖਕ - ਅਲੀਜ਼ਰ - 8774 ਲੇਖ।
• ਚੋਟੀ ਦਾ ਦਰਜਾ ਦਿੱਤਾ ਲੇਖ - 1448 ਪਲੱਸ
• ਸਭ ਤੋਂ ਵੱਧ ਪੜ੍ਹਿਆ ਲੇਖ - 1660841 ਵਾਰ ਦੇਖਿਆ ਗਿਆ
• ਸਭ ਤੋਂ ਵੱਧ ਚਰਚਾ ਵਾਲਾ ਲੇਖ - 2444 ਟਿੱਪਣੀਆਂ

ਨਾਲ ਨਾਲ, ਸਿਖਰ ਦੇ ਰੂਪ ਵਿੱਚਚੋਟੀ ਦੇ 15 ਲੇਖਕ
ਰੇਟਿੰਗ ਦੁਆਰਾ ਸਿਖਰ 15
ਸਿਖਰ ਦੇ 15 ਪੜ੍ਹੇ
ਸਿਖਰ 15 ਚਰਚਾ ਕੀਤੀ

ਸਰੋਤ: www.habr.com