Python on kutake小站

在有共同字段下的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格式解决，而字体加载就难了。

从创建项目到测试打包上传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是可卸载安装的模块。

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

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)，用于实现面向对象编程语言里不同类型系统的数据之间的转换

哈夫曼编码的实现(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")}')

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堵塞，现在的数据量查询速度还算快，但要是时间久了就不一定；

FastApi应用-bot中挂载web服务

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

轻量web服务

介绍

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

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

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')