:::warning{title="说明"}
如题，问题很简单，假如有一个很长的txt文档，每一段都有一个数字编号，但是这个编号是不连续的，现在想把所有的编号都去掉，然后重新按顺序编号。
文档格式举例：
"""
1、dksipewkfksjfala
3、dklsflkjfiwfklakd.
34、ldsaifjwpfjp932ifl.
43.kaliwjfpidsaf;dl;
46)laidwlfiasflw;;fll
(58)lsfjwlfmlafijwfsf;
....
98882、kdkfjpwkflkfs
"""
:::
直接上代码




```python
import re

with open('./text.txt', 'r', encoding='utf-8') as f:
    # 以回车符为标志，读取所有的段落，变成一个列表read_lines
    read_lines = f.readlines()
# 遍历read_lines里的第一个段落，然后用正则表达式方法去掉段落开头的数字和符号
n = 1
for line in read_lines:
    # 去掉数字和顿号，如：“23、”
    line = re.sub('[\d+、]', '', line)
    # 去掉数字和点号，如：“23.”
    line = re.sub('[\d+.]', '', line)
    # 去掉反括号，如：“)”，也可能是一对圆括号()，自己看结果的情况修改
    line = re.sub('[)]', '', line)
    # print(line)
    # 把修改后的每一个段落重新写入一个文件。
    with open('./text_new.txt', 'a', encoding='utf-8') as file:
        file.write(f"{n}、{line}")
```

python中用正则去掉字符串开头的数字编号

:::tip{title="提示"}
最近用python写了个全国疫情中高风险地区查询的爬虫代码，分享给大家一起交流，希望得到不同思路的指教，让代码更简洁，运行效率更高。
:::
# 总体思路
1、找到可供查询的源网站
2、分析、获取查询的API
3、构造API
4、获取全国中高风险地区信息
5、对信息按“省、市、街道”进行整理
6、构造查询匹配语句，判断输入的“省、市、县”是否在获取的信息中

注：输入匹配部分的代码自己总觉得不是最优解，希望能有大佬看到，指点一二。




# 代码部分
```python
# -*- coding: utf-8 -*-
# @Time    : 2022/5/12 11:08
# @Author  : Kyln.Wu
# @Email   : kylnwu@qq.com
# @File    : 疫情风险地区查询.py
# @Software: PyCharm
import hashlib
import json
import difflib
import requests
import time


timestamp = str(int((time.time())))
# print(timestamp)

token = '23y0ufFl5YxIyGrI8hWRUZmKkvtSjLQA'
nonce = '123456789abcdefg'
passid = 'zdww'
key = "3C502C97ABDA40D0A60FBEE50FAAD1DA"


def get_zdwwsignature():
    zdwwsign = timestamp + 'fTN2pfuisxTavbTuYVSsNJHetwq5bJvC' + 'QkjjtiLM2dCratiA' + timestamp
    hsobj = hashlib.sha256()
    hsobj.update(zdwwsign.encode('utf-8'))
    zdwwsignature = hsobj.hexdigest().upper()
    # print(zdwwsignature)
    return zdwwsignature


def get_signatureheader():
    has256 = hashlib.sha256()
    sign_header = timestamp + token + nonce + timestamp
    has256.update(sign_header.encode('utf-8'))
    signatureHeader = has256.hexdigest().upper()
    # print(signatureHeader)
    return signatureHeader


def get_datas():
    url = 'https://bmfw.www.gov.cn/bjww/interface/interfaceJson'
    headers = {
        "Accept": "application/json, text/javascript, */*; q=0.01",
        "Accept-Encoding": "gzip, deflate, br",
        "Accept-Language": "zh-CN,zh;q=0.9",
        "Connection": "keep-alive",
        # "Content-Length": "235",
        "Content-Type": "application/json; charset=UTF-8",
        "Host": "bmfw.www.gov.cn",
        "Origin": "http://bmfw.www.gov.cn",
        "Referer": "http://bmfw.www.gov.cn/yqfxdjcx/risk.html",
        # "Sec-Fetch-Dest": "empty",
        # "Sec-Fetch-Mode": "cors",
        # "Sec-Fetch-Site": "cross-site",
        "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",
        "x-wif-nonce": "QkjjtiLM2dCratiA",
        "x-wif-paasid": "smt-application",
        "x-wif-signature": get_zdwwsignature(),
        "x-wif-timestamp": timestamp
    }

    params = {
        'appId': "NcApplication",
        'paasHeader': "zdww",
        'timestampHeader': timestamp,
        'nonceHeader': "123456789abcdefg",
        'signatureHeader': get_signatureheader(),
        'key': "3C502C97ABDA40D0A60FBEE50FAAD1DA"
    }

    resp = requests.post(url, headers=headers, json=params)
    datas = resp.text

	# 在线获取后，保存到本地，再进行本地整理操作，减少在线访问，以免被封IP
    with open('./risk_data.log', 'w', encoding='utf-8') as f:
        f.write(datas)


def get_highlist(data):
    highlist = data['data']['highlist']
    return highlist


def get_middlelist(data):
    middlelist = data['data']['middlelist']
    return middlelist


def chaxun(high_list, middle_list):
    # 用列表推导式从high_list中取出province的值，然后用set()去重，再转换成列表
    high_provinces = list(set([x['province'] for x in high_list]))
    high_citys = list(set([x['city'] for x in high_list]))
    high_countys = list(set([x['county'] for x in high_list]))
    print(f'高风险省/直辖市：{high_provinces}')
    print(f'高风险市/区：{high_citys}')
    print(f'高风险县/街道：{high_countys}')
    middle_provinces = list(set([x['province'] for x in middle_list]))
    middle_citys = list(set([x['city'] for x in middle_list]))
    middle_countys = list(set([x['county'] for x in middle_list]))
    print(f'中风险省/直辖市：{middle_provinces}')
    print(f'中风险市/区：{middle_citys}')
    print(f'中风险县/街道：{middle_countys}')

    while True:

        province_in = input('请输入来自省/直辖市：')
        if len(province_in) == 0:
            print('输入省/直辖市不能为空！')
            break
        city_in = input('请输入来自市/区：')
        if len(city_in) == 0:
            print('输入市/区不能为空！')
            break
        county_in = input('请输入来自县/街道：')
        if len(county_in) == 0:
            print('输入县/街道不能为空！')
            break

        # 用difflib.get_close_matches()方法从high_provinces中取出1个与province_in最匹配的值，近似度0.6
        high_province = difflib.get_close_matches(province_in, high_provinces, 1, cutoff=0.6)
        # print(f'high_province:{high_province}')
        high_city = difflib.get_close_matches(city_in, high_citys, 1, cutoff=0.6)
        # print(f'high_city:{high_city}')
        high_county = difflib.get_close_matches(county_in, high_countys, 1, cutoff=0.6)
        # print(f'high_county:{high_county}')
        middle_province = difflib.get_close_matches(province_in, middle_provinces, 1, cutoff=0.6)
        # print(f'middle_province:{middle_province}')
        middle_city = difflib.get_close_matches(city_in, middle_citys, 1, cutoff=0.6)
        # print(f'middle_city:{middle_city}')
        middle_county = difflib.get_close_matches(county_in, middle_countys, 1, cutoff=0.6)
        # print(f'middle_county:{middle_county}')

		# 构造所有可能的中高风险条件
        # 高、高、高
        if high_province and high_city and high_county:
            print(f'{province_in}，{city_in}，{county_in} 为高风险省/直辖市，市/区，县/街道！！')
        # 高、高、中
        elif high_province and high_city and not high_county and not middle_province and not middle_city and middle_county:
            print(f'{province_in} 为高风险省/直辖市，{city_in} 为高风险市/区，{county_in} 为中风险县/街道。')
        # 高、高、低
        elif high_province and high_city and not high_county and not middle_province and not middle_city and not middle_county:
            print(f'{province_in} 为高风险省/直辖市，{city_in} 为高风险市/区，{county_in} 为低风险县/街道。')
        # 高、低、低
        elif high_province and not high_city and not high_county and not middle_province and not middle_city and not middle_county:
            print(f'{province_in} 为高风险省/直辖市，{city_in} 为低风险市/区，{county_in} 为低风险县/街道。')
        # 高、中、中
        elif high_province and not high_city and not high_county and middle_province and middle_city and not middle_county:
            print(f'{province_in} 为高风险省/直辖市，{city_in} 为中风险市/区，{county_in} 为中风险县/街道。')
        # 高、中、低
        elif high_province and not high_city and not high_county and not middle_province and middle_city and not middle_county:
            print(f'{province_in} 为高风险省/直辖市，{city_in} 为中风险市/区，{county_in} 为低风险县/街道。')
        # 中、中、中
        elif not high_province and not high_city and not high_county and middle_province and middle_city and middle_county:
            print(f'{province_in} 为中风险省/直辖市，{city_in} 为中风险市/区，{county_in} 为中风险县/街道。')
        # 中、中、低
        elif not high_province and not high_city and not high_county and middle_province and middle_city and not middle_county:
            print(f'{province_in} 为中风险省/直辖市，{city_in} 为中风险市/区，{county_in} 为低风险县/街道。')
        # 中、低、低
        elif not high_province and not high_city and not high_county and middle_province and not middle_city and not middle_county:
            print(f'{province_in} 为中风险省/直辖市，{city_in} 为低风险市/区，{county_in} 为低风险县/街道。')
        # 低、低、低
        elif not high_province and not high_city and not high_county and not middle_province and not middle_city and not middle_county:
            print(f'{province_in}，{city_in}，{county_in} 为低风险省/直辖市，市/区，县/街道。')
        else:
            print(f'不在中高风险列表中，或行政区域不匹配，请检查！！')

        loop = int(input('是否继续查询？1-继续，0-退出。'))
        if loop == 0:
            break


if __name__ == '__main__':
    # get_datas()
    with open('./risk_data.log', 'r', encoding='utf-8') as f:
        datas_dic = json.loads(f.read())
        high_lst = get_highlist(datas_dic)
        # print(high_list)
        middle_lst = get_middlelist(datas_dic)
        # print(middle_list)
        chaxun(high_lst, middle_lst)
```

# 运行结果
![全国中高风险地区查询结果](https://img-blog.csdnimg.cn/5c48455ed9e140f8b885ff82980cadb2.png#pic_center)

以上是运行结果，输入信息支持模糊查询

用python写了个全国疫情中高风险地区查询

## 用python获取指定目录下的指定类型的所有文件

:::tip{title="分享"}
快速从本地文件夹中挑选某一类型的文件，可以通过文件的扩展名来实现。
今天给大家分享一个思路，通过文件的扩展名来挑选指定目录下的某种类型的所有文件的python实现方法。
:::

### 直接上代码

```python
import os


# 获取某目录下所有表格类文件
def get_excel_file(dir_path):
    file_list = []
    for root, dirs, files in os.walk(dir_path):
        for file in files:
            if file.endswith("xlsx") or file.endswith("csv"):
                file_list.append(os.path.join(root, file))

    return file_list


if __name__ == '__main__':
    path = '您的目标文件夹路径(相对路径或绝对路径均可)'    # 如："D:/ABC/BB"
    print(get_excel_file(path))
```


以上只是一个简单的例子，在此基础上，还可以再进行批量改名等处理....

用python获取指定目录下的指定类型的所有文件

## Python编程requests headers快速转换格式



:::info{title="相关信息"}
在写python爬虫的时候，经常需要从浏览器中复制Requests headers，但是直接复制的格式又不是python里可以使用的字典格式，这里和大家分享一个我从网上搜到的快速转换headers为python字典格式的代码，拿去就能用。
:::

## Requests Headers代码

```python
import json

# 使用三引号将浏览器复制出来的requests headers参数赋值给一个变量，直接粘贴替换下方的三引号中的内容即可
headers = """
Accept: application/json, text/javascript, */*; q=0.01
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Connection: keep-alive
Content-Length: 235
Content-Type: application/json; charset=UTF-8
Host: bmfw.www.gov.cn
Origin: http://bmfw.www.gov.cn
Referer: http://bmfw.www.gov.cn/yqfxdjcx/risk.html
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
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
x-wif-nonce: QkjjtiLM2dCratiA
x-wif-paasid: smt-application
x-wif-signature: 15FDE897717A9D1538514AB9CE5AD5A9F524D6F84DC9E1C763E82D8422FD9BB5
x-wif-timestamp: 1652324163
"""

# 去除参数头尾的空格并按换行符分割
headers = headers.strip().split('\n')

# 使用字典生成式将参数切片重组，并去掉空格，处理带协议头中的://
headers = {x.split(':')[0].strip(): ("".join(x.split(':')[1:])).strip().replace('//', "://") for x in headers}

# 使用json模块将字典转化成json格式打印出来
print(json.dumps(headers, indent=4))
```

### 希望对您的python学习有所帮助。

Python编程requests headers快速转换格式


# 前言

Python对Windows程序窗口操作 最大化 最小化 关闭

# 代码

```python
import win32con
import win32gui
import time

'''
hwnd = win32gui.FindWindow(lpClassName=None, lpWindowName=None)  # 查找窗口，不找子窗口，返回值为0表示未找到窗口
hwnd = win32gui.FindWindowEx(hwndParent=0, hwndChildAfter=0, lpszClass=None, lpszWindow=None)  # 查找子窗口，返回值为0表示未找到子窗口

win32gui.ShowWindow(hwnd, win32con.SW_SHOWNORMAL)
SW_HIDE：隐藏窗口并激活其他窗口。nCmdShow=0。
SW_SHOWNORMAL：激活并显示一个窗口。如果窗口被最小化或最大化，系统将其恢复到原来的尺寸和大小。应用程序在第一次显示窗口的时候应该指定此标志。nCmdShow=1。
SW_SHOWMINIMIZED：激活窗口并将其最小化。nCmdShow=2。
SW_SHOWMAXIMIZED：激活窗口并将其最大化。nCmdShow=3。
SW_SHOWNOACTIVATE：以窗口最近一次的大小和状态显示窗口。激活窗口仍然维持激活状态。nCmdShow=4。
SW_SHOW：在窗口原来的位置以原来的尺寸激活和显示窗口。nCmdShow=5。
SW_MINIMIZE：最小化指定的窗口并且激活在Z序中的下一个顶层窗口。nCmdShow=6。
SW_SHOWMINNOACTIVE：窗口最小化，激活窗口仍然维持激活状态。nCmdShow=7。
SW_SHOWNA：以窗口原来的状态显示窗口。激活窗口仍然维持激活状态。nCmdShow=8。
SW_RESTORE：激活并显示窗口。如果窗口最小化或最大化，则系统将窗口恢复到原来的尺寸和位置。在恢复最小化窗口时，应用程序应该指定这个标志。nCmdShow=9。
'''

# 先等待3秒
time.sleep(3)

# 查找窗口句柄
hwnd = win32gui.FindWindow("YodaoMainWndClass", u"网易有道词典")
print(hwnd)

if hwnd != 0:
    # 若最小化，则将其显示，反之则最小化
    if win32gui.IsIconic(hwnd):
        win32gui.ShowWindow(hwnd, win32con.SW_SHOWMAXIMIZED)
    else:
        win32gui.ShowWindow(hwnd, win32con.SW_SHOWMINIMIZED)

    win32gui.SetForegroundWindow(hwnd)  # 设置前置窗口
    # win32gui.SetFocus(hwnd)  # 设置聚焦窗口

    # 关闭窗口
    win32gui.PostMessage(hwnd, win32con.WM_CLOSE, 0, 0)
```


# 补充
获取窗口的ClassName(上面代码里的"YodaoMainWndClass") 推荐一个工具：WinSpy