一：安装 vision seed SDK
1:如何安装SDK？
WIN+R进入cmd工具窗口,通过python pip工具执行命令pip install –upgrade vision安装。
如下：
二:如何从visionseed获取数据
1：获取数据的第一步需要将VisionSeed通过USB数据线连接到电脑
2：了解sdk获取相关算法数据的调用方法。
进入visionseed sdk官网: https://visionseed.youtu.qq.com/docs/sdk-python/
了解获取如何调用相关API的相关方法:
三:开发人脸疲劳检测程序
如图示为左眼（对于算法是左眼，实际为人的右眼）的配准点信息，该信息可以从YtFaceShape中获取。我们可以通过以下公式判定人眼的睁开和闭合状态。
openness= distance(p[6],p[2])
即人眼的睁开程度openness正比于眼部上下配准点的距离。但是这样使用绝对距离不能解决人与摄像头距离变化的问题，离摄像头越远，眼睛越小。考虑到人眼都是左右距离大于上下距离，所以我们可以使用下面的公式进行归一化，这样就避免了使用绝对值带来的问题。
openness=(distance(p[6],p[2]))/(distance(p[0],p[4]))
即人眼的睁开程度openness（0~1）正比于眼部上下配准点的距离，反比于眼部左右配准点的距离。
首先导入sdk包和相关的依赖包: (缺少相关包的话需要通过pip工具进行安装)
新建一个get_visionseed_data.py文件:
from visionseed import YtVisionSeed, YtDataLink #调用sdk依赖包
import serial #读取visionseed硬件端口数据的依赖包
import datetime #获取当前时间数据的依赖包
import cv2 as cv #安装并调用opencv-python库作为读取RGB摄像头数据,并显示人脸识别窗口
然后需要实例化一个YtVisionSeed类作为获取相关处理数据的对象
datalink = YtVisionSeed(serial.Serial(“COM5”,115200,timeout=0.5))
注意这里的“COM5”需要根据VisionSeed连接到电脑后的实际串口号进行修改，可以通过windows的设备管理器查看VisionSeed对应的串口号.
可通过WIN+R键并输入命令: devmgmt.msc 即可打开设备管理器查看对应串口号
初始化调用visionseed摄像头,代码如下:
#读取摄像头数据
cap = cv.VideoCapture(1) #0是读取本地电脑自带摄像头的数据,改为1读取visionseed数据
if (cap.isOpened() == False):
print("不能读取visionseed摄像头数据")
exit(0)
编写函数不断的调用datalink对象的recvRunOnce方法从VisionSeed获取人眼关键点数据:
def main():
while True:
#显示摄像头数据
if (cap.isOpened()):
ret, frame = cap.read()
cv.namedWindow('frame', cv.WINDOW_NORMAL)
cv.imshow('frame', frame)
k = cv.waitKey(1)
if k == 27:
cap.release()
cv.destroyAllWindows()
break
result, msg = datalink.recvRunOnce()
if result:
YtVisionSeedModel = YtDataLink.YtVisionSeedModel
#count是检测到的人脸的数量
count = result.getResult([YtVisionSeedModel.FACE_DETECTION])
#对检测到的每一张人脸获取其相关处理后的数据
for i in range(count):
line = ''
# 获取人脸识别结果
faceName = result.getResult([YtVisionSeedModel.FACE_DETECTION, i, YtVisionSeedModel.FACE_RECOGNITION])
if (faceName):
line += 'name: %s (confidence: %.3f) ' % (faceName.str, faceName.conf)
shape = result.getResult([YtVisionSeedModel.FACE_DETECTION, i, YtVisionSeedModel.FACE_LANDMARK])
if (shape):
# 计算眼睛的睁开程度,根据眼睛上下点的距离与左右眼角的距离比值得到眼睛睁开的程度
faceShape = shape.faceShape
leftEyeOpenness = (faceShape.leftEye[6] - faceShape.leftEye[2]).length() / (
faceShape.leftEye[0] - faceShape.leftEye[4]).length()
rightEyeOpenness = (faceShape.rightEye[6] - faceShape.rightEye[2]).length() / (
faceShape.rightEye[0] - faceShape.rightEye[4]).length()
#再通过设置眼睛是否闭着的‘阈值’，当眼睛的睁开程度小于该数字就判定为紧闭。
上述代码已经基本实现疲劳的判定，但是如果人头部偏向某一侧，使得其中一个眼睛被遮挡，那么这样该眼部的配准点信息将不可靠。故还需要通过姿态信息来对此进行改进。
结合下图理解头部姿态信息，理解各个姿态角的意义。如图示，我们可以通过判断yaw角度来选择可信度比较高的眼睛配准点，当人脸往左边偏转（yaw>0）的时候，使用右边眼睛的睁开程度，当人脸往右边偏转(yaw<0)的时候，使用左边眼睛的睁开程度。
即在上述代码的基础上增加如下代码:
# 增加使用头部姿态信息yaw角度进行优化,比如当人左倾,使用右眼的信息判断疲劳,当人右倾,使用左眼的信息判断疲劳
pose = result.getResult([YtVisionSeedModel.FACE_DETECTION, i, YtVisionSeedModel.FACE_POSE])
if not(pose is None):
yawAngle = pose.array[1]
print('头部左偏,正通过您的右眼进行判断' if yawAngle < 0 else '头部右偏,正通过您的左眼进行判断', yawAngle)
eyeOpenness = leftEyeOpenness if yawAngle < 0 else rightEyeOpenness
else:
eyeOpenness = (leftEyeOpenness + rightEyeOpenness) / 2
这样前述任务利用眼部配准点计算人眼的开闭状态结合姿态实现了疲劳监测的基本功能。不过上述程序一旦监测到人眼闭合就会报警，这样即使眨眼也会被误判为疲劳，这显然是不合理的。解决该问题的基本想法是只有连续一段时间都闭着眼睛才判定为疲劳即可，即我们需要缓存一段时间之内的眼睛睁开状态。故我将使用RingBuffer缓存来实现这想法，对疲劳监测程序进行进一步的优化。
(1) 首先使用以下命令安装numpy和numpy_ringbuffer库
即 pip install numpy 和 pip install numpy_ringbuffer
(2) 然后在前面程序中导入这两个包,即：
import numpy as np
from numpy_ringbuffer import RingBuffer#增加环形buffer缓存一段时间的状态
(3):然后需要在上述代码的基础上改进并增加如下代码:
需要在实例化datalink增加如下一行代码:
#实例化YTdataLink类
datalink = YtVisionSeed(serial.Serial(“COM5”,115200,timeout=0.5))
新增以下语句，定义一个capacity为5的RingBuffer，用来存储疲劳状态
eyeClosedRingBuffer = RingBuffer(capacity=5, dtype=np.bool)
还需要增加在前面main函数的基础上定义新的函数:eyeReallyClosed()
def main():
# 增加一个RingBuffer缓存进行优化的函数
def eyeReallyClosed():
# 当ringbuffer中的所有记录都为闭眼时才判定为真的闭眼，以避免对眨眼的误判
for close in eyeClosedRingBuffer:
# 利用for循环遍历,如果存在是not true成立,即有存在不是闭眼的情况,就是返回False,不是真的劳累
if not close:
return False
return True # 否则就是buffer缓存中都是True，即都是闭眼,返回True,是真的劳累
while True:
#显示摄像头数据
if (cap.isOpened()):
……… 省略
还需要在设置阈值处增加如下代码:
设置判断眼睛是否闭着的‘阈值’，当眼睛的睁开程度小于该数字就判定为紧闭
threshold = 0.1
append方法 增加比较结果的bool值存入Buffer缓存中.
eyeClosedRingBuffer.append(eyeOpenness < threshold) # 这里的计算结果小于阈值是True成立的话即是闭眼,false则不是闭眼,
四: 创建一个保存数据的本地数据库和数据库表单
创建一个create_database.py文件：其中代码如下
import mysql.connector
from mysql.connector import Error
database = 'exhausted_state_monitor'
tableName = 'exhausted_state'
def createDb(host='localhost', user='root', password='你的数据库密码'): #注意这里的密码需要和创建数据库时候设定的密码一致
try:
connection = mysql.connector.connect(host=host,
user=user,
password=password)
if connection.is_connected():
cursor = connection.cursor()
sql = """CREATE DATABASE IF NOT EXISTS {};
USE {};
CREATE TABLE IF NOT EXISTS {} (
time DATETIME PRIMARY KEY,
name VARCHAR(255),
face_rect_x SMALLINT,
face_rect_y SMALLINT,
face_rect_h SMALLINT,
face_rect_w SMALLINT
);""".format(database, database, tableName)
for result in cursor.execute(sql, multi=True):
if result.with_rows:
print("Rows produced by statement '{}':".format(result.statement))
print(result.fetchall())
else:
print("Number of rows affected by statement '{}': {}".format(
result.statement, result.rowcount))
cursor.close()
except Error as e:
print('error while create database', e)
finally:
if connection.is_connected():
connection.close()
if __name__ == "__main__":
createDb()
运行脚本创建数据库
五：在疲劳检测代码基础上增加将数据保存到本地数据库
实验基础:已安装并配置好本地的mysql数据库。
需要用到的模块:
import pymysql #数据库连接依赖库
import re #字符串正则匹配依赖库
在get_visionseed_data.py文件代码的基础上增加一个保存数据到数据库的函数,代码如下:
"""数据保存至本地数据库"""
def logto(strnow, name, x, y, w, h):
# 使用pymysql.connect方法连接数据库
db = pymysql.connect(host='127.0.0.1', port=3306, user='root', password='你的数据库密码',
database='exhausted_state_monitor', charset='utf8')
# 操作数据库，获取db下的cursor对象
cursor = db.cursor()
# 使用cursor.execute来执行SQL语句
# 提交表单内条写入数据库
sql = "insert into exhausted_state (time,name,face_rect_x,face_rect_y,face_rect_h,face_rect_w)values(%s,%s,%s,%s,%s,%s)"
try:
# 执行sql语句
cursor.execute(sql, (strnow, name, x, y, w, h ))
# 提交到数据库执行
print("已保存一条劳累的记录")
db.commit()
#print("已保存一条劳累的记录")
except Exception as err:
# 检查异常原因是否是感兴趣的
result1 = re.search('Duplicate entry.*key.*PRIMARY', str(err))
# 如果是，什么都不用做
# 否则（也不知道是什么原因），那就回滚吧
if (result1 == None):
# 如果发生错误则回滚
db.rollback()
# 关闭数据库连接
db.close()
增加完保存至数据库的函数后,需要再改进下前面的代码:(当检测到疲劳时,就写入数据库)
代码改动一如下:
多定义一个时间间隔
leastTimeToRecordState = 2 #second
在while前面初始化上一次写入数据库的时间戳,即lastLogTime
def main():
# 增加一个RingBuffer缓存进行优化的函数
def eyeReallyClosed():
# 当ringbuffer中的所有记录都为闭眼时才判定为真的闭眼，以避免对眨眼的误判
for close in eyeClosedRingBuffer:
# 利用for循环遍历,如果存在是not true成立,即有存在不是闭眼的情况,就是返回False,不是真的劳累
if not close:
return False
return True # 否则就是buffer缓存中都是True，即都是闭眼,返回True,是真的劳累
# 初始化上一次写入数据库的时间戳
lastLogTime = datetime.datetime.now()
while True:
……… 省略
代码改动二如下:
# append方法 增加比较结果的bool值存入Buffer缓存中.
eyeClosedRingBuffer.append(eyeOpenness < threshold) # 这里的计算结果小
于阈值是True成立的话即是闭眼,false则不是闭眼
"""前面基础上新增加的代码如下"""
#获取姓名
name = result.getResult(
[YtVisionSeedModel.FACE_DETECTION, i, YtVisionSeedModel.FACE_RECOGNITION])
if (name):
print("识别人的姓名是:" + name.str)
name = name.str
else:
print("识别的人未知")
# 获取人脸坐标
rect = result.getResult([YtVisionSeedModel.FACE_DETECTION, i])
if (rect):
x = rect.x
y = rect.y
w = rect.w
h = rect.h
print("检测到人脸,x坐标{},y坐标,宽度{},高度{}".format(x, y, w, h))
# 判断是否真的劳累状态下的闭眼的布尔值
if eyeReallyClosed():
print("你是劳累的,将会把记录写入数据库")
# 获取当前的时间
now = datetime.datetime.now()
print(now)
# 将时间格式转化为数据库支持的datetime格式
strnow = now.strftime('%Y-%m-%d %H:%M:%S')
# 只在给定的时间间隔之后才将疲劳状态写入数据库
if (now - lastLogTime).seconds >= leastTimeToRecordState:
logto(strnow, name, x, y, w, h)
else:
print("你并不劳累")
故最终的get_visionseed_data.py代码如下:
from visionseed import YtVisionSeed,YtDataLink
import serial #串口库
import datetime
import numpy as np
from numpy_ringbuffer import RingBuffer#增加环形buffer进行缓存一段时间的状态
import pymysql #数据库连接依赖库
import re #字符串正则匹配依赖库
import cv2 as cv #利用opencv进行视频图像输出
#实例化YTdataLink类
datalink = YtVisionSeed(serial.Serial("COM5",115200,timeout=0.5))
"""定义一个capacity为5的RingBuffer，用来存储一段时间疲劳状态,用于判断,不存储的话一闭眼就被误报检测为劳累
适当调节RingBuffer的capacity以在延迟和误判之间取得平衡。
RingBuffer相当于对数据进行了滤波处理，这样使得程序的响应变慢了。可以考虑调整RingBuffer的长度在实时性和避免误判之间平衡。
"""
eyeClosedRingBuffer = RingBuffer(capacity=5, dtype=np.bool)
"""
只要检测到疲劳就立即会写入数据库，当人眼紧闭的时候则会持续不断的写入数据库，所以我们对写入的频率进行限制
"""
leastTimeToRecordState = 1.5 #second为单位
#读取摄像头数据
cap = cv.VideoCapture(1) #0是读取本地电脑自带摄像头的数据,改为1读取visionseed数据
if (cap.isOpened() == False):
print("不能读取摄像头数据")
exit(0)
"""数据保存至本地数据库"""
def logto(strnow, name, x, y, w, h):
# 使用pymysql.connect方法连接数据库
db = pymysql.connect(host='127.0.0.1', port=3306, user='root', password='你的数据库密码',
database='exhausted_state_monitor', charset='utf8')
# 操作数据库，获取db下的cursor对象
cursor = db.cursor()
# 使用cursor.execute来执行SQL语句
# 提交表单内条写入数据库
sql = "insert into exhausted_state (time,name,face_rect_x,face_rect_y,face_rect_h,face_rect_w)values(%s,%s,%s,%s,%s,%s)"
try:
# 执行sql语句
cursor.execute(sql, (strnow, name, x, y, w, h ))
# 提交到数据库执行
print("已保存一条劳累的记录")
db.commit()
#print("已保存一条劳累的记录")
except Exception as err:
# 检查异常原因是否是感兴趣的
result1 = re.search('Duplicate entry.*key.*PRIMARY', str(err))
# 如果是，什么都不用做
# 否则（也不知道是什么原因），那就回滚吧
if (result1 == None):
# 如果发生错误则回滚
db.rollback()
# 关闭数据库连接
db.close()
def main():
# 增加一个RingBuffer缓存进行优化的函数
def eyeReallyClosed():
# 当ringbuffer中的所有记录都为闭眼时才判定为真的闭眼，以避免对眨眼的误判
for close in eyeClosedRingBuffer:
# 利用for循环遍历,如果存在是not true成立,即有存在不是闭眼的情况,就是返回False,不是真的劳累
if not close:
return False
return True # 否则就是buffer缓存中都是True，即都是闭眼,返回True,是真的劳累
# 初始化上一次写入数据库的时间戳
lastLogTime = datetime.datetime.now()
while True:
#显示摄像头数据
if (cap.isOpened()):
ret, frame = cap.read()
cv.namedWindow('frame', cv.WINDOW_NORMAL)
cv.imshow('frame', frame)
k = cv.waitKey(1)
if k == 27:
cap.release()
cv.destroyAllWindows()
break
result, msg = datalink.recvRunOnce()
if result:
YtVisionSeedModel = YtDataLink.YtVisionSeedModel
count = result.getResult([YtVisionSeedModel.FACE_DETECTION])
for i in range(count):
line = ''
# 获取人脸识别结果
faceName = result.getResult([YtVisionSeedModel.FACE_DETECTION, i, YtVisionSeedModel.FACE_RECOGNITION])
if (faceName):
line += 'name: %s (confidence: %.3f) ' % (faceName.str, faceName.conf)
shape = result.getResult([YtVisionSeedModel.FACE_DETECTION, i, YtVisionSeedModel.FACE_LANDMARK])
if (shape):
# 计算眼睛的睁开程度,根据眼睛上下点的距离与左右眼角的距离比值得到眼睛睁开的程度
faceShape = shape.faceShape
leftEyeOpenness = (faceShape.leftEye[6] - faceShape.leftEye[2]).length() / (
faceShape.leftEye[0] - faceShape.leftEye[4]).length()
rightEyeOpenness = (faceShape.rightEye[6] - faceShape.rightEye[2]).length() / (
faceShape.rightEye[0] - faceShape.rightEye[4]).length()
# 增加使用头部姿态信息yaw角度进行优化,比如当人左倾,使用右眼的信息判断疲劳,当人右倾,使用左眼的信息判断疲劳
pose = result.getResult([YtVisionSeedModel.FACE_DETECTION, i, YtVisionSeedModel.FACE_POSE])
if not(pose is None):
yawAngle = pose.array[1]
print('头部左偏,正通过您的右眼进行判断' if yawAngle < 0 else '头部右偏,正通过您的左眼进行判断', yawAngle)
eyeOpenness = leftEyeOpenness if yawAngle < 0 else rightEyeOpenness
else:
eyeOpenness = (leftEyeOpenness + rightEyeOpenness) / 2
# 设置判断眼睛是否闭着的‘阈值’，当眼睛的睁开程度小于该数字就判定为紧闭
threshold = 0.1
# append方法 增加比较结果的bool值存入Buffer缓存中.
eyeClosedRingBuffer.append(eyeOpenness < threshold) # 这里的计算结果小于阈值是True成立的话即是闭眼,false则不是闭眼
"""前面基础上新增加的代码如下"""
#获取姓名
name = result.getResult(
[YtVisionSeedModel.FACE_DETECTION, i, YtVisionSeedModel.FACE_RECOGNITION])
if (name):
print("识别人的姓名是:" + name.str)
name = name.str
else:
print("识别的人未知")
# 获取人脸坐标
rect = result.getResult([YtVisionSeedModel.FACE_DETECTION, i])
if (rect):
x = rect.x
y = rect.y
w = rect.w
h = rect.h
print("检测到人脸,x坐标{},y坐标,宽度{},高度{}".format(x, y, w, h))
# 判断是否真的劳累状态下的闭眼的布尔值
if eyeReallyClosed():
print("你是劳累的,将会把记录写入数据库")
# 获取当前的时间
now = datetime.datetime.now()
print(now)
# 将时间格式转化为数据库支持的datetime格式
strnow = now.strftime('%Y-%m-%d %H:%M:%S')
# 只在给定的时间间隔之后才将疲劳状态写入数据库
if (now - lastLogTime).seconds >= leastTimeToRecordState:
logto(strnow, name, x, y, w, h)
else:
print("你并不劳累")
if __name__ == "__main__":
main()
六:疲劳状态监控web程序开发
实验基础:已经成功的将疲劳状态保存至本地数据库中
Web效果说明:
从保存至本地的数据库中读取数据,可将所有人的劳累数据记录显示在页面上。
并可通过查询功能显示特定姓名的劳累数据记录。(这里我以小组成员姓名进行演示)
由于运用flask的模板应用功能,需要在项目文件目录下新增一个名叫templates的文件夹,
并在其中新建一个my_web.html文件,才能在server.py文件进行调用
其中html代码文件如下:
<!doctype html>
<html>
<head>
<title>劳累状态记录表</title>
</head>
<body>
<h1>劳累状态记录表</h1>
<form name="frm" action="" method="post">
<h5>请输入需要特定查询的姓名(默认显示全部姓名和信息):</h5><input type="text" name="value" >
<input type="submit" value="查询" style="color:blue; text-align:center">
{{ info }}
</form>
<hr>
<table id="employees" style="width:50%">
<tbody>
<tr>
<th>录入时间</th>
<th>姓名</th>
<th>脸部的X坐标</th>
<th>脸部的Y坐标</th>
<th>脸部的宽度</th>
<th>脸部的高度</th>
</tr>
{% if result %}
{% for row in result %}
<tr>
<td> {{ row.time }}</td>
<td> {{ row.name }}</td>
<td> {{ row.face_rect_x }}</td>
<td> {{ row.face_rect_y }}</td>
<td> {{ row.face_rect_w }}</td>
<td> {{ row.face_rect_h }}</td>
</tr>
{% endfor %}
{% endif %}
</tbody>
</table>
</body>
</html>
<style>
table {
font-family: arial, sans-serif;
border-collapse: collapse;
width: 100%;
}
td, th {
border: 1px solid #dddddd;
text-align: left;
padding: 8px;
}
tr:nth-child(even) {
background-color: #dddddd;
}
</style>
新建一个server.py文件。
导入用到的模块:(缺少相关的包需要通过pip工具进行安装):
import flask #python的web开发依赖库
import pymysql #提取mysql数据
创建读取数据库数据的类:,代码如下:
class Database:
def __init__(self):
host = '127.0.0.1' #本地数据库地址
port = 3306
user = 'root'
password = '你的数据库密码'
database = 'exhausted_state_monitor'
charset = 'utf8' #才能操作中文字符
self.con = pymysql.connect(host=host,port=port,user=user,password=password,database=database,cursorclass=pymysql.cursors.DictCursor,charset=charset)
#展示所有人不包括特定用户的疲劳信息
def showData_all(self):
tablename = "exhausted_state"
try:
#with关键字后面才会自动关闭cursor()对象
with self.con.cursor() as cursor:
sql = "select * from {}".format(tablename)
print("执行的sql语句为:" + sql)
cursor.execute(sql)
result = cursor.fetchall()
return result
finally:
#关闭数据库连接
self.con.close()
#用户过滤,只展示特定用户的疲劳信息
def showData(self,name):
tablename = "exhausted_state"
try:
with self.con.cursor() as cursor:
#读取数据库中名字为name的所有记录，增加where关键字进行限制
sql = "select * from {} where name = '{}'".format(tablename,name)
print("执行的sql语句为:"+sql)
cursor.execute(sql)
result = cursor.fetchall()
return result
finally:
self.con.close()
增加flask web开发代码:
#初始化
app = flask.Flask(__name__)
@app.route('/',methods=['GET','POST'])
def index():
def db_query():
db = Database() #实例化类对象
result = db.showData_all()
return result
res = db_query()
def db_query_name(x):
db = Database()
result = db.showData(x)
return result
x = flask.request.values.get('value')
info = ''
print(x)
#用户过滤(当前页面版本)
if x=='Carson':
res = db_query_name(x)
elif x=='abc':
res = db_query_name(x)
elif x=='abcd':
res = db_query_name(x)
elif x== "abcde":
res = db_query_name(x)
elif x== "abcdef":
res = db_query_name(x)
elif x!=None:
info = '没有此人'
else:
res = db_query()
return flask.render_template('my_web.html', result=res,info=info,content_type='application/json')
故最终的server.py文件代码如下:
import flask #python的web开发依赖库
import pymysql #提取mysql数据
class Database:
def __init__(self):
host = '127.0.0.1' #本地数据库地址
port = 3306
user = 'root'
password = '你的数据库密码'
database = 'exhausted_state_monitor'
charset = 'utf8' #才能操作中文字符
self.con = pymysql.connect(host=host,port=port,user=user,password=password,database=database,cursorclass=pymysql.cursors.DictCursor,charset=charset)
#展示所有人不包括特定用户的疲劳信息
def showData_all(self):
tablename = "exhausted_state"
try:
#with关键字后面才会自动关闭cursor()对象
with self.con.cursor() as cursor:
sql = "select * from {}".format(tablename)
print("执行的sql语句为:" + sql)
cursor.execute(sql)
result = cursor.fetchall()
return result
finally:
#关闭数据库连接
self.con.close()
#用户过滤,只展示特定用户的疲劳信息
def showData(self,name):
tablename = "exhausted_state"
try:
with self.con.cursor() as cursor:
#读取数据库中名字为name的所有记录，增加where关键字进行限制
sql = "select * from {} where name = '{}'".format(tablename,name)
print("执行的sql语句为:"+sql)
cursor.execute(sql)
result = cursor.fetchall()
return result
finally:
self.con.close()
#初始化
app = flask.Flask(__name__)
@app.route('/',methods=['GET','POST'])
def index():
def db_query():
db = Database() #实例化类对象
result = db.showData_all()
return result
res = db_query()
def db_query_name(x):
db = Database()
result = db.showData(x)
return result
x = flask.request.values.get('value')
info = ''
print(x)
#用户过滤(当前页面版本)
if x=='Carson':
res = db_query_name(x)
elif x=='abc':
res = db_query_name(x)
elif x=='abcd':
res = db_query_name(x)
elif x== "abcde":
res = db_query_name(x)
elif x== "abcdef":
res = db_query_name(x)
elif x!=None:
info = '没有此人'
else:
res = db_query()
return flask.render_template('my_web.html', result=res,info=info,content_type='application/json')
#运行
app.debug = True
app.run()
最终运行server.py文件,效果如下:(项目web最终效果)
The End!!创作不易,欢迎点赞/评论!!欢迎关注个人公众号
3198
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
