猫史档案馆

-----------------------------------------------微型数据库 & 逻辑回归(机器学习)-------------------------------------------

微型数据库-源代码：

from bs4 import BeautifulSoup
import requests
import json

headers = {
    "Content-Type": "application/json",
    "User-Agent": 'Mozilla/5.0 (Windows NT 10.0; ) '
    'AppleWebKit/537.36 (KH喵L, like Gecko) '
    'Chrome/81.0.4044.138 Safari/537.36'}


def get(url: str, cookies={}):
    return requests.get(url, headers=headers, cookies=cookies)


def post(url: str, data={}, cookies={}):
    return requests.post(url, headers=headers, data=json.dumps(data), cookies=cookies)


def put(url: str, data={}, cookies={}):
    return requests.put(url, headers=headers, data=json.dumps(data), cookies=cookies)


class DataBase:
    def __init__(self, identity: str, password: str, novel: int):
        if not (type(identity) == str and type(password) == str and type(novel) == int):
            raise ValueError("Error: parameter error")
        response = post(
            "https://api.codemao.cn/tiger/v3/web/accounts/login", data={"identity": identity, "password": password, "pid": "65edCTyg"})
        if "user_info" not in json.loads(response.text):
            raise ValueError("Error: identity or password error")
        self.cookies = response.cookies
        self.user_id = str(json.loads(response.text)["user_info"]["id"])
        response = get("https://api.codemao.cn/web/fanfic/section/" +
                       str(novel), cookies=self.cookies)
        if "id" not in json.loads(response.text):
            raise ValueError("Error: novel error")
        self.novel = str(novel)

    def show(self):
        data = {}
        response = get("https://api.codemao.cn/web/fanfic/section/" +
                       self.novel, cookies=self.cookies)
        soup = BeautifulSoup(json.loads(response.text)["draft"], "lxml")
        for i in soup.select("p"):
            data[str(i)[3:-4].split(":")[0]] = str(i)[3:-4].split(":")[1]
        return data

    def revise(self, key: str, value: str):
        if not (type(key) == str and type(value) == str):
            raise ValueError("Error: parameter error")
        if ":" in key or ":" in value:
            raise ValueError(
                "Error: key or value can not includes the char ':'")
        data = self.show()
        data[key] = value
        draft = ""
        for i in data.items():
            draft += "<p>" + i[0] + ":" + i[1] + "</p>\n"
        put("https://api.codemao.cn/web/fanfic/section/"+self.novel,
            data={"draft_words_num": 0, "title": "数据库", "draft": draft}, cookies=self.cookies)

    def delete(self, key: str):
        if type(key) != str:
            raise ValueError("Error: parameter error")
        data = self.show()
        try:
            data.pop(key)
        except:
            return False
        draft = ""
        for i in data.items():
            draft += "<p>" + i[0] + ":" + i[1] + "</p>\n"
        put("https://api.codemao.cn/web/fanfic/section/"+self.novel,
            data={"draft_words_num": 0, "title": "数据库", "draft": draft}, cookies=self.cookies)
        return True

    def clear(self):
        for reply in self._get_reply_list():
            put("https://api.codemao.cn/web/fanfic/section/"+self.novel,
                data={"draft_words_num": 0, "title": "数据库", "draft": ""}, cookies=self.cookies)

逻辑回归-源代码

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
import numpy


class Classifier:
    def __init__(self, data: dict):
        self.labels = []
        self.features = []
        self._name_label = {}
        self._names = 0
        if type(data) != dict:
            raise ValueError(
                "Type of the parameter must be dict! User Manual: https://shequ.codemao.cn/")
        for item in data.items():
            if type(item[0]) != str:
                raise ValueError(
                    "Labels need to be of string type! User Manual: https://shequ.codemao.cn/")
            if type(item[1]) != list:
                raise ValueError(
                    "Feature lists need to be list type! User Manual: https://shequ.codemao.cn/")
            if len(item[1]) == 0:
                raise ValueError(
                    "Feature lists' lengths need to be non-zero! User Manual: https://shequ.codemao.cn/")
            for features in item[1]:
                if type(features) != list:
                    raise ValueError(
                        "Features need to be list type! User Manual: https://shequ.codemao.cn/")
                if len(features) == 0 or len(features) != len(list(data.values())[0][0]):
                    raise ValueError(
                        "Features' lengths need to be non-zero and equal! User Manual: https://shequ.codemao.cn/")
                for feature in features:
                    if type(feature) != int and type(feature) != float:
                        raise ValueError(
                            "Feature need to be int or float type! User Manual: https://shequ.codemao.cn/")
                self.features.append(features)
                if item[0] not in self._name_label.keys():
                    self._names += 1
                    self._name_label[item[0]] = self._names
                self.labels.append(self._name_label[item[0]])
        self._train_features, self._test_features, self._train_labels, self._test_labels = train_test_split(
            numpy.array(self.features), numpy.array(self.labels), test_size=0.3, random_state=0)
        self._model = LogisticRegression(penalty="l2", solver="newton-cg",
                                         multi_class="multinomial", n_jobs=-1)
        self._model.fit(self._train_features, self._train_labels)

    def classify(self, data: list):
        if type(data) != list:
            raise ValueError(
                "Type of the parameter must be dict! User Manual: https://shequ.codemao.cn/")
        if len(data) == 0 or len(data) != len(self.features[0]):
            raise ValueError(
                "Features' lengths need to be non-zero and equal! User Manual: https://shequ.codemao.cn/")
        label = self._model.predict(numpy.array(data).reshape(1, -1))
        for i in self._name_label.items():
            if i[1] == label:
                return i[0]

    def confidence(self):
        return self._model.score(self._test_features, self._test_labels)