归档 on kutake小站

把 WordPress 博客搬进 Hugo：迁移、构建与发布全记录

Wed, 14 Oct 2026 04:21:21 +0800

这个博客原来跑在 WordPress 上。前几天我把它整个搬到了 Hugo，静态托管在 Cloudflare Pages 上，顺手把「写文章」这件事也重新做了一遍。这篇算是迁移完成后的第一篇，把整条流水线从头到尾记一遍：数据怎么搬、Hugo 怎么构建、文章怎么写、发布怎么做，以及中间踩过的坑。

在有共同字段下的pydantic类转换不正确问题

Sat, 10 Feb 2024 16:15:40 +0800

在使用 Pydantic 进行数据验证和设置时，你可能会遇到一个问题：当多个类有共同字段时，Pydantic 可能无法正确地区分这些类。让我通过一个简单的例子来解释这个问题。

基于Route来解决playwright的静态HTML资源加载问题

Sat, 10 Feb 2024 16:14:14 +0800

前因

由于python中没有方便快捷生成美观图片的方案，所以我使用了jinja2模板生成html后交给playwright生成网页图片，这其中，图片资源可以使用base64格式解决，而字体加载就难了。

使用Github Workflows构建Tauri应用

Thu, 28 Dec 2023 21:04:15 +0800

下面这个例子是，当release分支有commit发生时，自动获取当前应用的版本信息，并使用缓存，分别构建前端和rust，并将构建好的包上传至指定tag的release上。在 platform处定义平台，这里我只选定了Win

[Tauri]Uint8Array与 Vec的坑

Thu, 28 Dec 2023 20:44:38 +0800

问题

当尝试传递 Uint8Array类型的图片数据给rust后端时，会发生 invalid type: map, expected a sequence

原因在于，tauri将 Uint8Array是作为对象而不是一个 Vec，要接受它，需要使用 HashMap<String, u8>来接收。

Tokio异步task控制并发数量

Thu, 28 Dec 2023 20:30:29 +0800

使用tokio::sync::Semaphore

信号量可以保证在某一时刻最多运行指定数量的并发任务。

使用信号量时，需在初始化时指定信号灯(tokio中的SemaphorePermit)的数量，每当任务要执行时，将从中取走一个信号灯，当任务完成时(信号灯被drop)会归还信号灯。当某个任务要执行时，如果此时信号灯数量为0，则该任务将等待，直到有信号灯被归还。因此，信号量通常用来提供类似于限量的功能。

Tauri 调用终端api

Wed, 29 Nov 2023 22:25:50 +0800

当你想从Tauri调用终端并运行类似 ls的命令的话，需要使用 @tauri-apps/api/shell的api，步骤如下

编辑 tauri.conf.json下的 tauri.allowlist.shell

{
 "tauri": {
 "allowlist": {
 "shell": {
 "all": true, // enable all shell APIs
 "execute": true, // enable process spawn APIs
 "sidecar": true, // enable spawning sidecars
 "open": true // enable opening files/URLs using the default program
 }
 }
 }
}

其他api暂时不讨论，只说 execute，假设我们需要使用git命令（案例来自官网）

编辑 scope定义好需要用到的命令，要是没有定义则无法调用

{
 "scope": [
 {
 "name": "run-git-commit",
 "cmd": "git",
 "args": ["commit", "-m", { "validator": "\\S+" }]
 }
 ]
}

开始调用该命令

import { Command } from '@tauri-apps/api/shell'
const c = new Command('run-git-commit', ['commit', '-m', 'the commit message'])
const std = await c.execute();
std.stderr
std.stdout
std.code
std.signal

你可以将 args设置为 true来使js端可以传入任意参数

Tauri 文件访问api

Wed, 29 Nov 2023 22:07:56 +0800

tauri支持从$APPCONFIG, $APPDATA, $APPLOCALDATA, $APPCACHE, $APPLOG, $AUDIO, $CACHE, $CONFIG, $DATA, $LOCALDATA, $DESKTOP, $DOCUMENT, $DOWNLOAD, $EXE, $FONT, $HOME, $PICTURE, $PUBLIC, $RUNTIME, $TEMPLATE, $VIDEO, $RESOURCE, $APP, $LOG, $TEMP 访问并读或文件夹和文件，具体措施如下

编辑 tauri.conf.json内的tauri.allowlist.fs

{
 "tauri": {
 "allowlist": {
 "fs": {
 "all": true, // enable all FS APIs
 "readFile": true,
 "writeFile": true,
 "readDir": true,
 "copyFile": true,
 "createDir": true,
 "removeDir": true,
 "removeFile": true,
 "renameFile": true,
 "exists": true
 }
 }
 }
}

可以直接 all: true 来开放所有tauri文件api，也可以单独开放某个api

编辑 scope开放具体访问权限
```
{
 "tauri": {
 "allowlist": {
 "fs": {
 "scope": ["$APPDATA/img/*"]
 }
 }
 }
}
```
注意，这里开放了 $APPDATA下的 database访问权限，这样可以阻止程序访问任何路径，除了 database

从js中访问

import { readBinaryFile, BaseDirectory } from '@tauri-apps/api/fs'; // 可以是任何api
// Read the image file in the `$APPDATA/avatar.png` path
const contents = await readBinaryFile('img/avatar.png', { dir: BaseDirectory.AppData });
// 注意！一定要加上BaseDirectory.AppData

开放了哪个目录权限，就用 dir: BaseDirectory来指定访问路径，至少用绝对路径访问的方法我还没有找到，当然，这种相对路径访问的方式更加安全

从创建项目到测试打包上传Pypi

Mon, 30 Oct 2023 20:16:30 +0800

前言

这是一次从创建项目到测试打包上传Pypi的过程，记录一下。

创建项目

这里我是用的是pdm这个包管理工具，创建项目的命令是pdm init，跟着引导一步步走，之后会生成一个pyproject.toml文件，里面有项目的一些基本信息，比如作者、版本号等。下面是一个示例：

更优雅的包可用性检测

Sun, 06 Aug 2023 03:32:54 +0800

一般

try:
 import numpy
except ImportError:
 print("numpy is not installed")

更推荐

from importlib.util import find_spec

if find_spec("numpy") is not None:
 print("numpy is installed")
else:
 print("numpy is not installed")

Rich 使用PY在终端上展示富文本界面

Fri, 28 Jul 2023 02:15:54 +0800

安装

pip install rich

# PDM
pdm add rich

文档 & 源码

基础

from rich import print

print("Hello World")

Rich功能非常丰富，从日志处理到富文本显示甚至动态的终端界面。

要使用Rich用做界面的话，一般是这样的：

from rich.console import Console
from rich.layout import Layout
from rich.panel import

console = Console()
panel = Panel(name="panel_name")
layout = Layout(panel,name="layout_name")

界面Layout和面板Panel是经常要用到的东西，Layout作为界面布局，Panel内展示元素并风格化，比如经常使用的表格Table；要实现动态变化而不是print需要用到Live。

一个PY多数据源的统一入口思路

Fri, 21 Apr 2023 22:41:27 +0800

需求

以我的bot来说：

Bot:
├─config
├─core
├─modules
│ ├─required
│ │ ├─BotManager
│ │ ├─BotStatus
│ │ ├─ExceptionCatch
│ │ ├─...
│ └─self
│ ├─Modules1
│ ├─Modules2
│ ├─...
├─resources
├─service
└─utils

模块统一放在modules下，required是bot运行必须的模块，self是可卸载安装的模块。

Redis持久化策略

Fri, 14 Apr 2023 15:35:44 +0800

Redis是一种高性能的内存数据库，它支持多种数据结构，如字符串、列表、集合、散列、有序集合等。Redis的优点是速度快，操作简单，功能丰富，但是它也有一个缺点，就是数据都存储在内存中，一旦服务器宕机或者重启，数据就会丢失。为了解决这个问题，Redis提供了两种持久化机制，分别是RDB（快照）和AOF（追加文件）。

docker多阶段构建

Sat, 11 Mar 2023 10:11:37 +0800

非多阶段

以node项目为例：

FROM alpine

RUN mkdir -p /opt/app

WORKDIR /opt/app

COPY package.json package-lock.json ./

RUN apk add --no-cache --update nodejs npm

RUN apk add --no-cache \
 gcc \
 g++ \
 python3=3.10.10-r0 \
 make=4.3-r1 \
 pkgconf 

COPY . .

RUN npm install --production

EXPOSE 8080

CMD ["node", "main.js"]

这样虽然可以使用，但是很多依赖是生产环境下不需要受用的，比如build阶段的gcc以及npm等等

sqlalchemy&sqlmodel的commit后数据丢失问题

Sat, 11 Mar 2023 01:50:07 +0800

描述

print(user)
# name=user,age=18, ...

session.commit()

print(user)
# empty

原因

sqlalchemy为了保持session内的数据同步，默认了expire_on_commit为True，它表现在：

# 查询
b = session.query(User).filter(User.id==2).first()

# 更改数据
b.name = "user_b"
session.add(b)
session.flush()
session.commit()

# commit后再次访问，其实是重新进行了select操作
b.name
# user_b

expire_on_commit可以用来更改 SQLAlchemy 的对象刷新机制，默认值为True即在session调用commit之后会主动将同一个session在commit之前查询得到的 ORM 对象的_sa_instance_state.expire属性设置为Flase，再次读取该对象属性时将重载这个对象，方法是重新调用之前的查询语句。

sqlmodel单与多数据库连接

Sat, 11 Mar 2023 01:48:02 +0800

连接单个数据库

from typing import Optional

from sqlmodel import Field, Session, SQLModel, create_engine

# 表
class Hero(SQLModel, table=True):
 id: Optional[int] = Field(default=None, primary_key=True)
 name: str
 secret_name: str
 age: Optional[int] = None
# 连接
engine = create_engine("sqlite:///database.db")

# 建表
SQLModel.metadata.create_all(engine)

连接多个数据库

from typing import Optional

from sqlmodel import Field, Session, SQLModel, create_engine
from sqlmodel.main import registry

# 表1
table1 = registry()

class Hero1(SQLModel, table=True, registry=table1):
 id: Optional[int] = Field(default=None, primary_key=True)
 name: str
 secret_name: str
 age: Optional[int] = None

# 表2
table2 = registry()

class Hero2(SQLModel, table=True, registry=table2):
 id: Optional[int] = Field(default=None, primary_key=True)
 name: str
 secret_name: str
 age: Optional[int] = None

# 连接1
engine1 = create_engine("sqlite:///database1.db")

# 连接2
engine2 = create_engine("sqlite:///database2.db")

# 建表1
Hero1.metadata.create_all(engine1)

# 建表2
Hero2.metadata.create_all(engine2)

一点优化

显然这样建多表会很麻烦，一种优化方案是：

sqlalchemy异步与同步方式获取自增id

Thu, 05 Jan 2023 00:19:10 +0800

同步

# sync_session
# example(id, name)
e = example(name="name1")
db.add(e)
db.flush()
print(e.id) # id = 1

异步

# async_session
# example(id, name)
e = example(name="name1")
db.add(e)
await db.flush()
await db.commit()
await db.refresh(e)
print(e.id) # id = 1

[myabtis-plus]XML中返回的id顺序问题

Thu, 22 Dec 2022 02:25:25 +0800

问题

<insert id="insertListIfNotExists" useGeneratedKeys="true" keyProperty="id">
 INSERT IGNORE INTO
 `tag` (name, create_time)
 VALUES
 <foreach collection="list" item="item" separator=",">
 (#{item.name}, #{item.createTime})
 </foreach>
 </insert>

useGeneratedKeys与INSERT IGNORE配合后，若插入顺序是

id:1 name: name1
id: null name: name2
id: null name: name3

返回的id会变成

[myabtis-plus]xml中的字段注入不生效

Thu, 22 Dec 2022 02:23:17 +0800

未声明则不插入

create_time是自动注入字段

xml是最终执行的sql命令，未声明加入则不会插入

<insert id="insertListIfNotExists" useGeneratedKeys="true" keyProperty="id">
 INSERT IGNORE INTO
 `tag` (name)
 VALUES
 <foreach collection="list" item="item" separator=",">
 (#{item.name})
 </foreach>
 </insert>

修改：

<insert id="insertListIfNotExists" useGeneratedKeys="true" keyProperty="id">
 INSERT IGNORE INTO
 `tag` (name, create_time)
 VALUES
 <foreach collection="list" item="item" separator=",">
 (#{item.name}, #{item.createTime})
 </foreach>
 </insert>

bot的一些反思

Sun, 25 Sep 2022 15:50:04 +0800

模块化

我现在是这样的

Bot:
└─config
└─db
└─modules
└─utils

config内包含所有模块用到的配置项
db内是实体类和业务语句的集合
utils内是一些公共工具

现在问题是，config与db非常难维护，一打开就是几百行语句，找起来都麻烦，数据库和配置项有一点不对整个bot就无法启动

PDM-更现代的python包管理器

Tue, 31 May 2022 15:57:23 +0800

PDM介绍

一个现代的 Python 包管理器，支持 PEP 582

跟pipenv与poetry有着相同功能
抛弃传统包管理器所需的虚拟环境 - PEP 582
比poetry更快的依赖解析
类似pnpm的中心化安装缓存
插件系统
PEP 621 元数据格式
兼容 PEP 517 的构建后端，用于构建发布包(源码格式与 wheel 格式)

Python中便捷的上下文管理器contextmanager

Sat, 14 May 2022 20:36:57 +0800

基本的上下文管理器

需要定义：

class ContextM:
 def __enter__():
 dosomethings()

 def __exit__():
 dosometings()

class AsyncContextM:
 async def __aenter__():
 await dosometings()

 async def __aexit__():
 await dosometings()

调用时使用with ContextM()或async with AsyncContextM

ContextManager

Python内置的一个很方便的生成上下文管理器的装饰器

在fastapi中使用loguru记录日志

Sat, 12 Mar 2022 17:54:22 +0800

日志重写

import logging
import os
import sys
from pprint import pformat
from loguru import logger
from config import settings


class InterceptHandler(logging.Handler):
 def emit(self, record):
 # Get corresponding Loguru level if it exists
 try:
 level = logger.level(record.levelname).name
 except ValueError:
 level = record.levelno

 # Find caller from where originated the logged message
 frame, depth = logging.currentframe(), 2
 while frame.f_code.co_filename == logging.__file__:
 frame = frame.f_back
 depth += 1

 logger.opt(depth=depth, exception=record.exc_info).log(
 level, record.getMessage()
 )


def format_record(record: dict) -> str:
 format_string = settings.config.LOG_FORMAT

 if record["extra"].get("payload") is not None:
 record["extra"]["payload"] = pformat(
 record["extra"]["payload"], indent=4, compact=True, width=88
 )
 format_string += "\n<level>{extra[payload]}</level>"

 format_string += "{exception}\n"
 return format_string


# it requires app init or won't be work
def logger_init():
 log_path_all = os.path.join(settings.config.log_path, settings.config.LOG_FILE)
 log_path_error = os.path.join(settings.config.log_error_path, settings.config.LOG_FILE)
 logging.getLogger().handlers = [InterceptHandler()]
 logger.configure(
 handlers=[{"sink": sys.stdout, "level": logging.DEBUG, "format": format_record}])
 # logger.add(config.LOG_DIR, encoding='utf-8', rotation="9:46")
 logger.add(log_path_all,
 rotation="00:00",
 retention="2 week",
 enqueue=True,
 diagnose=True,
 level="DEBUG",
 format=format_record
 )
 logger.add(log_path_error,
 rotation="00:00",
 retention="3 week",
 enqueue=True,
 backtrace=True,
 diagnose=True,
 level="ERROR",
 format=format_record
 )
 logger.debug('日志系统已加载\n\n\n')
 logging.getLogger("uvicorn.access").handlers = [InterceptHandler()]

在app中调用

app = FastAPI(
 title=config.settings.title,
 debug=config.settings.config.DEBUG
)
# app create frist, then init logger
logger_init()


origins = [
 "http://127.0.0.1",
 f"http://127.0.0.1:{config.settings.config.port}",
 "http://localhost",
 f"http://localhost:{config.settings.config.port}",
 # "*"
]

app.include_router(scraper.router)
app.include_router(works.router)
app.include_router(users.router)
app.add_middleware(
 CORSMiddleware,
 allow_origins=origins,
 allow_credentials=True,
 allow_methods=["*"],
 allow_headers=["*"],
)

if __name__ == '__main__':

 uvicorn.run(
 app='main:app',
 host='0.0.0.0',
 port=config.settings.config.port,
 reload=True, # should be False at production
 access_log=True,
 ws_ping_interval=300,
 ws_ping_timeout=300
 )

FastApi使用jwt-token进行验证

Sat, 12 Mar 2022 17:48:58 +0800

以Depends的方式定义jwt

from jose import JWTError, jwt
from passlib.context import CryptContext
from fastapi.security import OAuth2PasswordBearer
from fastapi import Depends, HTTPException, status
from db import Curd
from typing import Optional
from datetime import datetime
from config import settings
from utils import logger
from .db import get_db
from datetime import timedelta


pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
oauth2_schema = OAuth2PasswordBearer(tokenUrl="/users/login")


def hash_password(plain_password: str) -> str:
 return pwd_context.hash(plain_password)


def verity_password(plain_password: str, hashed_password: str) -> bool:
 return pwd_context.verify(plain_password, hashed_password)


async def jwt_authenticate_user(username: str, password: str):
 db = get_db()
 user = await Curd.get_user_by_name(await db.__anext__(), username)
 if not user:
 return False
 if not verity_password(password, user.password):
 return False
 return user


def created_access_token(data: dict, expires_delta: Optional[timedelta] = None):
 to_encode = data.copy()
 if expires_delta:
 expire = datetime.utcnow() + expires_delta
 else:
 expire = datetime.utcnow() + timedelta(minutes=settings.config.ACCESS_TOKEN_EXPIRE_MINUTES)
 to_encode.update({"exp": expire})
 encoded_jwt = jwt.encode(claims=to_encode, key=settings.default.SECRET_KEY, algorithm="HS256")
 return encoded_jwt


async def jwt_verity(token: str = Depends(oauth2_schema)):
 credentials_exception = HTTPException(
 status_code=status.HTTP_401_UNAUTHORIZED,
 detail="Could not validate credentials",
 headers={"WWW-Authenticate": "Bearer"},
 )
 try:
 playload = jwt.decode(token=token, key=settings.default.SECRET_KEY, algorithms=["HS256"])
 except JWTError as e:
 logger.error("验证出现错误:\n", e)
 raise credentials_exception
 else:
 return playload


async def jwt_get_current_user(playload: dict = Depends(jwt_verity)):
 db = get_db()
 user_id = int(playload.get("sub"))
 user = await Curd.get_user_by_id(await db.__anext__(), user_id=user_id)
 return user


async def jwt_verity_admin(playload: dict = Depends(jwt_verity)):
 db = get_db()
 user_id = int(playload.get("sub"))
 is_admin = playload.get("is_admin")
 if is_admin:
 user = await Curd.get_user_by_id(await db.__anext__(), user_id=user_id)
 if user.is_admin:
 return
 raise HTTPException(
 status_code=status.HTTP_401_UNAUTHORIZED,
 detail="Could not validate credentials",
 headers={"WWW-Authenticate": "Bearer"},
 )

需要分发token的url

router = APIRouter(
 prefix="/users",
 tags=["user"],
)

# it defind at dependencies.jwt
# oauth2_schema = OAuth2PasswordBearer(tokenUrl="/users/token")


@router.post("/register", response_model=UserToken)
async def user_register(user: OAuth2PasswordRequestForm = Depends(), db: AsyncSession = Depends(get_db)):
 if await Curd.is_user_name_exists(db, user.username):
 raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
 detail="username already exists")
 hashed_password = hash_password(user.password)
 new_user = UserCreate(id=worker.get_id(), name=user.username, password=hashed_password)
 await Curd.register_user(db, new_user)


@router.post("/login", response_model=UserToken)
async def user_login(user: OAuth2PasswordRequestForm = Depends()):
 user = await jwt_authenticate_user(username=user.username, password=user.password)
 if not user:
 raise HTTPException(
 status.HTTP_401_UNAUTHORIZED,
 detail="Incorrect username or password",
 headers={"WWW-Authenticate": "Bearer"},
 )
 access_token = created_access_token(data={"sub": str(user.id)})
 user_token = UserToken(username=user.name,
 access_token=access_token,
 token_type="bearer")
 return user_token

需要token进行访问限制的url

router = APIRouter(
 prefix="/works",
 tags=["works"],
)


@router.get("/get", response_model=Works)
async def test(
 order: int,
 nsfw: bool,
 page: int,
 sort: int,
 user: User = Depends(jwt_get_current_user),
 db: AsyncSession = Depends(get_db),
 ):
 works = await Curd.get_works(db, user.id, order, nsfw, page, sort)
 return works

Sqlalchemy-关于PyhtonORM的各种事

Sat, 12 Mar 2022 17:27:57 +0800

ORM

ORM：对象关系映射（Object Relational Mapping，简称ORM，或O/RM，或O/R mapping)，用于实现面向对象编程语言里不同类型系统的数据之间的转换

数据结构复习

Mon, 27 Dec 2021 00:41:50 +0800

1.什么是算法？

算法是计算机科学中的基本概念，是对特定问题的求解步骤

2.什么是算法的复杂度？

分为时间复杂度和空间复杂度，前者一般是指程序运行从开始到结束所需的时间，后者一般是指对应的程序从运行开始到结束所需的储存空间

JetBrains 系列关于登录验证的屏蔽方法

Sun, 26 Dec 2021 00:05:54 +0800

前言

Pycharm好像是3.X版本上的登录验证，IEDA应该是2.3，登录验证已经无法使用插件来绕过，这里记录一下新的方法。

此方法来源依旧是eval-reset插件的作者，使用到的开源项目地址或网站：

考试相关

Fri, 17 Dec 2021 23:24:56 +0800

Linux

基本的排错

检查端口是否打开
检查服务/容器是否启动
检查防火墙是否关闭
ftp中检查配置文件中的 ip 是否替换为了自己的ip
docker中注意容器的命名冲突

Centos的Apache部署web

Fri, 17 Dec 2021 22:28:33 +0800

前言

Apache程序是目前拥有很高市场占有率的Web服务程序之一，这里演示如何安装，并访问一个简单的index.html

开整

首先安装apache的软件包：

FTP的配置与遇到的问题

Wed, 15 Dec 2021 22:59:06 +0800

安装

# 安装
yum install vsftpd -y
yum install ftp -y
# 启用
systemctl restart vsftpd
systemctl enable vsftpd
# 处理配置文件
mv /etc/vsftpd/vsftpd.conf /etc/vsftpd/vsftpd.conf.bak
grep -v "#" /etc/vsftpd/vsftpd.conf.bak > /etc/vsftpd/vsftpd.conf
# 关闭SELinux
setenforce 0

修改配置文件：

vim /etc/vsftpd/vsftpd.conf

将以下内容复制进去（注意！将18行 pasv_address 等号后面的ip改为你自己云服务器的ip地址！！）

Docker-2021/12/10

Mon, 13 Dec 2021 20:02:55 +0800

Docker 是一个用于开发，交付和运行应用程序的开放平台。Docker 使您能够将应用程序与基础架构分开，从而可以快速交付软件。借助 Docker，您可以与管理应用程序相同的方式来管理基础架构。通过利用 Docker 的方法来快速交付，测试和部署代码，您可以大大减少编写代码和在生产环境中运行代码之间的延迟。

菜鸟教程--docker的优点

Note: 数据库原理与应用P113 sql表创建

Mon, 06 Dec 2021 11:28:11 +0800

CREATE TABLE Student(
Sno Char(3) NOT NULL PRIMARY KEY,
Sname CHAR(3) NOT NULL,
Ssex CHAR(2) NOT NULL,
Sbirthday datetime,
Class CHAR(5)
)
CREATE TABLE Teacher(
Tno CHAR(3) PRIMARY KEY,
Tname CHAR(4) NOT NULL,
Tsex CHAR(2) NOT NULL,
Tbirthday datetime,
Prof CHAR(6),
Depart VARCHAR(10) NOT NULL
)
CREATE TABLE Course(
Cno CHAR(5) NOT NULL PRIMARY KEY,
Cname VARCHAR(10) NOT NULL,
Tno CHAR(3) NOT NULL,
FOREIGN KEY (Tno) REFERENCES Teacher(Tno)
)
CREATE TABLE Score(
Sno CHAR(3) NOT NULL,
Cno CHAR(5) NOT NULL,
Degree Decimal(4,1)
FOREIGN KEY (Sno) REFERENCES Student(Sno),
FOREIGN KEY (Cno) REFERENCES Course(Cno)
)

哈夫曼编码的实现(python)

Sun, 21 Nov 2021 21:31:23 +0800

思路

~~C++实在是弄不懂~~

代码

from typing import List, Optional
class Node:
"""
结点
"""
def __init__(self):
self.name: Optional[str] = None
self.weight: Optional[int] = None
self.left_child: Optional[Node] = None
self.right_child: Optional[Node] = None
self.parent: Optional[Node] = None
class NodeCode:
"""
结点的编码
"""
def __init__(self, name: str, code: str):
self.name = name
self.code = code
def __str__(self):
return f"{self.name}:{self.code}"
class HaffumanTreeCode:
"""
哈夫曼树的编码
"""
def __init__(self):
self.code_list: List[NodeCode] = []
def append(self, code: NodeCode):
self.code_list.append(code)
def code(self, massage: str):
"""
针对编码表编码
:param massage: 需要编码的信息
:return:
"""
code = ""
for i in massage:
for n in self.code_list:
if n.name == i:
code += n.code
break
# raise ValueError(f"'{i}'不存在")
return code
def decode(self, code: str):
"""
针对编码表解码
:param code:需要解码的哈夫曼码
:return:
"""
out = ""
i = 0
while code:
code_need_match = code[0:i+1]
for n in self.code_list:
if n.code == code_need_match:
out += n.name
code = code[i+1:]
i = 0
break
i += 1
return out
def __str__(self):
"""
打印
:return:
"""
out = ""
for i in self.code_list:
out += i.__str__() + "\n"
return out.strip()
class HaffumanTree:
"""
哈夫曼树
"""
def __init__(self):
self.root = Node()
self.nodes: List[Node] = []
self.nodes_raw: List[Node] = []
self.codes: HaffumanTreeCode = HaffumanTreeCode()
def inser(self, newnode: Node):
for i in range(len(self.nodes)):
if self.nodes[i].weight < newnode.weight:
self.nodes.insert(i, newnode)
return
self.nodes.append(newnode)
def build_tree(self, name_list: List[str], weight_list: List[int]):
"""
创建哈夫曼树
:param name_list: 字符列表
:param weight_list: 权重列表
:return:
"""
# 队每个字符生成结点
while len(name_list) > 0:
max_weight = max(weight_list)
max_index = weight_list.index(max_weight)
max_name = name_list[max_index]
newnode = Node()
newnode.name = max_name
newnode.weight = max_weight
self.nodes.append(newnode)
name_list.remove(max_name)
weight_list.remove(max_weight)
# 保存源结点
self.nodes_raw = self.nodes[:]
# 创建新结点并生成树
while len(self.nodes) > 2:
left = self.nodes.pop()
right = self.nodes.pop()
newnode = Node()
newnode.weight = left.weight + right.weight
newnode.left_child = left
newnode.right_child = right
left.parent = newnode
right.parent = newnode
# 根据权重插入
self.inser(newnode)
left = self.nodes.pop()
right = self.nodes.pop()
self.root.weight = left.weight + right.weight
self.root.left_child = left
self.root.right_child = right
left.parent = self.root
right.parent = self.root
def make_code(self):
"""
生成编码表
:return:
"""
while len(self.nodes_raw):
node = self.nodes_raw.pop()
name = node.name
code = ""
while node.parent != self.root:
parent = node.parent
if parent.left_child == node:
code = "0" + code
elif parent.right_child == node:
code = "1" + code
node = parent
if self.root.left_child == node:
code = "0" + code
elif self.root.right_child == node:
code = "1" + code
self.codes.append(NodeCode(name, code))
def decode(self, code: str):
return self.codes.decode(code)
def code(self, massage: str):
return self.codes.code(massage)
if __name__ == '__main__':
h = HaffumanTree()
name_list = ["a", "b", "c", "d", "e"]
wight_list = [5, 11, 6, 21, 19]
h.build_tree(name_list, wight_list)
h.make_code()
print(f"编码表：\n{h.codes}")
print(f'bcacce编码为：{h.code("bcacce")}')
print(f'01001000001001解码为： {h.decode("0100100000100110")}')

Real-ESRGAN腾讯的类WIAFU2X二次元图片放大算法

Wed, 17 Nov 2021 21:45:51 +0800

项目地址：xinntao/Real-ESRGAN: Real-ESRGAN aims at developing Practical Algorithms for General Image Restoration. (github.com)

中文介绍：Real-ESRGAN/README_CN.md at master · xinntao/Real-ESRGAN (github.com)

使用方法

先进行下载，后解压缩，解压后文件如图

在这个文件夹路径内输入cmd，回车

输入cmd后回车

就来到了命令终端：

之后把要放大的图片放在这个文件夹内，比如我这里是test.jpg

Nginx反向代理中涉及Websocket的问题

Fri, 10 Sep 2021 11:37:42 +0800

也许是我这种小白在反向代理中最常面临的问题

Nas上挂载过很多自用的站点，提供包括影音、docker管理、qB客户端之类的服务，在穿透到云端并使用Nginx进行反向代理时经常会遇到各种各样无法访问的问题：

Win下挂载Webdav卡顿问题的解决方法

Sun, 05 Sep 2021 00:07:46 +0800

远程文件访问需求

家里的Nas里面有音乐、电影、动漫啥的需要在外面进行访问，如果是单纯的视听，那么解决方法非常多，docker就可以部署很多成品的影音娱乐应用，再对端口进行穿透即可访问。但我这里有个需求，有些动漫需要用第三方客户端加载弹幕才看的输出，这个第三方客户端也没有对远程视频文件进行支持，所以还是选择了将文件挂载到本地环境的方法。

Openwrt-从安装到插件设置记录

Sun, 15 Aug 2021 01:43:07 +0800

Openwrt

按照我浅显的了解，这是一个开源的路由系统，本质就是个用在路由器上的linux，具体的作用非常多，上网管控、广告屏蔽、dns管理、KMS破解、网易云灰色歌曲解锁、内网穿肉、游戏加速、分流分拨等等等等非常多的功能就不一一介绍。

PyMySQL基础使用

Fri, 13 Aug 2021 13:56:12 +0800

安装

pip install PyMySQL

连接

db = pymysql.connect(host="192.168.1.1", port=3306, user="root", password="password", database="database_name")
cursor = db.cursor()

查/增

sql_insert = """
INSERT INTO 表名(id, name, path)
VALUES (%s, %s, %s)
"""
# 无论数据库数据类型为int或date，全部使用py的字符串形式插入，所以使用%s
cursor.execute(sql_insert, (user_id, name, path)) # 这种可以有效避免因敏感字符而导致出现语法错误
db.commit() # 进行提交，否则无效
# 当数据源为http相关时，注意转义
import html
from pymysql.converters import escape_string
safe_data = escape_string(html.unescape(unsafe_data)) # unescape转义html字符，escape转义为可直接插入数据库的安全字符串
# 多数据一次插入
cursor.executemany(sql, info) # info可为list，循环按顺序进行插入
db.commit()

以及

因为图库已经快20g了，为了管理方便，顺便就上了mysql做数据管理，但有个问题，pymysql非异步，可能会造成bot的io堵塞，现在的数据量查询速度还算快，但要是时间久了就不一定；

Gogs-0.13Dev版本邮件服务设置失败方法

Sat, 24 Jul 2021 21:27:34 +0800

起因

因为Gitlab各种设置实在是繁琐+奇怪，受不鸟还是转回gogs了，秒重启+秒开真的舒服，Gitlab的消耗我的小Nas实在是受不起。

无语的折腾记录-Gitlab的STMP服务设置

Tue, 20 Jul 2021 14:39:06 +0800

自建Git - Gogs/Gitlab

代码修修改改多了，就有了版本控制的需求，Github是最好的选择，但对于个人来说，代码里面有非常重要的隐私信息，又需要方便的进行分享，于是就转到了自建git服务器。

FastApi应用-bot中挂载web服务

Tue, 15 Jun 2021 19:34:04 +0800

轻量web服务

介绍

FastAPI 是一个用于构建 API 的现代、快速（高性能）的 web 框架，使用 Python 3.6+ 并基于标准的 Python 类型提示。

FastAPI 框架，高性能，易于学习，高效编码，生产可用

《18岁的流水线》

Mon, 07 Jun 2021 13:07:04 +0800

https://www.youtube.com/watch?v=T3FpwfUlUnc

记录-软路由今天翻车了

Mon, 07 Jun 2021 09:46:40 +0800

起不动的主板

这玩意是去年十一月淘宝入手的，到手上差不多半年，中间开过穿透，开过docker，还用了AD guard和smart DNS，替代我之前N1的软路由工作，运行的也很稳，J1900的cpu占用都很少上40%，直到现在......

Mediawiki - 更专业的wiki网站程序

Tue, 01 Jun 2021 20:35:25 +0800

介绍

Mediawiki是非常著名的开源wiki程序，比起之前的Dokuwiki功能要更完善，也更专业，使用PHP+SQL开发，适合用于构建百科、知识库、在线文档、个人笔记之类的应用。它的优点如下

美观的界面和可视化编辑器
拥有丰富的官方插件支持
官方文档非常完善，对中文支持也很友好

部署

我依旧是使用docker部署的，手动部署环境本次不介绍~~（不会）~~

Dokuwiki搭建个人wiki

Mon, 31 May 2021 03:13:49 +0800

起因&需求

挺早之前有个整跑团的群友需要个地方存剧本和设定，也就是个小wiki，刚好最近用开源框架撘站也变得熟练了，于是到处搜索了一下，决定使用Dokuwiki来完成

Nginx反向代理和SSL部署

Sun, 30 May 2021 18:32:53 +0800

需求

我有几个小网站需要穿透出去，为了方便使用和安全，选择了直接使用Nginx实现反向代理和ssl的部署，另外还有一些简单的Nginx防护

反代实现
加密访问（仅本人访问）
SSL部署
Nginx防护恶意请求

反代实现

server
{
listen 80;
server_name www.your_url.com;
location / {
proxy_pass http://local456:port/;
}
}

这样就在80端口实现了对server_name 的反代操作，server_name填写外部请求的url，proxy_pass填写内部你需要反代出去的url

博客迁移至香港腾讯轻量应用云的记录

Wed, 26 May 2021 00:36:59 +0800

原因

申请不到公网ip，短期内也不考虑换宽带
就算申请到了也封80/443，我这个菜鸡无法解决这种高难度问题
将Nas上的wordpress穿透到云上的方案折腾而且不好用，现在考虑直接部署至云上

过程

看别人推荐，用了腾讯的香港轻量云，体验非常不错

all() 一个便利的多条件判断方法

Tue, 04 May 2021 13:43:48 +0800

一般的多条件判断

if 判断1 and 判断2 and 判断3:
run()

当语句非常长的时候，就显得难懂且不美观

all()方法多条件判断

if all([条件1, 条件2, 条件3]):
run()

all()传入一个可迭代对象，当所有条件为True时，返回True

CUAVbot--一个python构成的qq机器人

Mon, 03 May 2021 01:39:59 +0800

这个bot写了有段小时间了，一直没有做个总结之类的，正好最近使用了saya, ~~代码算是可以看了点~~，于是就准备做个小总结。

Bot是什么

输入 - 处理 - 结果

大致上就是如此，发送一句话，bot根据这句话进行处理，然后得到预期结果。很明显，bot就是IO密集型程序，使用异步的方式是最便捷也是最高效的，这里就要说下开发框架

pip 换源与临时换源

Fri, 19 Mar 2021 18:52:42 +0800

永久换源

pip config set global.index-url https://

临时换源

pip install --index-url https:// module
pip install module -i https://

常用源

清华大学 https://pypi.tuna.tsinghua.edu.cn/simple/
阿里云 http://mirrors.aliyun.com/pypi/simple/
中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/
豆瓣(douban) http://pypi.douban.com/simple/
中国科学技术大学 http://pypi.mirrors.ustc.edu.cn/simple/

其中中国科技大学还挺好

模拟登录相关

Wed, 05 Aug 2020 00:26:05 +0800

一个网页不需要登录，就可以随意访问网站的所有具体信息的话，那就好比是一个敞开了大门的网站，摆好酒桌好吃好喝招待爬虫脚本们，数据提取的成本非常低。于是比较常规的网站，都会使用账号登录来提高网站对于每个想要查看网站数据的门槛，所以模拟登陆的问题就是必修课

Scrapy+随机User-Again+随机高匿代理ip爬取全球最大的同人网站上万条信息

Thu, 30 Jul 2020 00:48:22 +0800

确定需求

DLsite是全球最大的同人贩卖网站，里面包括漫画、音声、动画、游戏等等来自不同国家不同地区不同语言以及不同形式的二次元创作作品，这个项目暂定是爬取home下的所有漫画信息作为统计数据，链接为：

scrapy+mysql:2006错误解决方法

Tue, 28 Jul 2020 16:27:34 +0800

首先放上piplines的代码

from itemadapter import ItemAdapter
import MySQLdb
import logging
class TestRjPipeline:
def __init__(self):
host = ('localhost')
user = ('root')
pass_ = ('123456')
db = ('sqlforpy')
self.connect = MySQLdb.connect(host,user,pass_,db,charset='utf8mb4')
self.cursor = self.connect.cursor()
def process_item(self, item, spider):
def get_data(items_):
data = dict(items_)
rj={'ID':'无','title':'无','circle':'无','keyword_creater':'无','data':'无','sname':'无'\
,'GEN':'无','type_':'无','category':'无','other':'无','pages':'无','genre':'无',\
'file_':'无','event':'无'}
for k in data.items():
rj[k[0]] = k[1]
return rj
rj = get_data(item)
sql = r"""insert into dlsite_cg_copy1(RJ,标题,社团,作者,发售日,系列名,年龄指定,文件形式,作品类型,其他,页数,分类,文件容量,活动)VALUES("%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s")"""% (rj['ID'],rj['title'],rj['circle'],rj['keyword_creater'],rj['data'],rj['sname'],rj['GEN'],rj['type_'],rj['category'],rj['other'],rj['pages'],rj['genre'],rj['file_'],rj['event'])
try:
self.cursor.execute(sql)
self.connect.commit()
except:
logging.debug('%s写入数据库出现错误！'%rj['ID'])
logging.debug('内容为:\n{}\n'.format(rj))
self.connect.rollback()
logging.debug('此次保存操作结束')
def close_spider(self, spider):
self.cursor.close()
self.connect.close()

start之后，总是只能保存第一条信息，然后一直显示2006错误

关于ValueError: too many values to unpack错误

Mon, 27 Jul 2020 14:38:07 +0800

在写scrapy的时候遇到的一个坑，准备了一个由“无”元素作为value的字典作为蓝本，遍历从scrapy上得到的items字典数据，把其中有的元素放到第一个作为蓝本的字典中，于是这里就有两个操作，读取第二个字典，修改第一个字典

实战：comic walker漫画多章节爬虫

Wed, 15 Jul 2020 10:57:00 +0800

为什么要做

还在做汉化组的扒图的时候，一直觉得comic walker这个站点的漫画拔起来非常麻烦，因为它自带一个阅读器界面，异步加载图片，而且无法右键，甚至在网页元素中，也无法直接保存图片（这应该是漫画网站的常见配置了），只能一个个在控制台中拖动图片至新的标签页才能加载图片并保存，十分麻烦，正好学习python中，就写了这个小工具。

json文件转xls文件

Sat, 27 Jun 2020 14:26:12 +0800

#写成json的文本文件内容，转换为xls文件
import xlwt
import os
import json
def get_(path):
with open(path,'r',encoding='utf-8') as f:
content=f.read()
return content
def json_(str):
d=json.loads(str)
d=sorted(d.items(),key=lambda item:item[0],reverse=False)
return d
def json_16(str):
d=json.loads(str)
return d
def save_(d,path):
workbook=xlwt.Workbook(encoding='utf-8')
sheet1=workbook.add_sheet('sheet1')
r=0
c=1
for key,value in d:
sheet1.write(r,0,key)
for i in value:
sheet1.write(r,c,i)
c+=1
r+=1
c=1
workbook.save(path)
def save_16(d,path):
workbook=xlwt.Workbook(encoding='utf-8')
sheet1=workbook.add_sheet('sheet1')
for a,b in enumerate(d):
for c,v in enumerate(b):
sheet1.write(a,c,v)
workbook.save(path)
if __name__ == "__main__":
p1=r'E:\vscode\code\testwork\txtfile\5.txt'
p2=r'E:\vscode\code\testwork\txtfile\5.xls'
save_16(json_16(get_(p1)),p2)
print('END')

实战：词云生成

Sat, 27 Jun 2020 14:21:00 +0800

import re
import jieba
import collections
import numpy as np
import wordcloud # 词云展示库
from PIL import Image # 图像处理库
import matplotlib.pyplot as plt # 图像展示库
def remove():
with open('remove_words.txt','r',encoding='utf-8') as f:
txt=f.read()
words = re.findall(r'[^\s]+',txt)
list_=[]
for i in words:
if i in list_:
continue
else:
list_.append(i)
return list_
def get_words(path):
f=open(path,encoding='utf-8')
txt=f.read()
f.close()
words = jieba.lcut(txt)
remove_word=remove()
reword = []
for word in words:
if len(word) == 1:
continue
elif word in remove_word:
continue
else:
reword.append(word)
word_counts=collections.Counter(reword)
return word_counts
#统计词频
def wordcount(word_counts):
top=word_counts.most_common(20)
print(top)
def wordc(impath,words):
mask=np.array(Image.open(impath))
wc = wordcloud.WordCloud(
font_path='C:/Windows/Fonts/simhei.ttf', # 设置字体格式
mask=mask, # 设置背景图
max_words=600, # 最多显示词数
max_font_size=130 # 字体最大值
)
wc.generate_from_frequencies(words) # 从字典生成词云
image_colors = wordcloud.ImageColorGenerator(mask) # 从背景图建立颜色方案
wc.recolor(color_func=image_colors) # 将词云颜色设置为背景图方案
plt.imshow(wc) # 显示词云
plt.axis('off') # 关闭坐标轴
plt.show() # 显示图像
wc.to_file('ff.png')
if __name__ == "__main__":
path=r'E:\vscode\code\ff.txt'
impath=r'E:\vscode\code\topdodo_2.jpg'
wordc(impath,get_words(path))

实战：RJ爬虫并上传本地SQL

Sat, 27 Jun 2020 14:18:00 +0800

下载了上百个RJ后，如何根据声优或分类喜好来找到自己喜欢的作品就成了个问题，于是诞生出了这个代码

问题拆分

定位需求

查询RJ主要是在对该RJ文件夹对应网页中的标题、声优、制作社团与分类，拿到具体数据后，对数据进行查询操作。

生成四位验证码并验证

Sat, 27 Jun 2020 14:15:00 +0800

#四位数数字字母验证码，显示进行输入判断验证
from PIL import Image, ImageFilter, ImageFont,ImageDraw
import os
import random
import string
import matplotlib.pyplot as plt
# ImageFilter:Python中的图像滤波，主要对图像进行平滑、锐化、边界增强等滤波处理。
#随机选取一个数字字母，含大小写
def get_word():
word = string.ascii_letters+string.digits
return random.choice(word)
#字体像素随机颜色
def font_color():
#random.randint()在范围内取随机数
return(random.randint(32,255),random.randint(23,255),random.randint(32,255))
#背景像素随机颜色
def b_color():
return(random.randint(64,255),random.randint(64,255),random.randint(64,255))
#生成验证码图像，返回一个字符串，表示验证码
def imag(path):
w = 60*4
h = 60
d_word=''
#新建图像对象
img = Image.new('RGB',(w,h),(255,255,255))
#字体对象
font = ImageFont.truetype(r'H:\gay化\汉化\字体\4书法 - 2\FZ宋s刻d本r秀d楷繁.ttf',60)
#类似于画笔
draw = ImageDraw.Draw(img)
for i in range(w):
for j in range(h):
#画背景，用随机颜色填充每个像素
draw.point((i,j),fill=b_color())
for i in range(4):
word=get_word()
#draw.text方法进行字符绘图，()内：绘图位置，字符，字体，颜色
draw.text((i*60+10,5),word,font=font,fill=font_color())
#单个验证码相加
d_word = d_word + word
#保存验证码图像
img.save(path,'jpeg')
#返回验证码
return d_word
#一个输入函数，调用时返回输入内容
def get_input():
return str(input('请输入验证码:\n'))
#运行
if __name__ == "__main__":
path = ('test.jpg')
str_=imag(path)
test_img=Image.open(path)
plt.figure('test')
plt.imshow(test_img)
plt.show()
#四次机会
for i in range(4):
if str.lower(str_) == str.lower(get_input()):
print('验证成功')
break
else:
if i == 3:
print('错误次数已用完！')
else:
print('错误！还有%d次机会'%(3-i))
#结束后删除验证码图像
os.remove(path)

图片等比例缩放实现

Sat, 27 Jun 2020 14:11:00 +0800

#设定一个分辨率，使一个文件夹内所有大于该分辨率的图像都进行等比例缩放
import os
import re
from PIL import Image
#设置目录
f_path = 'E:/vscode/code/testwork/testFile'
#设置iPhone5的分辨率
i_high = 640
i_width = 1136
#使用os.listdir()方法，将目录内的图像文件名，以列表的形式存入list
list=os.listdir(f_path)
#设置计数初始值
count = 0
#对每个文件进行判断
for pic in list:
#path为完整的图像文件路径
path=f_path+'/'+pic
#使用Image.open()方法，打开图像文件
im=Image.open(path)
#im.size方法获得图像的宽高，分别存入w,h
w,h=im.size
#当宽度大于i5
if w > i_width:
#这里判断：原图像哪边大则依据哪边作为等比缩放比例
if w>h:
w_new = i_width
h_new = int(h*i_width/w)
else:
w_new = int(w*i_high/h)
h_new = i_high
print('%s被修改' %pic)
#使用resize()方法修改分辨率，((w,h),此处Image.ANTIALIAS表示高质量)
out = im.resize((w_new,h_new),Image.ANTIALIAS)
#使用re.sub方法，在字符串pic中，开头至倒数第四位字符替换为添加_new的字符串
newpic = re.sub(pic[:-4],pic[:-4]+'_new',pic)
#处理后的图像的完整保存路径
new_path = f_path+'/'+newpic
#save方法保存
out.save(new_path)
#处理完毕计数+1
count = count + 1
elif h > i_high:
if w>h:
w_new = i_width
h_new = int(h*i_width/w)
else:
w_new = int(w*i_high/h)
h_new = i_high
print('%s被修改' %pic)
out = im.resize((w_new,h_new),Image.ANTIALIAS)
newpic = re.sub(pic[:-4],pic[:-4]+'_new',pic)
new_path = f_path+'/'+newpic
out.save(new_path)
count = count + 1
print('处理结束\n总共有%d个文件被处理' %count)

实战：通话统计及简易图表制作

Sat, 27 Jun 2020 14:08:00 +0800

最开始的看到的python基础习题之一，现在顺便扩展一点，练习xlrd、pandas以及matplotlib的练习

数据来源

来自于联通官网的通话数据下载，文件为某年某月的通话记录详情，格式为xls**[图片缺失: 2020/06/QQ截图20200627215145.png]**

文本识别屏蔽词转换

Sat, 27 Jun 2020 14:01:00 +0800

#2020/3/10
#设置一个屏蔽词文本，输入一段字符串，将其中的屏蔽词转换成*
import re
#参数为路径，返回整个屏蔽词文本
def get_f(path):
f = open(path,'r',encoding='utf-8')
art=f.read()
f.close()
return art
#参数为字符串，返回一个屏蔽词列表
def get_list(str):
list_=[]
word = re.findall(r'[^\s]+',str)
for i in word:
list_.append(i.lower())
return list_
#参数i为输入，b为屏蔽词列表
def pri(i,b):
ww=[]
ww.append(i)
h=0
for n in b:
if re.findall(n,ww[h]) != []:
s='*'*len(n)
p = re.sub(n,s,ww[h])
h+=1
ww.append(p)
if h != 0:
#print('共替换了%d个词'%h)
return ww[h]
else:
return i
#run
if __name__ == "__main__":
path=r'E:\vscode\code\ban.txt'
b=get_list(get_f(path))
#print(b)
i=str(input('输入：\n'))
print(pri(i,b))

随机码生成

Fri, 26 Jun 2020 14:16:19 +0800

#生成自定义数量由大小写字母与数字随机组成的号码/激活码，然后存入mysql数据库
import random
import string
import MySQLdb
#获取号码
def GenKey(length): #length为号码长度
chars = string.ascii_letters + string.digits #string.ascii.letters是26个英文字母的大小写[a-z A-Z],string.digits为[0-9]相加作为字典
return ''.join([random.choice(chars) for i in range(length)])
#拿出chars内的一个字符并重复进行length次，将得到的字符与空字符串相加，得到长度为length的号码
#保存号码
def SaveKey(content):
f = open('Result Key.txt', 'a')
#打开Result Key.txt，a表示“打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。”
f.write(content)
#写入一个content，此处为号码
f.write('\n')
#换行
f.close()
#关闭
#保存至mysql数据库
def save_sql(code_nu):
host = ("localhost")
user = ("root")
pass_ = ("123456")
db = ("sqlforpy")
#建立连接
connect = MySQLdb.connect(host,user,pass_,db)
#使用cursor()方法获取操作游标 （在操作游标中才可进行数据库操作
cursor = connect.cursor()
#使用insert into进行插入数据
sql = "insert into code(code)VALUES('%s')" % code_nu
#执行sql语句
cursor.execute(sql)
#使用commit提交到数据库执行保存
connect.commit()
#关闭连接
connect.close()
if __name__ == '__main__':
length=int(input("\n请输入需要的号码个数："))
for i in range(length):
value = GenKey(20)
print (value)
#SaveKey(value)
save_sql(value)

统计英文单词词频

Wed, 24 Jun 2020 14:18:03 +0800

#读取一个纯英文的文本文件，统计其中每个单词的出现次数，并将次数和其单词本身存入mysql数据库
import re
import MySQLdb
#读取文件信息
filename="word.txt"
#使用open方法操作文本文件，r表示以只读方式打开文件。文件的指针将会放在文件的开头
f=open(filename,'r')
#使用f.read方法返回整个文本文件给article，
artical=f.read()
#使用f.close关闭文件
f.close()
#将文本中的所有英文单词筛选出来 去掉标点和其他文本符号 并且将单词都小写保存在数组List中
List=[]
#'[a-zA-Z]+'正则表达式，表示大小写a-z出现一次或连续出现，这里表达一个单词
#使用re.findall方法，从article中获取单词，作为list存入word中
word=re.findall('[a-zA-Z]+',artical)
for i in word:
List.append(i.lower())
#把单词与出现的次数存入数据库（我也不知道为什么要存进去:)
def save_sql(word,numbers):
host = ("localhost")
user = ("root")
pass_ = ("123456")
db = ("sqlforpy")
#建立连接
connect = MySQLdb.connect(host,user,pass_,db)
#使用cursor()方法获取操作游标 （在操作游标中才可进行数据库操作
cursor = connect.cursor()
#使用insert into进行插入数据
sql = "insert into count_word(word,numbers)VALUES('%s','%d')" % (word,numbers)
#执行sql语句
try:
cursor.execute(sql)
#使用commit提交到数据库执行保存
connect.commit()
except:
#发生错误时回滚
connect.rollback()
#关闭连接
connect.close()
#统计单词数目
print("%s总共有%d个单词" %(filename,List.__len__()))
#统计各个单词出现的频率，并且按照字典顺序输出并将内容写入文件中
#f=open("result.txt",'w')
List=sorted(List)
i=0
for i in range(0,List.__len__()-1):
#使用count方法获得字符串出现的次数
count=List.count(List[i])
if(List[i]!=List[i+1]):
#print(List[i]+" "+str(count)+"\n")
#f.write(List[i]+" "+str(count)+"\n")
save_sql(List[i],count)

统计文件夹内所有文件的词频

Tue, 23 Jun 2020 14:20:22 +0800

#在一个文件夹内存放着几个纯英文文本，统计其中出现次数最多的单词
import os
import re
f_dir='E:/vscode/code/testwork/txtfile'
f_list=os.listdir(f_dir)
List=[]
dict={}
#传入文件名，返回文本文件路径
def get_f(name):
return f_dir+'/'+name
#传入文件路径，返回文件内文本（字符串
def open_f(fdir):
f = open(fdir,'r',encoding='UTF-8')
artical=f.read()
f.close()
return artical
#传入字符串，找出其中的单词统一小写，并以list形式添加到List中
def get_w(file):
word=re.findall('[a-zA-Z]+',file)
for i in word:
List.append(i.lower())
#传入一个list，将其排序后，提取每个单词与其出现的次数，以字典形式存放于dict
def get_c(w_list):
s_list=sorted(w_list)
i = 0
for i in range(0,s_list.__len__()-1):
count=s_list.count(s_list[i])
if(s_list[i]!=s_list[i+1]):
dict[s_list[i]]=count
if __name__ == "__main__":
art=''
for i in f_list:
f_path=get_f(i)
art=art+open_f(f_path)
get_w(art)
get_c(List)
#用max方法找出字典内values最大的值
highest=max(dict.values())
print('所有文件共有%d个单词'%List.__len__())
print('出现最多次的单词：')
#用最大值去提取与其相匹配的key，得到一个或多个出现次数最高的单词
print([k for k,v in dict.items() if v == highest])
print('总共出现了%d次'%highest)

统计文件夹内所有代码文件的代码行、注释行和空行

Mon, 22 Jun 2020 14:22:01 +0800

#有一个文件夹内存放着代码文件，统计所有文件的代码行，注释行和空行的总数
import os
def j_anno(line):
if line.strip().startswith("#"):
return True
else:
return False
def j_annos(line):
if line.strip().startswith("'''") or line.strip().startswith('"""'):
return True
else:
return False
path='E:/vscode/code/testwork'
code_line=0
comm_line=0
space_line=0
for root,dirs,files in os.walk(path):
for item in files:
f_path=os.path.join(root,item)
f_exten=os.path.splitext(f_path)[1]
if f_exten == '.py':
with open(f_path,'r',encoding='utf-8') as fp:
#print('key:',key)
#print('value:',value)
while True:
line=fp.readline()
if not line:
break
elif j_anno(line):
comm_line +=1
elif j_annos(line):
while True:
line=fp.readline()
if j_annos(line):
break
else:
comm_line +=1
elif line.strip():
code_line+=1
else:
space_line+=1
#test
print('目录：%s总共有:\n%d行代码\n%d行注释\n%d个空行'%(path,code_line,comm_line,space_line))

哈希加密验证尝试

Sun, 21 Jun 2020 14:27:06 +0800

#加入随机salt的哈希运算验证
import random
from hashlib import sha256
from hmac import HMAC
#意义在于，随机halt哈希混淆运算后的数据极难被反推出密码原文，彩虹字典的暴力破解难度极大
#参数r_pass为密码原文，salt可选，返回一个带slat与加密后的字符串
def get_pass(r_pass,salt=None):
if salt == None:
salt=sha256(str(random.random()).encode('utf-8')).hexdigest()[-8:]
#先生成一个HMAC()对象，然后再调用digest()生成hash之后的结果
password=HMAC(salt.encode('utf-8'),r_pass.encode('utf-8'),sha256).hexdigest()
return ('%s$%s'%(salt,password))
#参数r_pass为再次输入的原文密码，password为第一次哈希后的字符串
def check_pass(r_pass,password):
salt=password.split('$')[0]
return password == get_pass(r_pass,salt)
#run
if __name__ == "__main__":
password=input('请输入密码：\n')
p=get_pass(password)
while True:
pass_=input('请再次输入密码：\n')
if check_pass(pass_,p):
print('密码正确')
break
else:
print('密码错误')

未读消息图标模拟

Fri, 29 May 2020 14:15:00 +0800

from PIL import Image,ImageFont,ImageDraw
import sys
reload(sys) #必须要reload
sys.setdefaultencoding('utf-8') #字符编码改为utf8
headPath=r""
#头像图片路径
output=r""
#处理后输出路径
fontPath=r""
#字体路径
headFile="" #头像文件
outFile="" #输出文件
#打开图片建立画布
image=Image.open(headPath+headFile,r)
draw=ImageDraw.Draw(image)
#由图片大小确定字体大小
fontsize=min(image.size)/4
#增加文字
fontobj=ImageFont.truetype(font=fontPath+"AdobeHeisistd-Regular.otf",size=fontsize,index=0,encoding=",filename=None)#
"""
"""
from PIL import Image,ImageFont,ImageDraw#从PIL库导入所需模块
import sys
reload(sys) #必须要reload
sys.setdefaultencoding('utf-8')#字符编码改为utf8
headPath=r"E:\\vscode\\code\\testwork\\testFile\\"
#头像图片路径
outputPath=r"C:E:\\vscode\\code\\testwork\\testFile\\output\\"
#处理后输出路径
fontPath=r"C:\\Windows\\Fonts\\"
#字体路径
headFile="head.jpg" #头像文件
outFile="output.jpg" #输出文件
#打开图片，建立画布
image=Image.open(headPath+headFile,'r')
draw=ImageDraw.Draw(image)
#由图片大小确定字体大小
fontsize=min(image.size)/4
#增加文字
fontobj=ImageFont.truetype(font=fontPath+"AdobeHeitiStd-Regular.otf",size=fontsize,index=0,encoding='',filename=None)#实例字体对象
draw.text((image.size[0]-fontsize,0),text="5",fill=(255,0,0),font=fontobj,anchor=None)#用draw对象的text()方法添加文字
image.save(outputPath+outFile)#保存图片
"""
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2016/12/12 上午10:13
# @Author : hukezhu
# @Site :
# @File : 0000:添加未读消息.py
# @Software: PyCharm
from PIL import Image, ImageDraw, ImageFont
#创建图片对象
headImage = Image.open('E:/vscode/code/testwork/testFile/head.jpg')
#获取图片对象的宽高
w,h = headImage.size
#创建字体对象
font = ImageFont.truetype('C:/Windows/Fonts/Arial.ttf',int(h/4))
#绘制圆形
ImageDraw.Draw(headImage).pieslice([(w/3*2,0),(w,h/3)],0,360,fill='red')
ImageDraw.Draw(headImage).text((w*0.76,h*0.02),'3',font = font, fill = 'white')
#展示绘制结果(使用系统默认的图片浏览器)
#headImage.show()
#保存绘制结果
headImage.save('E:/vscode/code/testwork/testFile/wode.jpg')

SQL笔记

Sun, 23 Feb 2020 05:51:45 +0800

SQL简介

SQL = Structured Query Language

总的来说，SQL语言定义了这么几种操作数据库的能力：

DDL：Data Definition Language
- DDL允许用户定义数据，也就是创建表、删除表、修改表结构这些操作。通常，DDL由数据库管理员执行。
DML：Data Manipulation Language
- DML为用户提供添加、删除、更新数据的能力，这些是应用程序对数据库的日常操作。
DQL：Data Query Language
- DQL允许用户查询数据，这也是通常最频繁的数据库日常操作

数据库类别

关系型数据库(SQL)
非关系型数据库(NoSQL) - MongoDB, Cassandra, Dynamo

关系模型

主键

主键是关系表中记录的唯一标识。选取主键的一个基本原则是：不使用任何业务相关的字段作为主键。