代码小整理1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

import os
import pandas as pd
import xlwings as xw
import warnings
warnings.filterwarnings('ignore')

def read_excel_safe(filename):
    """安全读取 Excel 文件，处理含计算公式的情况"""
    try:
        # 尝试使用 pandas 直接读取
        data = pd.read_excel(filename)
        data.columns = [col.strip() for col in data.columns]  # 清理列名空格
        return data
    except Exception as e:
        print(f'Pandas 读取失败，使用 xlwings 模块: {e}')
        # 使用 xlwings 作为备用方案
        app = xw.App(visible=False, add_book=False)
        app.display_alerts = False
        app.screen_updating = False

        wb = app.books.open(filename)
        ws = wb.sheets[0]
        info = ws.used_range

        nrows = info.last_cell.row
        ncolumns = info.last_cell.column

        # 获取数据
        ws_data = ws.range((1, 1), (nrows, ncolumns)).value
        # 获取列名
        data_columns = ws_data.pop(0)
        data = pd.DataFrame(ws_data, columns=data_columns)

        wb.close()
        app.quit()
        return data

# 主程序：合并多个 Excel 文件
def merge_excel_files(folder_path, output_file='合并后.xlsx'):
    """合并指定文件夹中的所有 Excel 文件"""
    combined_data = pd.DataFrame()
    file_list = os.listdir(folder_path)

    print('开始合并文件...')

    for index, filename in enumerate(file_list):
        print(f'处理第 {index+1} 个文件: {filename}')
        file_path = os.path.join(folder_path, filename)

        data = read_excel_safe(file_path)
        combined_data = pd.concat([combined_data, data], axis=0, ignore_index=True)

    combined_data.to_excel(output_file, index=False)
    print('文件合并完成 ✔')
    return combined_data

# 使用示例
if __name__ == "__main__":
    folder_path = r".\Excel文件路径"  # 替换为实际路径
    merge_excel_files(folder_path)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import struct

def read_binary_data(filename, data_size=6720):
    """读取二进制气象数据文件"""
    with open(filename, 'rb') as f:
        # 'f' 表示浮点数，4*6720 表示读取 6720 个浮点数（每个4字节）
        data = struct.unpack('f' * data_size, f.read(4 * data_size))
        print(f'前20个数据点: {data[:20]}')
    return data

# 使用示例
filename = './数据/xxx.dat'
meteorological_data = read_binary_data(filename)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

import numpy as np
import math
import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.basemap import Basemap

# 显示中文和负号
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

# 初始化数组
h1000 = np.zeros((7, 32, 30))      # 原始数据 (纬度, 经度, 年份)
climatology = np.zeros((7, 32))    # 气候场
anomaly = np.zeros((7, 32, 30))    # 距平场
std_dev = np.zeros((7, 32))        # 均方差场
missing_records = []               # 缺失值记录

# 数据处理
data = np.array(meteorological_data)
for year in range(30):          # 30年数据
    for lat_idx in range(7):     # 7个纬度
        for lon_idx in range(32): # 32个经度
            # 计算数据索引位置
            index = lon_idx + 32 * lat_idx + 32 * 7 * year
            h1000[lat_idx, lon_idx, year] = data[index]

            # 处理缺失值（标记为9999）
            if h1000[lat_idx, lon_idx, year] >= 9999:
                h1000[lat_idx, lon_idx, year] = 0
                missing_records.append((lat_idx, lon_idx, year))

# print(h1000[:,:,0][0])  # 表示第一年纬度为 -18.0950 下的 32 个经度的海温数据
# 提取特定年份数据
h1000_1982 = h1000[:, :, 4]    # 1982年数据
h1000_1998 = h1000[:, :, 20]   # 1998年数据

# 计算气候场（30年平均）
climatology = np.mean(h1000, axis=2)

# 填补缺失值
for lat_idx, lon_idx, year in missing_records:
    h1000[lat_idx, lon_idx, year] = climatology[lat_idx, lon_idx]

# 计算距平场
for year in range(30):
    anomaly[:, :, year] = h1000[:, :, year] - climatology

anomaly_1982 = anomaly[:, :, 4]  # 1982年距平
anomaly_1998 = anomaly[:, :, 20] # 1998年距平

# 计算均方差场
std_dev = np.sqrt(np.mean(anomaly**2, axis=2))

# 经纬度坐标
longitude = np.arange(121.88, 300.8, 5.65)  # 经度数组
latitude = np.array([-18.0950, -12.3808, -6.6666, -0.9524, 4.7618, 10.4761, 16.1902])  # 纬度数组

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

def plot_meteorological_data(lon, lat, data, levels, title, colormap='PuBu'):
    """
    绘制气象数据图

    参数:
    lon: 经度数组
    lat: 纬度数组
    data: 要绘制的数据（二维数组）
    levels: 等高线密度/分级
    title: 图像标题
    colormap: 颜色映射，默认为'PuBu'
    """
    # 创建Basemap对象
    b_map = Basemap(
        resolution='l',
        area_thresh=10000,
        projection='cyl',
        llcrnrlon=min(lon),
        urcrnrlon=max(lon),
        llcrnrlat=min(lat),
        urcrnrlat=max(lat)
    )

    fig = plt.figure(figsize=(18, 12))
    ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])

    # 创建网格数据
    # https://zhuanlan.zhihu.com/p/33579211
    lon_grid, lat_grid = np.meshgrid(lon, lat)
    x, y = b_map(lon_grid, lat_grid)

    # 绘制填充等高线
    cs = b_map.contourf(x, y, data, levels=levels, cmap=plt.get_cmap(colormap))
    b_map.colorbar(cs, label='数值')

    # 添加地理信息, 关于海岸线和国家边界线的绘制设置
    b_map.drawcoastlines(linewidth=1)
    b_map.drawcountries(linewidth=1.5)

    # 添加经纬度刻度
    lon_dict = b_map.drawmeridians(
        np.linspace(min(lon), max(lon), 5),
        labels=[0, 0, 0, 1],  # 四个值分别代表 [左,右,上,下]，下为 1 即只标注在下
        fontsize=12
    )
    lat_dict = b_map.drawparallels(
        np.linspace(min(lat), max(lat), 5),
        labels=[1, 0, 0, 0],  # 左为 1 即只标注在左
        fontsize=12
    )

    # 加上经纬刻度线
    lon_list = []
    lat_list = []
    for lon_key in lon_dict.keys():
        try:
            # print(lon_dict[lon_key][1][0].get_position())
            lon_list.append(lon_dict[lon_key][1][0].get_position()[0])
        except Exception as e:
            print(e)
            continue
    for lat_key in lat_dict.keys():
        try:
            # print(lat_dict[lat_key][1][0].get_position())
            lat_list.append(lat_dict[lat_key][1][0].get_position()[1])
        except Exception as e:
            print(e)
            continue

    ax = plt.gca() #获取当前轴
    # ax.xaxis.tick_top() #翻转 x轴
    ax.set_xticks(lon_list)
    ax.set_yticks(lat_list)
    ax.tick_params(labelcolor='none') #设置隐藏原本的刻度值

    plt.title(title, fontsize=20)
    plt.show()
    plt.close()

1
2
3
4

# 使用示例
title_1982 = '1982年海温数据'
levels_1982 = np.linspace(h1000_1982.min(), h1000_1982.max(), 30)
plot_meteorological_data(longitude, latitude, h1000_1982, levels_1982, title_1982)

1
2
3

pip install netCDF4
# 或指定特定版本
pip install netCDF4-1.5.8-cp39-cp39-win_amd64.whl

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import numpy as np
import datetime
import matplotlib.pyplot as plt
from mpl_toolkits.basemap import Basemap
from netCDF4 import Dataset
import seaborn as sns

# 读取NetCDF文件
nc_file = Dataset('air.mon.mean.nc')

# 查看变量信息
print("文件变量信息:")
for var_name in nc_file.variables.keys():
    var_data = nc_file.variables[var_name]
    print(f"{var_name}: {var_data.shape}")
    # np.save(i + '.npy', var_data)  # 保存数据

# 提取各变量数据
latitudes = nc_file.variables['lat'][:]
longitudes = nc_file.variables['lon'][:]
time_data = nc_file.variables['time'][:]
air_data = nc_file.variables['air'][:]
print(f"纬度范围: {latitudes.min()} 到 {latitudes.max()}")
print(f"经度范围: {longitudes.min()} 到 {longitudes.max()}")
print(f"时间点数量: {len(time_data)}")
print(f"空气数据维度: {air_data.shape}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# 时间戳转换示例
def convert_netcdf_time(nc_time, index=0):
    """转换NetCDF时间戳为可读格式"""
    base_date = datetime.datetime(1800, 1, 1, 0, 0, 0)
    time_delta = datetime.timedelta(hours=float(nc_time[index]))
    return base_date + time_delta

# 数据切片示例
# 获取特定站点的时序数据
station_timeseries = air_data[:, 1, 0]  # 纬度索引1, 经度索引0的所有时间点

# 获取特定时间点的空间数据
spatial_data = air_data[0, :, :]  # 第一个时间点的所有空间数据

# 中国区域数据提取
def extract_china_region(air_data, lons, lats):
    """
    提取中国区域的数据
    中国范围大约: 北纬 3~53°, 东经 73~135°
    """
    # 查找中国范围内的索引
    lat_mask = (lats >= 3) & (lats <= 53)
    lon_mask = (lons >= 73) & (lons <= 135)

    china_air = air_data[:, lat_mask, :]
    china_air = china_air[:, :, lon_mask]

    china_lats = lats[lat_mask]
    china_lons = lons[lon_mask]

    return china_air, china_lons, china_lats

# 提取中国区域数据
china_air, china_lons, china_lats = extract_china_region(air_data, longitudes, latitudes)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

# 可视化函数
def plot_netcdf_data(lons, lats, data, title, levels=20):
    """绘制NetCDF数据"""
    b_map = Basemap(
        resolution='l',
        area_thresh=10000,
        projection='cyl',
        llcrnrlon=min(lons),
        urcrnrlon=max(lons),
        llcrnrlat=min(lats),
        urcrnrlat=max(lats)
    )

    fig, ax = plt.subplots(figsize=(12, 8))

    # 创建网格
    lon_grid, lat_grid = np.meshgrid(lons, lats)
    x, y = b_map(lon_grid, lat_grid)

    # 绘制数据
    contour = b_map.contourf(x, y, data, levels=levels, cmap='RdBu_r')
    b_map.colorbar(contour, label='温度 (°C)')

    # 添加地理要素
    b_map.drawcoastlines()
    b_map.drawcountries()
    b_map.drawstates()

    # 添加网格线
    b_map.drawmeridians(
        np.arange(np.floor(min(lons)), np.ceil(max(lons)), 10),
        labels=[0, 0, 0, 1]
    )
    b_map.drawparallels(
        np.arange(np.floor(min(lats)), np.ceil(max(lats)), 10),
        labels=[1, 0, 0, 0]
    )

    plt.title(title, fontsize=16)
    plt.tight_layout()
    plt.show()

# 绘制前几个时间点的中国区域数据
for i in range(min(5, len(china_air))):
    time_str = convert_netcdf_time(time_data, i).strftime("%Y-%m-%d")
    plot_netcdf_data(
        china_lons,
        china_lats,
        china_air[i, :, :],
        f"中国区域气温 - {time_str}"
    )

# 关闭NetCDF文件
nc_file.close()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

import json
import random
import time
import requests


def process_json(uid, *args):
    # 读取json格式数据，注意最后一项末尾不能有逗号
    data = json.loads("""
        {
            "uuid": "1",
            "appId": 42
        }
    """)
    data['uuid'] = uid
    # 返回字典
    return json.dumps(data)

def get_headers():
    headers = {
        "Host": "",
        "Connection": "keep-alive",
        "Content-Length": "",
        "sec-ch-ua" : """" Not A;Brand";v="99", "Chromium";v="100", "Google Chrome";v="100" """,
        "sec-ch-ua-mobile": "?0",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36",
        "sec-ch-ua-platform": "Windows",
        "Content-Type":"application/x-www-form-urlencoded",
        "Accept":"*/*",
        "Origin" :"",
        "Referer":"",
        "Accept-Encoding":"gzip, deflate, br",
        "Accept-Language":"zh-CN,zh;q=0.9 ",
    }
    return headers

def sent_post(uid):
    url = "https://virtualcourse.zhihuishu.com/report/saveReport"
    data = {
        "jsonStr": process_json(uid),
        "ticket": None
    }
    headers = get_headers()
    response = requests.post(url, data=data, headers=headers)
    print(response.status_code, response.text)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver import ActionChains
from time import sleep
import requests
import pyautogui


URL = 'https://passport.zhihuishu.com/login'
username = 'xxx'
password = 'xxx'
# 填写 msedgedriver 路径
browser = webdriver.Edge('C:\Program Files (x86)\Microsoft\Edge\Application\msedgedriver.exe')


# 最大化浏览器窗口
# browser.maximize_window()
# 设置浏览器窗口大小
browser.set_window_size(1280, 720)
# 创建等待时间对象
wait = WebDriverWait(browser, 300, 1)
# 向目标网站发送请求
browser.get(URL)
sleep(3)

# 某些内容需要等待网页加载完成才会出现，之后进行点击
username_loc = wait.until(
    EC.presence_of_element_located(
        (By.XPATH, "//input[@id='lUsername']")
    )
)

# 填写手机号和秘密
username_loc = browser.find_element(
    By.XPATH, "//input[@id='lUsername']"
)
username_loc.clear()
username_loc.send_keys(username)
sleep(1)
password_loc = browser.find_element(
    By.XPATH, "//input[@id='lPassword']"
)
password_loc.clear()
password_loc.send_keys(password)
sleep(1)

# 模拟鼠标点击登录按钮
register_button = wait.until(
    EC.presence_of_element_located(
        (By.XPATH, "//span[@class='wall-sub-btn']")
    )
)
# 将鼠标移动到按钮位置
ActionChains(browser) \
    .move_to_element(register_button) \
    .perform()
# 进行点击操作
register_button.click()
sleep(1)

# 模拟鼠标点击 “我的学堂”
xuetang_button = wait.until(
    EC.presence_of_element_located(
        (By.XPATH, "//a[@href='https://onlineweb.zhihuishu.com']")
    )
)
ActionChains(browser) \
    .move_to_element(xuetang_button) \
    .perform()
xuetang_button.click()
sleep(5)

# 模拟鼠标点击进入虚拟仿真
courseName_button = wait.until(
    EC.presence_of_element_located(
        (By.XPATH, "//div[@class='courseName' and @data-v-5451e64c='']")
    )
)
ActionChains(browser) \
    .move_to_element(courseName_button) \
    .perform()
courseName_button.click()
sleep(1)

# 获取当前窗口
# currentwindow = browser.current_window_handle
# print(currentwindow)
# sleep(1)

# 获取所有的窗口
all_window = browser.window_handles
print(all_window)
browser.switch_to.window(all_window[-1])
sleep(1)

# 模拟鼠标点击实验资源
resources_button = wait.until(
    EC.presence_of_element_located(
        (By.XPATH, "//span[@style='']")
    )
)
ActionChains(browser) \
    .move_to_element(resources_button) \
    .perform()
resources_button.click()
sleep(1)

# 模拟鼠标点击开始实验
start_button = wait.until(
    EC.presence_of_element_located(
        (By.XPATH, "//button[@class='el-button btn el-button--primary']")
    )
)
ActionChains(browser) \
    .move_to_element(start_button) \
    .perform()
start_button.click()
sleep(1)

all_window = browser.window_handles
print(all_window)
browser.switch_to.window(all_window[-1])
sleep(30)

waitload = wait.until(
    EC.text_to_be_present_in_element(
        (By.XPATH, "//div[@id='jindu_num']"),
        "资源加载中：100%"
    )
)
sleep(5)
# 点击跳过帮助，x和y是鼠标横纵坐标
pyautogui.click(x=900, y=930, )

# 开头的讲话
sleep(39)

pyautogui.moveTo(600, 500)
sleep(5)
# 按住鼠标右键并拖动，持续时间2秒
pyautogui.dragRel(300, 0, duration=2, button='right')
sleep(5)

# 通过控制键盘实现向前走动四步，抵达前言
for i in range(4):
    ActionChains(browser) \
        .send_keys(Keys.UP) \
        .perform()
    sleep(0.5)
sleep(100) #需要等待大概 100秒

# 向右走动十步
for i in range(10):
    ActionChains(browser) \
        .send_keys(Keys.RIGHT) \
        .perform()
    sleep(0.5)

# 关闭浏览器
browser.quit()

1
2
3
4
5
6
7
8
9

{
  "event_mention": {
    "event_type": "Exhibit",
    "trigger": {
      "text": "展示",
      "offset": [12, 13]
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import sys
import getopt

def main(argv):
    inputfile = ''
    try:
        opts, args = getopt.getopt(argv, "hi:o:", ["ifile=", "ofile="])
    except getopt.GetoptError:
        print('usage: test.py -i <inputfile> -o <outputfile>')
        sys.exit(2)

    for opt, arg in opts:
        if opt == '-h':
            print('test.py -i <inputfile> -o <outputfile>')
            sys.exit()
        elif opt in ("-i", "--ifile"):
            inputfile = arg
        elif opt in ("-o", "--ofile"):
            outputfile = arg

    print('Input file:', inputfile)
    print('Output file:', outputfile)

if __name__ == "__main__":
    main(sys.argv[1:])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import configparser


# 创建管理对象
conf = configparser.ConfigParser()
# 读取配置文件
conf.read('./GloVar.ini', encoding='utf-8')
print(conf.sections())

# 删除不需要的 section
if conf.has_section("CoarseAdjust"):
    # 删除该 section 下的所有内容
    conf.remove_section("CoarseAdjust")

# 添加 section 并向其中添加 key 和 value
conf.add_section("CoarseAdjust")
conf.set("CoarseAdjust", "xPerAngle", "{}".format(500))
conf.set("CoarseAdjust", "yPerAngle", "160")

items = conf.items('CoarseAdjust')
print(items)
# list 里面对象是元组

with open("GloVar.ini", "w+") as f:
    conf.write(f)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

import jieba
import pandas as pd
import numpy as np

# 示例数据 (假设 'data' 是包含 'Comment' 列的 DataFrame)
data = pd.DataFrame({'Comment': ['这个手机非常好', '电池续航太差了'], 'Class': [1, -1]})

# 使用匿名函数进行分词
my_cut = lambda x: ' '.join(jieba.cut(x))

# 对每条评论进行分词处理
cutted = [my_cut(line) for line in data["Comment"]]
cutted_array = np.array(cutted)

# 创建分词后的新 DataFrame
data_cutted = pd.DataFrame({
    'Comment': cutted_array,
    'Class': data['Class']
})
data_cutted.index = range(0, len(data_cutted))
print(data_cutted)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

def stop_word_processing(stop_file, unstoped_texts):
    """
    处理停用词的函数

    参数:
    stop_file: 停用词文件路径
    unstoped_texts: 未处理停用词的文本列表

    返回:
    处理后的文本字符串
    """
    with open(stop_file, 'r', encoding='utf8') as f:
        stop_list = [line.strip('\n') for line in f.readlines()]

    outstr = ''
    for line in unstoped_texts:
        for word in line.split(' '):
            if word not in stop_list and word != '\t':
                outstr += word + ' '
    return outstr

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

from wordcloud import WordCloud
import matplotlib.pyplot as plt


a = stop_word_processing('stopwords.txt', data_cutted['Comment'][data_cutted['Class']==1])

# 生成词云
font_path = 'path/to/your/font.ttf'  # 中文字体路径
wordcloud = WordCloud(
    font_path = font,           # 设置字体
    max_words = 100,            # 词云显示的最大词数
    background_color = 'white', # 背景颜色
    scale=32                    # 按照比例进行放大画布,使得图片清晰
)
wordcloud.generate(a)
wordcloud.to_file('wordcloud.png')

# 显示词云
plt.figure(figsize = (20, 10))   # 设置画布大小
plt.imshow(wordcloud)          # 画图
plt.axis('off')                  # 取消坐标轴
plt.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import dlib
import cv2


print("GPU计算是否启用：", dlib.DLIB_USE_CUDA)
mysql_host = "s1.mc.fyi"
mysql_post = 11452
mysql_user = "root"
mysql_password = "##########"
mysql_db = "attendance_system"
login_url = "http://s1.mc.fyi:11453/login/"
login_header = {'Content-Type': 'application/json'}
login_username = "201635020501"
login_password = "##########"
upload_url = "http://s1.mc.fyi:11453/access_control/"
# 判断识别阈值，欧式距离小于0.4即可判断为相似，越小越严格
threshold = 0.4

# 初始化Dlib组件
# 创建正向人脸检测器
detector = dlib.get_frontal_face_detector()
# 创建人脸 5 特征点检测器
predictor = dlib.shape_predictor("shape_predictor_5_face_landmarks.dat")
# 导入 Dlib 预先学习的人脸识别模型
face_rec = dlib.face_recognition_model_v1("dlib_face_recognition_resnet_model_v1.dat")

# OpenCV 调用摄像头
cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)
# 设置视频参数
cap.set(3, 480)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

from datetime import datetime, timedelta
import pymysql

def get_user_face_data(get_time, data):
    """
    从数据库获取人脸数据(缓存五分钟)

    参数:
    get_time: 上次获取数据的时间
    data: 上次获取的数据内容

    返回:
    更新时间, 数据内容
    """
    if get_time == "" or get_time < (datetime.now() - timedelta(minutes=5)):
        # 连接数据库
        conn = pymysql.connect(
            host=mysql_host,
            port=mysql_post,
            user=mysql_user,
            password=mysql_password,
            db=mysql_db,
            charset='utf8'
        )
        # 创建游标
        cur = conn.cursor()
        sql = """
        SELECT user_id, username, first_name, last_name, features
        FROM users_userface
        INNER JOIN users_user
          ON users_userface.user_id = users_user.id;
        """
        # 执行语句
        cur.execute(sql)
        result = cur.fetchall()
        # 关闭连接池
        cur.close()
        conn.close()
        return datetime.now(), result
    return get_time, data


# 上传图片
def upload_image(save_name, user_id, euclidean_distance):
    with open('temp/' + save_name, mode="rb")as f:  # 打开文件
        file = {
            "file": (save_name, f.read())  # 引号的file是接口的字段，后面的是文件的名称、文件的内容
        }
    upload_post_result = requests.post(url=upload_url + '?user_id=' + str(user_id) + '&euclidean_distance=' + str(euclidean_distance),
                                       headers={
                                           'Authorization': 'JWT ' + login_token
                                       },
                                       files=file)
    print("[BACKEND]", json.loads(upload_post_result.text)['detail'])


# 保存图片
def save_image(image):
    save_name = datetime.now().strftime("%Y-%m-%d %H-%M-%S") + '.jpg'
    cv2.imwrite('temp/' + save_name, image)
    return save_name

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

# 初始化数组等
get_time = datetime.strptime("2020-01-01", "%Y-%m-%d")
calculate_time = datetime.strptime("2020-01-01", "%Y-%m-%d")
data = ""
face_descriptor_old = ""
two_sec_min_euclidean_distance_list = []
two_sec_min_user_info_list = []
two_sec_min_img_list = []
name = ""
color = (0, 0, 0)


# 摄像头循环
while cap.isOpened():
    flag, img_read = cap.read()
    kk = cv2.waitKey(1)

    img_gray = cv2.cvtColor(img_read, cv2.COLOR_RGB2GRAY)
    # 人脸数 faces
    faces = detector(img_gray, 0)
    # 使用的字体
    font = cv2.FONT_HERSHEY_COMPLEX

    if len(faces) != 0:
        # 展示矩形框
        for k, d in enumerate(faces):
            # 判断是否超出边界
            if d.right() > 640 or d.bottom() > 480 or d.left() < 0 or d.top() < 0:
                name = "请保证人脸不要超出边界。"
                color = (255, 0, 0)
            # 判断是否多个人
            elif len(faces) != 1:
                name = "请保证摄像头范围内只存在一人。"
                color = (255, 0, 0)
            else:
                # 采用 Dlib 的人脸5特征点检测器
                shape = predictor(img_gray, d)
                # 生成单张人脸图像的128D特征
                face_descriptor = face_rec.compute_face_descriptor(img_read, shape)

                # 从数据库获取人脸数据(缓存五分钟)
                get_time, data = get_user_face_data(get_time, data)

                # 计算欧氏距离
                euclidean_distance_list = []
                for one_data in data:
                    euclidean_distance_list.append(return_euclidean_distance(json.loads(one_data[4]), face_descriptor))

                """
                if face_descriptor_old != "":
                    if return_euclidean_distance(face_descriptor_old, face_descriptor) > 0.4:
                        print("检测到摄像头前换人了。")
                        name = ""
                        two_sec_min_euclidean_distance_list = []
                        two_sec_min_user_info_list = []
                        two_sec_min_img_list = []
                face_descriptor_old = face_descriptor
                """

                # 每两秒保存一次
                if calculate_time < (datetime.now() - timedelta(seconds=2)):
                    if two_sec_min_euclidean_distance_list:
                        if min(two_sec_min_euclidean_distance_list) < threshold:
                            index = two_sec_min_euclidean_distance_list.index(
                                min(two_sec_min_euclidean_distance_list)
                            )
                            print("[MESSAGE]识别成功，你可能是：",
                                two_sec_min_user_info_list[index][2],
                                two_sec_min_user_info_list[index][3],
                                "，欧式距离：", min(two_sec_min_euclidean_distance_list), "。")
                            save_name = save_image(two_sec_min_img_list[index])
                            upload_image(save_name, two_sec_min_user_info_list[index][0], min(two_sec_min_euclidean_distance_list))
                            name = two_sec_min_user_info_list[index][2] + two_sec_min_user_info_list[index][3]
                            color = (0, 255, 0)
                        else:
                            print("[MESSAGE]识别失败，请完善自己账户人脸信息或联系管理员！")
                            name = "识别失败，请完善自己账户人脸信息或联系管理员！"
                            color = (255, 0, 0)
                    two_sec_min_euclidean_distance_list = []
                    two_sec_min_user_info_list = []
                    two_sec_min_img_list = []
                    calculate_time = datetime.now()
                else:
                    two_sec_min_euclidean_distance_list.append(min(euclidean_distance_list))
                    two_sec_min_user_info_list.append(data[euclidean_distance_list.index(min(euclidean_distance_list))])
                    two_sec_min_img_list.append(img_read)

            # 画边框
            cv2.rectangle(
                img_read,
                tuple([d.left(), d.top()]),
                tuple([d.right(), d.bottom()]),
                (255, 255, 255), 2
            )
            # 文字位置
            pos_namelist = tuple([d.left() + 5, d.bottom() - 25])
            img_read = change_cv2_draw(img_read, name, pos_namelist, 13, color)

    cv2.imshow("Dormitory Access Control System(Camera)", img_read)

1

batch_conf = conf_data.view(-1, self.num_classes)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_theme()


# ---------- 读取所需列 ----------
listingsdata = pd.read_csv(
    '数据文件路径/listings.csv',
    usecols=[
        'property_type', 'room_type', 'accommodates',
        'bedrooms', 'price']
)
listingsdata.head(5)

# ---------- 数据类型转换：将 price 从字符串转为数值 ----------
# 方法一：使用列表推导式
price_list = [
    float(item.replace(',', '')[1:])   # 去掉千分位和美元符号
    for item in listingsdata['price']
]
listingsdata['price'] = price_list

# 方法二：apply（大数据量时更高效）
def price_convert(x: str) -> float:
    """去除千分位和前缀符号后转为 float"""
    return float(x.replace(',', '')[1:])

listingsdata['price'] = listingsdata['price'].apply(price_convert)

# ---------- 数据可视化 ----------
# 1. 绘制箱线图
plt.figure(figsize=(16, 9))
sns.boxplot(
    x='property_type',
    y='price',
    data=listingsdata
)
# 将横坐标的刻度旋转 90°
plt.xticks(rotation=90)
plt.title('不同房屋类型的租金分布')
plt.show()

# 2. 分类数据绘图（默认 kind='strip'，可改为 'box'、'boxen'、'violin' 等）
sns.catplot(
    x='accommodates',
    y='price',
    data=listingsdata,
    color='m',
    estimator=np.median,
    height=8,
    aspect=1.35
)
plt.title('可容纳人数与租金的中位数关系')
plt.show()

# 3、绘制热力图
plt.figure(figsize=(16, 9))
sns.heatmap(
    listingsdata.groupby(['property_type', 'bedrooms'])['price']
        .mean()
        .unstack(),
        # 分组求和
        # 先按照'property_type', 'bedrooms'列分组
        # 再取出 price 求和
    annot = True, #用于显示每个方形内部的数值
    fmt = '.0f', #控制数值小数的位数
    cmap='YlGnBu'
)
plt.title('房屋类型 / 卧室数 与平均租金热力图')
plt.show()