:::note{title="注"}
很简单的一个注册表修改，就可以做到让windows永久性暂停更新，想要多久就久，由你来定！
:::

```reg
Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\WindowsUpdate\UX\Settings]
"FlightSettingsMaxPauseDays"=dword:00001b58
"PauseFeatureUpdatesStartTime"="2023-08-17T10:00:52Z"
"PauseFeatureUpdatesEndTime"="2222-09-05T09:59:52Z"
"PauseQualityUpdatesStartTime"="2023-08-17T10:00:52Z"
"PauseQualityUpdatesEndTime"="2222-09-05T09:59:52Z"
"PauseUpdatesStartTime"="2023-08-17T09:59:52Z"
"PauseUpdatesExpiryTime"="2222-09-05T09:59:52Z"

```



把其中的StarTime改成将来的某一时刻，只要是你执行这个操作的下一秒钟就行。
EndTime改成你想要的时间，即什么时候恢复更新。

然后把上面的内容复制到一个空的txt文档文件中，另存为“文件名.reg”即可。
注意：要把.txt变成.reg，如果不会的继续往下看，怎么让系统显示文件扩展名。


![微信截图_20230817082850.png](https://blog.kyln.fun/static/img/49dc26aaee43207f2563eaa1a6755902.%C3%A5%C2%BE%C2%AE%C3%A4%C2%BF%C2%A1%C3%A6%C2%88%C2%AA%C3%A5%C2%9B%C2%BE_20230817082850.webp)

如上图，双击你桌面上的“计算机”或者叫“此电脑”，或者win键+E打开资源管理器，点“查看”，然后勾选“文件扩展名”，就可以看到所有文件的扩展名了。

永久暂停windows更新的方法

今天分享几段工作生活中常用的代码，都是最为基础的功能和操作，而且大多还都是出现频率比较高的，很多都是可以拿来直接使用或者简单修改就可以放到自己的项目当中

## 日期生成
很多时候我们需要批量生成日期，方法有很多，这里分享两段代码

获取过去 N 天的日期

```python
import datetime

def get_nday_list(n):
 before_n_days = []
 for i in range(1, n + 1)[::-1]:
 before_n_days.append(str(datetime.date.today() - datetime.timedelta(days=i)))
 return before_n_days

a = get_nday_list(30)
print(a)
```



Output:

['2021-12-23', '2021-12-24', '2021-12-25', '2021-12-26', '2021-12-27', '2021-12-28', '2021-12-29', '2021-12-30', '2021-12-31', '2022-01-01', '2022-01-02', '2022-01-03', '2022-01-04', '2022-01-05', '2022-01-06', '2022-01-07', '2022-01-08', '2022-01-09', '2022-01-10', '2022-01-11', '2022-01-12', '2022-01-13', '2022-01-14', '2022-01-15', '2022-01-16', '2022-01-17', '2022-01-18', '2022-01-19', '2022-01-20', '2022-01-21']

## 生成一段时间区间内的日期
```python
import datetime

def create_assist_date(datestart = None,dateend = None):
 # 创建日期辅助表

 if datestart is None:
 datestart = '2016-01-01'
 if dateend is None:
 dateend = datetime.datetime.now().strftime('%Y-%m-%d')

 # 转为日期格式
 datestart=datetime.datetime.strptime(datestart,'%Y-%m-%d')
 dateend=datetime.datetime.strptime(dateend,'%Y-%m-%d')
 date_list = []
 date_list.append(datestart.strftime('%Y-%m-%d'))
 while datestart<dateend:
 # 日期叠加一天
 datestart+=datetime.timedelta(days=+1)
 # 日期转字符串存入列表
 date_list.append(datestart.strftime('%Y-%m-%d'))
 return date_list

d_list = create_assist_date(datestart='2021-12-27', dateend='2021-12-30')
d_list
```
Output:

['2021-12-27', '2021-12-28', '2021-12-29', '2021-12-30']
## 保存数据到CSV
保存数据到 CSV 是太常见的操作了，分享一段我个人比较喜欢的写法
```python
def save_data(data, date):
 if not os.path.exists(r'2021_data_%s.csv' % date):
 with open("2021_data_%s.csv" % date, "a+", encoding='utf-8') as f:
 f.write("标题,热度,时间,url\n")
 for i in data:
 title = i["title"]
 extra = i["extra"]
 time = i['time']
 url = i["url"]
 row = '{},{},{},{}'.format(title,extra,time,url)
 f.write(row)
 f.write('\n')
 else:
 with open("2021_data_%s.csv" % date, "a+", encoding='utf-8') as f:
 for i in data:
 title = i["title"]
 extra = i["extra"]
 time = i['time']
 url = i["url"]
 row = '{},{},{},{}'.format(title,extra,time,url)
 f.write(row)
 f.write('\n')
```
## 带背景颜色的 Pyecharts
Pyecharts 作为 Echarts 的优秀 Python 实现，受到众多开发者的青睐，用 Pyecharts 作图时，使用一个舒服的背景也会给我们的图表增色不少

以饼图为例，通过添加 JavaScript 代码来改变背景颜色
```python
def pie_rosetype(data) -> Pie:
 background_color_js = (
 "new echarts.graphic.LinearGradient(0, 0, 0, 1, "
 "[{offset: 0, color: '#c86589'}, {offset: 1, color: '#06a7ff'}], false)"
)
 c = (
 Pie(init_opts=opts.InitOpts(bg_color=JsCode(background_color_js)))
 .add(
 "",
 data,
 radius=["30%", "75%"],
 center=["45%", "50%"],
 rosetype="radius",
 label_opts=opts.LabelOpts(formatter="{b}: {c}"),
 )
 .set_global_opts(title_opts=opts.TitleOpts(title=""),
 )
 )
 return c
```
## requests 库调用
据统计，requests 库是 Python 家族里被引用的最多的第三方库，足见其江湖地位之高大！

发送 GET 请求
```python
import requests


headers = {
 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36',
 'cookie': 'some_cookie'
}
response = requests.request("GET", url, headers=headers)
```
发送 POST 请求
```python
import requests


payload={}
files=[]
headers = {
 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36',
 'cookie': 'some_cookie'
}
response = requests.request("POST", url, headers=headers, data=payload, files=files)
```
根据某些条件循环请求，比如根据生成的日期
```python
def get_data(mydate):
 date_list = create_assist_date(mydate)
 url = "https://test.test"
 files=[]
 headers = {
 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36',
 'cookie': ''
 }
 for d in date_list:
 payload={'p': '10',
 'day': d,
 'nodeid': '1',
 't': 'itemsbydate',
 'c': 'node'}
 for i in range(1, 100):
 payload['p'] = str(i)
 print("get data of %s in page %s" % (d, str(i)))
 response = requests.request("POST", url, headers=headers, data=payload, files=files)
 items = response.json()['data']['items']
 if items:
 save_data(items, d)
 else:
 break
```
## Python 操作各种数据库
### 操作 Redis
连接 Redis
```python
import redis


def redis_conn_pool():
 pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
 rd = redis.Redis(connection_pool=pool)
 return rd
```
写入 Redis
```python
from redis_conn import redis_conn_pool


rd = redis_conn_pool()
rd.set('test_data', 'mytest')
```
### 操作 MongoDB
连接 MongoDB
```python
from pymongo import MongoClient


conn = MongoClient("mongodb://%s:%s@ipaddress:49974/mydb" % ('username', 'password'))
db = conn.mydb
mongo_collection = db.mydata
```
批量插入数据
```python
res = requests.get(url, params=query).json()
commentList = res['data']['commentList']
mongo_collection.insert_many(commentList)
```
### 操作 MySQL
连接 MySQL
```python
import MySQLdb

# 打开数据库连接
db = MySQLdb.connect("localhost", "testuser", "test123", "TESTDB", charset='utf8' )

# 使用cursor()方法获取操作游标 
cursor = db.cursor()
执行 SQL 语句

# 使用 execute 方法执行 SQL 语句
cursor.execute("SELECT VERSION()")

# 使用 fetchone() 方法获取一条数据
data = cursor.fetchone()

print "Database version : %s " % data

# 关闭数据库连接
db.close()
```
Output:

Database version : 5.0.45
## 本地文件整理
整理文件涉及需求的比较多，这里分享的是将本地多个 CSV 文件整合成一个文件
```python
import pandas as pd
import os


df_list = []
for i in os.listdir():
 if "csv" in i:
 day = i.split('.')[0].split('_')[-1]
 df = pd.read_csv(i)
 df['day'] = day
 df_list.append(df)
df = pd.concat(df_list, axis=0)
df.to_csv("total.txt", index=0)
```
## 多线程代码
多线程也有很多实现方式，我们选择自己最为熟悉顺手的方式即可
```python
import threading
import time

exitFlag = 0

class myThread (threading.Thread):
 def __init__(self, threadID, name, delay):
 threading.Thread.__init__(self)
 self.threadID = threadID
 self.name = name
 self.delay = delay
 def run(self):
 print ("开始线程：" + self.name)
 print_time(self.name, self.delay, 5)
 print ("退出线程：" + self.name)

def print_time(threadName, delay, counter):
 while counter:
 if exitFlag:
 threadName.exit()
 time.sleep(delay)
 print ("%s: %s" % (threadName, time.ctime(time.time())))
 counter -= 1

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("退出主线程")
```
## 异步编程代码
异步爬取网站
```python
import asyncio
import aiohttp
import aiofiles

async def get_html(session, url):
 try:
 async with session.get(url=url, timeout=8) as resp:
 if not resp.status // 100 == 2:
 print(resp.status)
 print("爬取", url, "出现错误")
 else:
 resp.encoding = 'utf-8'
 text = await resp.text()
 return text
 except Exception as e:
 print("出现错误", e)
 await get_html(session, url)
```
使用异步请求之后，对应的文件保存也需要使用异步，即是一处异步，处处异步
```python
async def download(title_list, content_list):
 async with aiofiles.open('{}.txt'.format(title_list[0]), 'a',
 encoding='utf-8') as f:
 await f.write('{}'.format(str(content_list)))
```

以上就是平时用的最多的代码片段，希望对你有所帮助

分享几段祖传的Python代码，拿来直接使用！

:::note{title="注"}
在项目根目录下，创建一个空文件叫“.gitignore”，然后把下面的所有内容复制粘贴进去，保存即可。
如果你还有自己特殊的文件和文件夹，不想上传到github或gitee上，继续往里面加就可以了。
每一行表示一个文件或一个文件夹，名字后面带有“/”的表示文件夹。
:::

```python
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
 
# C extensions
*.so
 


# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
pip-wheel-metadata/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
 
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
 
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
 
# Unit test / coverage reports
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
.hypothesis/
.pytest_cache/
 
# Translations
*.mo
*.pot
 
# Django stuff:
*.log
local_settings.py
db.sqlite3
 
# Flask stuff:
instance/
.webassets-cache
 
# Scrapy stuff:
.scrapy
 
# Sphinx documentation
docs/_build/
 
# PyBuilder
target/
 
# Jupyter Notebook
.ipynb_checkpoints
 
# IPython
profile_default/
ipython_config.py
 
# pyenv
.python-version
 
# pipenv
# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
# However, in case of collaboration, if having platform-specific dependencies or dependencies
# having no cross-platform support, pipenv may install dependencies that don't work, or not
# install all needed dependencies.
#Pipfile.lock
 
# celery beat schedule file
celerybeat-schedule
 
# SageMath parsed files
*.sage.py
 
# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/
 
# Spyder project settings
.spyderproject
.spyproject
 
# Rope project settings
.ropeproject
 
# mkdocs documentation
/site
 
# mypy
.mypy_cache/
.dmypy.json
dmypy.json
 
# Pyre type checker
.pyre/

pycharm gitignore file配置


:::note{title="注"}
命令行运行nginx提示：[warn] conflicting server name "www.xxx.com" on 0.0.0.0:80, ignored
:::

这个报错的原因是在nginx的vhost里面有关于"www.xxx.com"  域名的重复配置的conf文件，检查所有conf文件中的server_name，找到关于"www.xxx.com" 的重复配置文件conf，删除其中一个，
然后nginx restart重启nginx即可。

Nginx [warn] conflicting server name "www.xxx.com" on 0.0.0.0:80, ignored

:::info{title="相关信息"}
本代码功能：抓取某电影免费下载网站资料，然后用flask搭建服务，用API方式执行任务，发布到Z-Blog和订阅号。
实现在线操作，不需要本地运行代码。
:::
```python
# -*- coding: utf-8 -*-
# @Time : 2023/5/19 23:38
# @Author : Kyln.Wu
# @Email : kylnwu@qq.com
# @FileName : app.py
# @IDE : PyCharm
import subprocess
from flask import Flask, request, jsonify
import asyncio
import os
import re
import time
import json
from PIL import Image
import aiofiles
import aiohttp
import httpx
import requests
from lxml import html
from lxml.html import tostring

app = Flask(__name__)



# 这是使用浏览器向服务器发送GET请求，让Flask去调用异步协程do_job()下载图片的API
@app.route('/api', methods=['GET', 'POST'])
# @verify_token # 使用verify_token验证
def api():
 print(f"当前时间：{time.strftime('%Y-%m-%d')}")
 start_id = request.args.get('s')
 end_id = request.args.get('n')
 # 为请求创建新事件循环
 loop = asyncio.new_event_loop()
 asyncio.set_event_loop(loop)

 # 运行任务
 task = loop.create_task(do_job(start_id, end_id))
 loop.run_until_complete(task)

 return jsonify({'msg': "successed！"})


@app.route('/')
def index():
 return "hello world!"


# 这是调用上传图片和资料信息到微信公从号的API
@app.route('/to_wx')
def to_wx():
 global access_token
 APPID = '你的公众号APPID'
 APPSECRET = '你的公众号APPSECRET'
 access_token_resp = requests.get(
 f'https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid={APPID}&secret={APPSECRET}')
 json_obj = json.loads(access_token_resp.text)
 access_token = json_obj.get('access_token')
 if not access_token:
 print(f"access_token: {access_token}")

 start_id = request.args.get('s')
 # print(start_id, type(start_id))
 end_id = request.args.get('n')
 # 开始上传到公众号
 m_details_lst = get_movie_details(start_id, end_id)
 to_wx_draft(m_details_lst)

 # 移动图片到UploadFile中
 mv_result_lst = mv_pics()

 return jsonify({'msg': mv_result_lst})


# 合并do_smthing和main任务
async def do_job(start_id, end_id):
 url_list = await get_pic_list(start_id, end_id)
 await download_pics(url_list)


etree = html.etree

# 构建请求头，根据实现情况修改
headers = {
 "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
 "Accept-Encoding": "gzip, deflate",
 "Accept-Language": "zh-CN,zh;q=0.9",
 "Cache-Control": "max-age=0",
 "Connection": "keep-alive",
 "Cookie": "isfirstvisited=false; PHPSESSID=gdep6db1598vdl8lg99uh6jfn1",
 "Host": "www.bd51.net",
 "Referer": "http://www.bd51.net/",
 "Upgrade-Insecure-Requests": "1",
 "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.87 Safari/537.36 SE 2.X MetaSr 1.0"
}


# 异步方法遍历图片总张数，获取真实的图片地址，返回列表
async def get_pic_list(start, end):
 print('正在解析图片地址...')
 pic_url_list = []
 tasks = []
 for i in range(int(start), int(end) + 1):
 each_url = f'http://www.bd51.net/index/mdetail/index.html?id={i}'
 # print(each_url)
 task = asyncio.ensure_future(parse_html(each_url, pic_url_list))
 task.add_done_callback(get_urls)
 tasks.append(task)
 # 异步执行解析图片地址，等待任务完成
 await asyncio.wait(tasks)
 return pic_url_list


# 异步方法解析网页，返回图片地址列表
async def parse_html(url, pic_url_list):
 async with aiohttp.ClientSession() as session:
 async with session.get(url) as resp:
 res_html = etree.HTML(await resp.text())
 try:
 part_pic_url = res_html.xpath('/html/body/div[3]/div[1]/div[2]/div[1]/div[2]/img/@src')[0]
 pic_url = f"http://www.bd51.net{part_pic_url}"
 print(pic_url)
 s_name = part_pic_url.rsplit('/', 1)[1]
 s_pic_url = f"http://www.bd51.net/UploadFile/{s_name.split('.')[0]}_s.{s_name.split('.')[1]}"
 print(s_pic_url)
 pic_url_list.append(pic_url)
 pic_url_list.append(s_pic_url)
 except Exception as e:
 print(e)

 return pic_url_list


# 异步方法下载图片，并存入文件中
async def aio_download(url, path):
 name = url.rsplit('/', 1)[1]
 try:
 # 异步发送请求http1.x
 async with aiohttp.ClientSession() as session:
 async with session.get(url, headers=headers) as resp:
 # print(f'aiohttp异步请求：{resp.status}')
 if resp.status == 200:
 # 异步写入文件
 async with aiofiles.open(f'{path}/{name}', 'wb') as f:
 await f.write(await resp.content.read())
 pic_resize(path, name)
 else:
 await httpx_download(url, path)
 ch_pics_own_mod(path, name)
 print(f"{name}--->>搞定！")
 except Exception as e:
 print(e)


# 异步模式下载http2.0的链接
async def httpx_download(url, path):
 name = url.rsplit('/', 1)[1]
 # 也可以写成client = httpx.AsyncClient()
 async with httpx.AsyncClient() as client:
 # 这里有个坑，httpx.get默认不追踪网页重定向，如果碰到返回代码301，需要加上参数follow_redirects=True
 resp = await client.get(url, headers=headers, follow_redirects=True)
 # print(f'httpx异步请求：{resp.status_code}')
 if resp.status_code == 200:
 # 异步写入文件
 async with aiofiles.open(f'{path}/{name}', 'wb') as f:
 await f.write(resp.content)
 pic_resize(path, name)


# 判断下载的图片大小和分辨率，进行压缩处理
def pic_resize(path, name):
 # 获取图片文件大小
 size = os.path.getsize(f'{path}/{name}') / 1024
 print(f'图片大小: {size}KB')
 # 获取图片分辨率
 img = Image.open(f'{path}/{name}')
 print('图片宽度和高度:', img.size)

 # 如果大于 1024KB,或宽度大小1080px，进行压缩
 if size > 1024 or img.size[0] > 1080:
 width = 1080
 height_scale = width / img.size[0]
 height = int(img.size[1] * height_scale)
 img = img.resize((width, height))
 print('图片缩小后宽度和高度:', img.size)

 # 图像压缩
 img.save(f'{path}/{name}', quality=70, optimize=True)
 print('压缩后图片大小:', os.path.getsize(f'{path}/{name}') / 1024, 'KB')
 else:
 print('无需压缩')


def ch_pics_own_mod(path, name):
 src_file = f'{path}/{name}'
 target_path = '你服务器上存放图片的路径' # 如果是linux服务器，最好写绝对路径，否则可能报错
 chown_cmd = ['chown', 'www', src_file]
 chmod_cmd = ['chmod', '755', src_file]
 # mv_cmd = ['mv', src_file, target_path]
 subprocess.run(chown_cmd)
 subprocess.run(chmod_cmd)
 # subprocess.run(mv_cmd)
 print(f'{src_file} chown_mod succeeded')


def mv_pics():
 path = create_save_path()
 result_lst = []
 for root, dirs, files in os.walk(path):
 for file in files:
 # print(file)
 # 使用join函数将文件名称和文件所在根目录连接起来
 if any((file.endswith('jpg'), file.endswith('png'))):
 src_file = os.path.join(path, file)
 # print(src_file)
 # 如果是linux服务器，最好写绝对路径，否则可能报错
 target_path = '你服务器上存放图片的路径'
 
 mv_cmd = ['mv', src_file, target_path]
 mv_res = subprocess.run(mv_cmd)
 if mv_res.returncode == 0:
 result_lst.append(f'{src_file} mv succeeded')
 print(f'{src_file} mv succeeded')
 else:
 result_lst.append(f'{src_file} mv failed')
 print(f'{src_file} mv failed')
 print(result_lst)
 return result_lst


# 这个函数是配合task.add_done_callback方法用的
# 定义一个任务对象的回调函数，回调函数必须有参数，参数为回调函数的绑定者（任务对象）
def get_urls(task):
 result = task.result()
 return result


# 按日期自定义保存目录
def create_save_path():
 time_folder = time.strftime('%Y-%m-%d')
 path = os.path.join(os.getcwd(), time_folder)

 if not os.path.exists(path):
 os.makedirs(path)
 return path


# 异步协程主程序
async def download_pics(urls):
 save_path = create_save_path()
 tasks = [asyncio.create_task(aio_download(url, save_path)) for url in urls]

 await asyncio.wait(tasks)


# ======================================
# 微信公众号发布消息代码开始
# ======================================


def get_movie_details(start_id, end_id):
 """
 这个函数是抓取影片资料的，同时过滤一些不要的信息，并重新组合成一个content，
 返回一个多条影片资料的列表
 """
 movie_infos_lst = []
 for k in range(int(start_id), int(end_id) + 1):
 movie_infos_dict = {}
 url = f"http://www.bd51.net/index/mdetail/index.html?id={k}"
 resp = requests.get(url)
 code = resp.apparent_encoding # 获取url对应的编码格式
 resp.encoding = code
 html_code = resp.text
 movie_infos_html = etree.HTML(html_code)
 movie_cn_name = movie_infos_html.xpath("/html/body/div[3]/div[1]/div[2]/div[1]/div[2]/div/h3/text()")[0]
 movie_year = re.findall('$(\d+)$', movie_cn_name)[0]
 part_pic_url = movie_infos_html.xpath('/html/body/div[3]/div[1]/div[2]/div[1]/div[2]/img/@src')[0]
 pic_url = f"http://www.bd51.net{part_pic_url}"
 imdb_rate = get_imdb_rate(k)
 div_tag1 = movie_infos_html.xpath("/html/body/div[3]/div[1]/div[2]/div[1]/div[2]/div")[0]
 div_tag2 = movie_infos_html.xpath("/html/body/div[3]/div[1]/div[2]/div[2]")[0]
 digest = movie_infos_html.xpath('/html/body/div[3]/div[1]/div[2]/div[2]/div[2]/p//text()')[0]
 html1 = tostring(div_tag1, encoding=code).decode(code).replace('\n', '')
 html1 = html1.replace('<h3>', '').replace('</h3>', '')
 html1 = html1.replace('首映日期：', f'上映年份：{movie_year}')
 html1 = html1.replace('0', f'<img src="{pic_url}">')
 html1 = html1.replace(' 00:00:00', '')
 html1 = html1.replace('', ' ')
 imdb_partern = re.compile('(人气：\d+)', re.S)
 html1 = re.sub(imdb_partern, f'IMDB：{imdb_rate}', html1)
 html2 = tostring(div_tag2, encoding=code).decode(code).replace('\n', '')
 html2_partern = re.compile('(<img.*?g">)', re.S)
 html2 = re.sub(html2_partern, '', html2)
 html2 = html2.replace('剧情介绍', '剧情介绍')
 # print(html1)
 # print(html2)
 wx_content = html1 + html2

 movie_infos_dict['中文名'] = movie_cn_name
 movie_infos_dict['海报'] = pic_url
 movie_infos_dict['影片简介'] = wx_content
 movie_infos_dict['摘要'] = digest
 movie_infos_lst.append(movie_infos_dict)
 # print(movie_detail)
 time.sleep(1)
 return movie_infos_lst


def get_imdb_rate(id):
 """
 :param id: 影片ID，接收影片id，到影片列表页进行搜索，匹配豆瓣评分
 :return: 如果匹配到了，就结束搜索，返回评分值
 """
 for j in range(1, 10):
 # 遍历9页搜索影片
 url = f"http://www.bd51.net/index/mlist/index.html?page={j}"
 res = requests.get(url).text
 time.sleep(3)
 index_html = etree.HTML(res)
 try:
 search_xpath = index_html.xpath(f'//*[@id="{id}"]')
 if search_xpath:
 imdb_rate = index_html.xpath(f'//*[@id="{id}"]/td[4]/p/text()')[0]
 # print(imdb_rate)
 return imdb_rate
 except:
 print(f"ID：{id}没找到。")


# 把文章分组并上传到草稿箱
def to_wx_draft(movie_datas_list):
 # ==========微信公众号同步发布===========
 # 如果爬取资料少于5篇
 if len(movie_datas_list) < 5:
 # 构造上传多图文消息的data
 data = {
 "articles": [pack_articles_list(movie_details) for movie_details in movie_datas_list]
 }
 # print(data)
 # 上传到草稿箱
 upd_post2cgx(data)
 print("上传公众号完成！")
 else:
 # 如果爬取资料大于5篇，则每5篇合成一篇发送到草稿箱
 for i in range(0, len(movie_datas_list), 5):
 # 构造上传多图文消息的data
 data = {
 "articles": [pack_articles_list(movie_details) for movie_details in movie_datas_list[i:i + 5]]
 }
 # print(data)
 # 上传到草稿箱
 upd_post2cgx(data)
 print("上传公众号完成！")
 return


# post到公众号草稿箱
def upd_post2cgx(data):
 try:
 url = 'https://api.weixin.qq.com/cgi-bin/draft/add?access_token=' + access_token
 vx_res = requests.post(url=url, data=json.dumps(data, ensure_ascii=False).encode("utf-8"))
 obj = json.loads(vx_res.content)
 # print(obj)
 return obj['media_id']
 except Exception as e:
 print(e)


# 获取公众号文章必须的title, digest, content, img_url，构造并返回多图文消息articles的结构
def pack_articles_list(movie_details):
 # 获取本次发布的所有文章的title, img_url, content, tags, intro, digest
 wx_title = movie_details.get('中文名') + ' 更新上架'
 digest = movie_details.get('摘要')[:100]
 base_folder = '/你自己定义的存放路径/api/' + time.strftime('%Y-%m-%d')
 file_name = movie_details.get('海报').rsplit('/', 1)[1]
 print(file_name)
 file_path = os.path.join(base_folder, file_name)
 if not os.path.exists(base_folder):
 os.makedirs(base_folder)
 # 2 上传封面获取封面id
 wx_fm_img_id, file_path = upd_fm_pic(file_name, file_path)
 # 3 上传正文图片到微信公众号,并获取返回的url地址
 wx_all_imgs_url = upd_imgs(file_path, file_name)
 # 4 用微信公众号返回的图片地址替换content里面的图片地址，获取最后要发布的正文内容
 img_url_pattern = re.compile('(https?://[a-zA-Z0-9.?/%-_]*.jpg)', re.S)
 content = movie_details.get('影片简介')
 wx_content = re.sub(img_url_pattern, wx_all_imgs_url, content)
 # print(wx_content)
 # 构造多图文消息articles结构
 articles_dict = create_post_dict(wx_title, digest, wx_content, wx_fm_img_id)
 # print(articles_lst)
 return articles_dict


# 2 上传封面图片到微信公众号，并返回封面图片id和本地图片绝对路径
def upd_fm_pic(file_name, file_path):
 try:
 url = f'https://api.weixin.qq.com/cgi-bin/material/add_material?access_token={access_token}&type=image'
 request_file = {
 'media': (file_name, open(file_path, 'rb'), 'image/jpeg')}
 vx_res = requests.post(url=url, files=request_file)
 obj = json.loads(vx_res.content)
 print(obj)
 return obj['media_id'], file_path
 except Exception as e:
 print(e)


# 3 上传正文图片到微信公众号，并返回正文图片网址
def upd_imgs(file_path, file_name):
 try:
 vx_img_url = 'https://api.weixin.qq.com/cgi-bin/media/uploadimg'
 request_file = {
 'media': (file_name, open(file_path, 'rb'), 'image/jpeg')}
 data = {
 'access_token': access_token
 }
 vx_res = requests.post(url=vx_img_url, files=request_file, data=data)
 obj = json.loads(vx_res.content)
 print(obj)
 return obj['url']
 except Exception as e:
 print(e)


# 4 构造多图文消息体的articles部分
def create_post_dict(wx_title, digest, wx_content, wx_fm_img_id):
 articles_dict = {
 "title": wx_title,
 "author": '',
 "digest": digest,
 "content": wx_content,
 "show_cover_pic": 1,
 "need_open_comment": 0,
 "only_fans_can_comment": 1,
 "thumb_media_id": wx_fm_img_id
 }
 return articles_dict


# ======================================
# 微信公众号发布消息代码结束
# ======================================
async def do_smthing(start_id, end_id):
 # 创建任务对象
 # get_pic_list()是一个协程函数对象，需要用asyncio.ensure_future()创建成任务，并去执行才会有结果
 url_list_task = asyncio.ensure_future(get_pic_list(start_id, end_id))

 # 想要得到任务对象的返回值，需要用task.add_done_callback()方法回调返回值
 # 想要回调返回值，绑定回调函数。
 url_list_task.add_done_callback(get_urls)
 # print(url_list)
 return url_list_task


if __name__ == '__main__':
 app.run(host='0.0.0.0', port=5000, debug=True)

```
### 下面是flask的配置参数
```python
bind = '0.0.0.0:5000'
user = 'root'
workers = 2
threads = 4
backlog = 512
timeout = 180
chdir = '这里是你的flask代码存放路径' # 记得要写绝对路径
access_log_format = '%(t)s %(p)s %(h)s "%(r)s" %(s)s %(L)s %(b)s %(f)s" "%(a)s"'
loglevel = 'info'
worker_class = 'sync'
errorlog = chdir + '/logs/error.log'
accesslog = chdir + '/logs/access.log'
pidfile = chdir + '/logs/电影更新api.pid'
```