羊村懒王

这个屌丝很懒，什么也没留下！

热门标签

基于python的人脸识别门禁系统_python人脸识别门禁系统

作者：羊村懒王 | 2024-04-26 13:02:43

踩

python人脸识别门禁系统

人脸识别门禁系统是一种基于人脸识别技术的安全系统。在Python中，可以使用多种人脸识别库（如OpenCV和dlib）来实现这种门禁系统。以下是一个基于Python的人脸识别门禁系统的需求分析：

1. 用户注册系统：门禁系统需要一个用户注册系统，让用户在系统中注册账户并上传自己的照片。这些照片将用于后续的人脸识别。

2. 人脸检测系统：门禁系统需要一个人脸检测系统，以检测进入门禁区域的人脸。这个检测系统需要使用Python中的人脸识别库，例如OpenCV或dlib。

3. 人脸识别系统：门禁系统需要一个人脸识别系统，以识别进入门禁区域的人员是否在注册用户列表中。这个识别系统需要使用Python中的人脸识别库，例如OpenCV或dlib。

4. 数据库管理系统：门禁系统需要一个数据库管理系统，以存储注册用户列表和门禁记录。这个管理系统可以使用Python中的SQLite或MySQL等关系型数据库。

5. 记录管理系统：门禁系统需要一个记录管理系统，以记录进出门禁区域的人员信息，包括时间戳、人员姓名、进出状态等。这个管理系统可以使用Python中的日志模块或数据库管理系统中的表格来实现。

6. 报警系统：门禁系统需要一个报警系统，以在检测到未注册用户或异常情况时发出警报。这个报警系统可以使用Python中的声音或图像提示，或者将警报信息发送到管理员的手机或电子邮件中。

7. 界面设计系统：门禁系统需要一个友好的界面设计系统，以便管理员或用户能够方便地使用门禁系统。这个设计系统可以使用Python中的Tkinter或PyQt等界面库来实现。

基于上述需求分析，我们可以进行以下详细设计：

1. 用户注册系统：

用户注册系统需要实现以下功能：

    a. 允许用户在系统中注册账户，并上传自己的照片。
    b. 保存用户的注册信息和照片到数据库中。
    c. 支持用户查看和修改自己的注册信息和照片。

实现方法：

    a. 可以使用Python中的图形用户界面库，如Tkinter、PyQt等，设计一个注册界面，让用户输入自己的姓名、性别、年龄、联系方式等信息，并上传自己的照片。
    b. 将用户的注册信息和照片保存到数据库中，可以使用Python中的关系型数据库MySQL或SQLite。
    c. 允许用户通过界面或API访问自己的注册信息和照片，并支持用户修改自己的信息和照片。

2. 人脸检测系统：

人脸检测系统需要实现以下功能：

a. 检测门禁区域进入的人脸。
b. 在检测到人脸后，将人脸图像传递给人脸识别系统进行识别。

实现方法：

a. 可以使用Python中的OpenCV或dlib等人脸识别库来实现人脸检测功能。
b. 将检测到的人脸图像传递给人脸识别系统进行识别。

3. 人脸识别系统：

人脸识别系统需要实现以下功能：

    a. 从数据库中读取已注册用户的信息和照片。
    b. 对进入门禁区域的人脸进行识别，判断是否为已注册用户。
    c. 如果是已注册用户，记录进出门禁区域的时间和状态，保存到数据库中。

实现方法：

    a. 从数据库中读取已注册用户的信息和照片。
    b. 使用Python中的人脸识别库，如OpenCV或dlib，对进入门禁区域的人脸进行识别，并判断是否为已注册用户。
    c. 如果是已注册用户，记录进出门禁区域的时间和状态，并保存到数据库中。

4. 数据库管理系统：

数据库管理系统需要实现以下功能：

a. 管理已注册用户的信息和照片。
b. 管理门禁记录，包括人员姓名、进出时间和状态等。

实现方法：

a. 可以使用Python中的关系型数据库MySQL或SQLite来管理已注册用户的信息和照片。
b. 在门禁记录中，使用数据库管理系统中的表格来存储人员姓名、进出时间和状态等信息。

5. 记录管理系统：

记录管理系统需要实现以下功能：

a. 记录进出门禁区域的人员信息，包括时间戳、人员姓名、进出状态等。
b. 支持管理员查看和导出门禁记录。

实现方法：

a. 在人脸识别系统中记录进出门禁区域的人员信息，包括时间戳、人员姓名、进出状态等，并保存到数据库中。
b. 支持管理员通过界面或API访问门禁记录，并支持管理员导出门禁记录。

6. 报警系统：

报警系统需要实现以下功能：

a. 在检测到未注册用户或异常情况时发出警报。
b. 将警报信息发送到管理员的手机或电子邮件中。

实现方法：

a. 在人脸检测和识别系统中检测未注册用户或异常情况，并在检测到时发出警报。
b. 将警报信息通过Python中的手机短信或电子邮件模块发送给管理员。

7. 界面设计系统：

界面设计系统需要实现以下功能：

    a. 提供一个友好的用户界面，方便管理员或用户使用门禁系统。
    b. 支持用户注册、查看、修改自己的信息和照片。
    c. 支持管理员查看门禁记录和导出记录。

实现方法：

    a. 可以使用Python中的图形用户界面库，如Tkinter、PyQt等，设计一个友好的用户界面。
    b. 提供用户注册、查看、修改自己的信息和照片的功能。
    c. 提供管理员查看门禁记录和导出记录的功能，并支持管理员对记录进行筛选和搜索。

以下是一个基于Python的用户注册系统的示例代码，使用了Tkinter作为图形用户界面库，SQLite作为关系型数据库。这个系统实现了用户注册、查看、修改和删除自己的信息和照片等功能。


import tkinter as tk
from tkinter import filedialog
import sqlite3
 
# 创建用户注册系统的主界面
class UserRegistrationSystem(tk.Frame):
    def __init__(self, master=None):
        super().__init__(master)
        self.master = master
        self.master.title("用户注册系统")
        self.pack()
 
        # 创建用户信息输入框
        self.create_input()
 
        # 创建用户照片上传按钮
        self.create_upload_button()
 
        # 创建注册和删除按钮
        self.create_register_button()
        self.create_delete_button()
 
        # 创建用户信息显示框
        self.create_text()
 
        # 连接数据库
        self.conn = sqlite3.connect('user.db')
        self.cursor = self.conn.cursor()
        self.create_table()
 
    # 创建用户信息输入框
    def create_input(self):
        self.name_label = tk.Label(self, text="姓名：")
        self.name_label.grid(row=0, column=0)
        self.name_entry = tk.Entry(self)
        self.name_entry.grid(row=0, column=1)
 
        self.gender_label = tk.Label(self, text="性别：")
        self.gender_label.grid(row=1, column=0)
        self.gender_entry = tk.Entry(self)
        self.gender_entry.grid(row=1, column=1)
 
        self.age_label = tk.Label(self, text="年龄：")
        self.age_label.grid(row=2, column=0)
        self.age_entry = tk.Entry(self)
        self.age_entry.grid(row=2, column=1)
 
        self.phone_label = tk.Label(self, text="联系方式：")
        self.phone_label.grid(row=3, column=0)
        self.phone_entry = tk.Entry(self)
        self.phone_entry.grid(row=3, column=1)
 
    # 创建用户照片上传按钮
    def create_upload_button(self):
        self.upload_button = tk.Button(self, text="上传照片", command=self.upload_photo)
        self.upload_button.grid(row=4, column=0)
 
    # 创建注册按钮
    def create_register_button(self):
        self.register_button = tk.Button(self, text="注册", command=self.register_user)
        self.register_button.grid(row=4, column=1)
 
    # 创建删除按钮
    def create_delete_button(self):
        self.delete_button = tk.Button(self, text="删除", command=self.delete_user)
        self.delete_button.grid(row=4, column=2)
 
    # 创建用户信息显示框
    def create_text(self):
        self.text = tk.Text(self, width=30, height=10)
        self.text.grid(row=5, columnspan=3)
 
    # 上传用户照片
    def upload_photo(self):
        # 打开文件对话框
        filename = filedialog.askopenfilename(initialdir="/", title="选择照片",
                                              filetypes=(("jpeg files", "*.jpg"), ("all files", "*.*")))
        self.photo_path = filename
 
    # 注册用户
    def register_user(self):
        name = self.name_entry.get()
        gender = self.gender_entry.get()
        age = self.age_entry.get()
        phone = self.phone_entry.get()
 
        # 将用户信息存入数据库
        if name and gender and age and phone and self.photo_path:
            with open(self.photo_path, 'rb') as f:
                photo = f.read()
            self.cursor.execute("INSERT INTO user (name, gender, age, phone, photo) VALUES (?, ?, ?, ?, ?)",
                                (name, gender, age, phone, photo))
            self.conn.commit()
            self.show_message("注册成功！")
        else:
            self.show_message("请填写所有信息并上传照片！")
 
    # 删除用户
    def delete_user(self):
        name = self.name_entry.get()
 
        # 从数据库中删除用户信息
        if name:
            self.cursor.execute("DELETE FROM user WHERE name=?", (name,))
            self.conn.commit()
            self.show_message("删除成功！")
        else:
            self.show_message("请输入姓名！")
 
    # 显示用户信息
    def show_message(self, message):
        self.text.delete('1.0', tk.END)
        self.text.insert('1.0', message)
 
    # 创建用户信息表格
    def create_table(self):
        self.cursor.execute('''CREATE TABLE IF NOT EXISTS user
                       (id INTEGER PRIMARY KEY AUTOINCREMENT,
                        name TEXT NOT NULL,
                        gender TEXT NOT NULL,
                        age INTEGER NOT NULL,
                        phone TEXT NOT NULL                        , photo BLOB NOT NULL)''')
 
    # 查询用户信息
    def query_user(self, name):
        self.cursor.execute("SELECT * FROM user WHERE name=?", (name,))
        result = self.cursor.fetchone()
        return result
 
    # 更新用户信息
    def update_user(self, name, gender, age, phone, photo_path):
        with open(photo_path, 'rb') as f:
            photo = f.read()
        self.cursor.execute("UPDATE user SET gender=?, age=?, phone=?, photo=? WHERE name=?",
                            (gender, age, phone, photo, name))
        self.conn.commit()
        self.show_message("更新成功！")
 
    # 显示用户信息
    def show_user(self, name):
        result = self.query_user(name)
        if result:
            self.show_message("姓名：{}\n性别：{}\n年龄：{}\n联系方式：{}".format(result[1], result[2], result[3], result[4]))
            with open('photo.jpg', 'wb') as f:
                f.write(result[5])
            img = tk.PhotoImage(file='photo.jpg')
            label = tk.Label(self, image=img)
            label.grid(row=6, columnspan=3)
            label.image = img
        else:
            self.show_message("用户不存在！")
 
# 运行用户注册系统
if __name__ == "__main__":
    root = tk.Tk()
    app = UserRegistrationSystem(master=root)
    app.mainloop()

一个基本的用户注册系统，允许用户输入姓名、性别、年龄、联系方式等信息，并上传自己的照片。用户注册信息和照片会被保存到SQLite数据库中，用户可以通过界面或API访问自己的注册信息和照片，并支持用户修改自己的信息和照片。这个示例代码还可以进一步扩展，增加更多的功能和优化用户体验。

以下是使用OpenCV实现人脸检测系统的代码示例：


import cv2
 
# 加载人脸检测器
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
 
# 加载人脸识别器
recognizer = cv2.face.LBPHFaceRecognizer_create()
 
# 加载训练好的人脸识别模型
recognizer.read('trained_model.yml')
 
# 打开摄像头
cap = cv2.VideoCapture(0)
 
while True:
    # 读取摄像头画面
    ret, frame = cap.read()
 
    # 将画面转换为灰度图像
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
 
    # 检测人脸
    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
 
    # 处理每一个检测到的人脸
    for (x, y, w, h) in faces:
        # 在检测到的人脸周围画一个矩形框
        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
 
        # 提取人脸图像
        face_roi_gray = gray[y:y+h, x:x+w]
        face_roi_color = frame[y:y+h, x:x+w]
 
        # 将人脸图像传递给人脸识别器进行识别
        label, confidence = recognizer.predict(face_roi_gray)
 
        # 将识别结果显示在画面上
        if confidence < 100:
            text = 'Person ' + str(label)
        else:
            text = 'Unknown'
        cv2.putText(frame, text, (x, y - 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
 
    # 显示处理后的画面
    cv2.imshow('Face Detection', frame)
 
    # 按下q键退出程序
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
 
# 释放摄像头资源
cap.release()
 
# 关闭所有窗口
cv2.destroyAllWindows()

在上述代码中，我们首先加载了人脸检测器和人脸识别器，然后打开摄像头开始读取画面。对于每一帧画面，我们先将其转换为灰度图像，然后使用人脸检测器检测其中的人脸。对于每一个检测到的人脸，我们在其周围画一个矩形框，并提取出人脸图像。然后将人脸图像传递给人脸识别器进行识别，并将识别结果显示在画面上。最后，我们通过按下q键来退出程序。

以下是一个基于OpenCV库的人脸识别系统，实现了从数据库中读取已注册用户的信息和照片，对进入门禁区域的人脸进行识别，并判断是否为已注册用户，如果是已注册用户则记录进出门禁区域的时间和状态，并保存到数据库中。

一个基本的示例代码，实际应用中还需要根据具体需求进行修改和完善。


import cv2
import numpy as np
import sqlite3
import datetime
 
 
# 连接数据库
conn = sqlite3.connect('users.db')
c = conn.cursor()
 
# 加载人脸识别器
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
recognizer = cv2.face.LBPHFaceRecognizer_create()
 
# 加载已注册用户的信息和照片
c.execute('SELECT * FROM users')
users = c.fetchall()
 
labels = []
faces = []
 
for user in users:
    labels.append(user[0])
    img = cv2.imread(user[1])
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    faces.append(gray)
 
# 训练人脸识别器
recognizer.train(faces, np.array(labels))
 
# 打开摄像头
cap = cv2.VideoCapture(0)
 
while True:
    # 读取摄像头画面
    ret, frame = cap.read()
 
    # 将画面转换为灰度图像
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
 
    # 检测人脸
    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
 
    # 处理每一个检测到的人脸
    for (x, y, w, h) in faces:
        # 在检测到的人脸周围画一个矩形框
        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
 
        # 提取人脸图像
        face_roi_gray = gray[y:y+h, x:x+w]
        face_roi_color = frame[y:y+h, x:x+w]
 
        # 将人脸图像传递给人脸识别器进行识别
        label, confidence = recognizer.predict(face_roi_gray)
 
        # 将识别结果显示在画面上
        if confidence < 100:
            # 如果是已注册用户，记录进出门禁区域的时间和状态，并保存到数据库中
            user_data = c.execute("SELECT * FROM users WHERE id=?", (label,))
            user = user_data.fetchone()
            status = 'in'  # 判断进出门禁区域的状态，这里假设所有用户初始状态都是进入门禁区域
            now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')  # 获取当前时间
            c.execute("INSERT INTO records (user_id, status, time) VALUES (?, ?, ?)", (user[0], status, now))
            conn.commit()
 
            text = 'Person ' + str(user[0])
        else:
            text = 'Unknown'
        cv2.putText(frame, text, (x, y - 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
 
    # 显示处理后的画面
    cv2.imshow('Face Recognition', frame)
 
    # 按下q键退出程序
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
 
# 释放摄像头资源
cap.release()
 
# 关闭所有窗口
cv2.destroyAllWindows()
 
# 关闭数据库连接
conn.close()

简单的记录管理系统的示例代码，使用Python编写，实现了记录进出门禁区域的人员信息，包括时间戳、人员姓名、进出状态等，并保存到数据库中；支持管理员通过界面或API访问门禁记录，并支持管理员导出门禁记录。

实际应用中还需要根据具体需求进行修改和完善。


import sqlite3
from flask import Flask, jsonify, request, send_file
import pandas as pd
 
# 连接数据库
conn = sqlite3.connect('records.db')
c = conn.cursor()
 
# 创建表格
c.execute('''CREATE TABLE IF NOT EXISTS records
             (id INTEGER PRIMARY KEY AUTOINCREMENT,
             user_id INTEGER,
             status TEXT,
             time TEXT)''')
 
# 创建Flask应用
app = Flask(__name__)
 
# 添加门禁记录
@app.route('/add_record', methods=['POST'])
def add_record():
    user_id = request.form['user_id']
    status = request.form['status']
    time = request.form['time']
 
    c.execute("INSERT INTO records (user_id, status, time) VALUES (?, ?, ?)", (user_id, status, time))
    conn.commit()
 
    return jsonify({'result': 'success'})
 
# 获取门禁记录
@app.route('/get_records', methods=['GET'])
def get_records():
    query = "SELECT records.id, users.name, records.status, records.time FROM records LEFT JOIN users ON records.user_id=users.id"
    records = c.execute(query).fetchall()
 
    # 将记录转换为JSON格式
    result = []
    for record in records:
        result.append({
            'id': record[0],
            'name': record[1],
            'status': record[2],
            'time': record[3]
        })
 
    return jsonify(result)
 
# 导出门禁记录
@app.route('/export_records', methods=['GET'])
def export_records():
    query = "SELECT records.id, users.name, records.status, records.time FROM records LEFT JOIN users ON records.user_id=users.id"
    records = c.execute(query).fetchall()
 
    # 将记录转换为Pandas DataFrame
    df = pd.DataFrame(records, columns=['id', 'name', 'status', 'time'])
 
    # 将DataFrame导出为CSV文件
    csv_file = 'records.csv'
    df.to_csv(csv_file, index=False)
 
    # 返回CSV文件
    return send_file(csv_file, as_attachment=True)
 
if __name__ == '__main__':
    app.run(debug=True)
 
# 关闭数据库连接
conn.close()

在这个代码中，我们使用了Flask框架来实现一个简单的REST API。我们定义了三个路由：

1. `/add_record`：用于添加门禁记录。通过HTTP POST请求，向该路由传递用户ID、进出状态和时间戳，然后将这些信息插入到数据库中。

2. `/get_records`：用于获取门禁记录。通过HTTP GET请求，访问该路由，然后从数据库中获取所有门禁记录，并将其转换为JSON格式返回给客户端。

3. `/export_records`：用于导出门禁记录。通过HTTP GET请求，访问该路由，然后从数据库中获取所有门禁记录，并将其转换为CSV格式，并将CSV文件作为附件返回给客户端。

在实际应用中，我们需要进行更多的安全性和错误处理，这里只是为了演示基本的功能。

以下是一个基于人脸识别的报警系统的示例代码，使用Python编写，实现了在检测到未注册用户或异常情况时发出警报，并将警报信息发送到管理员的手机或电子邮件中。

请注意，这只是一个基本的示例代码，实际应用中还需要根据具体需求进行修改和完善。```python


import cv2
import numpy as np
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.image import MIMEImage
from twilio.rest import Client
 
# 加载人脸识别器
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
recognizer = cv2.face.LBPHFaceRecognizer_create()
 
# 加载已注册用户的信息和照片
labels = []
faces = []
 
with open('users.txt', 'r') as f:
    for line in f:
        parts = line.strip().split(',')
        labels.append(int(parts[0]))
        img = cv2.imread(parts[1])
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        faces.append(gray)
 
# 训练人脸识别器
recognizer.train(faces, np.array(labels))
 
# Twilio账户信息（用于发送短信）
account_sid = 'your_account_sid'
auth_token = 'your_auth_token'
client = Client(account_sid, auth_token)
 
# 邮件账户信息（用于发送邮件）
email_address = 'your_email_address'
email_password = 'your_email_password'
smtp_server = 'your_smtp_server'
 
# 发送短信
def send_sms(to_number, message):
    client.messages.create(
        body=message,
        from_='+15017122661',
        to=to_number
    )
 
# 发送邮件
def send_email(to_address, subject, message, image_file):
    msg = MIMEMultipart()
    msg['From'] = email_address
    msg['To'] = to_address
    msg['Subject'] = subject
 
    text = MIMEText(message)
    msg.attach(text)
 
    with open(image_file, 'rb') as f:
        img_data = f.read()
    image = MIMEImage(img_data, name='image.jpg')
    msg.attach(image)
 
    with smtplib.SMTP(smtp_server, 587) as smtp:
        smtp.starttls()
        smtp.login(email_address, email_password)
        smtp.send_message(msg)
 
# 打开摄像头
cap = cv2.VideoCapture(0)
 
while True:
    # 读取摄像头画面
    ret, frame = cap.read()
 
    # 将画面转换为灰度图像
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
 
    # 检测人脸
    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
 
    # 处理每一个检测到的人脸
    for (x, y, w, h) in faces:
        # 在检测到的人脸周围画一个矩形框
        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
 
        # 提取人脸图像
        face_roi_gray = gray[y:y+h, x:x+w]
        face_roi_color = frame[y:y+h, x:x+w]
 
        # 将人脸图像传递给人脸识别器进行识别
        label, confidence = recognizer.predict(face_roi_gray)
 
        # 如果识别的置信度低于阈值，则认为是未注册用户，发出警报
        if confidence > 70:
            message = 'Unknown person detected!'
            send_sms('+1234567890', message)
            send_email('admin@example.com', 'Alert', message, 'image.jpg')
            cv2.putText(frame, 'Unknown', (x, y - 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
 
    # 显示处理后的画面
    cv2.imshow('Face Recognition', frame)
 
    # 按下q键退出程序
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
 
# 释放摄像头资源
cap.release()
 
# 关闭所有窗口
cv2.destroyAllWindows()

以下是一个使用Tkinter库实现的简单界面设计系统的示例代码，使用Python编写，实现了提供一个友好的用户界面，方便管理员或用户使用门禁系统；支持用户注册、查看、修改自己的信息和照片；支持管理员查看门禁记录和导出记录，并支持管理员对记录进行筛选和搜索。

请注意，这只是一个基本的示例代码，实际应用中还需要根据具体需求进行修改和完善。```python


import tkinter as tk
from tkinter import ttk
import sqlite3
from tkinter.filedialog import askopenfilename
import pandas as pd
 
# 连接数据库
conn = sqlite3.connect('records.db')
c = conn.cursor()
 
# 创建表格
c.execute('''CREATE TABLE IF NOT EXISTS users
             (id INTEGER PRIMARY KEY AUTOINCREMENT,
             name TEXT,
             email TEXT,
             phone TEXT,
             image TEXT)''')
 
# 创建表格
c.execute('''CREATE TABLE IF NOT EXISTS records
             (id INTEGER PRIMARY KEY AUTOINCREMENT,
             user_id INTEGER,
             status TEXT,
             time TEXT)''')
 
# 创建主窗口
root = tk.Tk()
root.title("Door Access System")
 
# 创建Notebook
notebook = ttk.Notebook(root)
notebook.pack()
 
# 创建用户注册页面
register_frame = ttk.Frame(notebook)
notebook.add(register_frame, text='Register')
 
# 创建用户信息显示页面
info_frame = ttk.Frame(notebook)
notebook.add(info_frame, text='My Info')
 
# 创建管理员页面
admin_frame = ttk.Frame(notebook)
notebook.add(admin_frame, text='Admin')
 
# 用户注册页面
def register():
    name = name_entry.get()
    email = email_entry.get()
    phone = phone_entry.get()
    image = image_path.get()
 
    # 将用户信息插入到数据库中
    c.execute("INSERT INTO users (name, email, phone, image) VALUES (?, ?, ?, ?)", (name, email, phone, image))
    conn.commit()
 
    # 清空表单
    name_entry.delete(0, tk.END)
    email_entry.delete(0, tk.END)
    phone_entry.delete(0, tk.END)
    image_path.set('')
 
    # 显示成功消息
    success_label.configure(text='Registration successful!')
 
# 创建用户注册表单
name_label = ttk.Label(register_frame, text='Name:')
name_label.grid(column=0, row=0, padx=10, pady=10)
 
name_entry = ttk.Entry(register_frame, width=30)
name_entry.grid(column=1, row=0, padx=10, pady=10)
 
email_label = ttk.Label(register_frame, text='Email:')
email_label.grid(column=0, row=1, padx=10, pady=10)
 
email_entry = ttk.Entry(register_frame, width=30)
email_entry.grid(column=1, row=1, padx=10, pady=10)
 
phone_label = ttk.Label(register_frame, text='Phone:')
phone_label.grid(column=0, row=2, padx=10, pady=10)
 
phone_entry = ttk.Entry(register_frame, width=30)
phone_entry.grid(column=1, row=2, padx=10, pady=10)
 
image_label = ttk.Label(register_frame, text='Image:')
image_label.grid(column=0, row=3, padx=10, pady=10)
 
image_path = tk.StringVar()
 
def select_image():
    filename = askopenfilename()
    image_path.set(filename)
 
select_button = ttk.Button(register_frame, text='Select', command=select_image)
select_button.grid(column=1, row=3, padx=10, pady=10)
 
register_button = ttk.Button(register_frame, text='Register', command=register)
register_button.grid(column=1, row=4, padx=10, pady=10)
 
success_label = ttk.Label(register_frame, foreground='green')
success_label.grid(column=1, row=5, padx=10, pady=10)
 
# 用户信息显示页面
def show_info():
    user_id = info_id_entry.get()
    query = "SELECT * FROM users WHERE id=?"
    user = c.execute(query, (user_id,)).fetchone()
 
    if user is not None:
        name_entry.configure(state='normal')
        email_entry.configure(state='normal')
        phone_entry.configure(state='normal')
        image_button.configure(state='normal')
 
        name_entry.delete(0, tk.END)
        email_entry.delete(0, tk.END)
        phone_entry.delete(0, tk.END)
 
        name_entry.insert(0, user[1])
        email_entry.insert(0, user[2])
        phone_entry.insert(0, user[3])
 
        image_path.set(user[4])
        image_button.configure(text='View Image', command=lambda: view_image(user[4]))
 
    else:
        name_entry.configure(state='disabled')
        email_entry.configure(state='disabled')
        phone_entry.configure(state='disabled')
        image_button.configure(state='disabled')
        image_path.set('')
        info_image.configure(image='')
 
    name_entry.grid(column=1, row=0, padx=10, pady=10)
    email_entry.grid(column=1, row=1, padx=10, pady=10)
    phone_entry.grid(column=1, row=2, padx=10, pady=10)
    image_button.grid(column=1, row=3, padx=10, pady=10)
    info_image.grid(column=2, row=0, rowspan=4, padx=10, pady=10)
 
def view_image(image_file):
    img = tk.PhotoImage(file=image_file)
    info_image.configure(image=img)
    info_image.image = img
 
info_id_label = ttk.Label(info_frame, text='User ID:')
info_id_label.grid(column=0, row=0, padx=10, pady=10)
 
info_id_entry = ttk.Entry(info_frame, width=30)
info_id_entry.grid(column=1, row=0, padx=10, pady=10)
 
show_info_button = ttk.Button(info_frame, text='Show Info', command=show_info)
show_info_button.grid(column=1, row=1, padx=10, pady=10)
 
name_label = ttk.Label(info_frame, text='Name:')
email_label = ttk.Label(info_frame, text='Email:')
phone_label = ttk.Label(info_frame, text='Phone:')
image_label = ttk.Label(info_frame, text='Image:')
 
name_entry = ttk.Entry(info_frame, width=30, state='disabled')
email_entry = ttk.Entry(info_frame, width=30, state='disabled')
phone_entry = ttk.Entry(info_frame, width=30, state='disabled')
 
image_path = tk.StringVar()
image_button = ttk.Button(info_frame, text='View Image', state='disabled')
info_image = ttk.Label(info_frame)
 
# 管理员页面
def show_records():
    status = status_var.get()
    query = "SELECT records.id, users.name, records.status, records.time FROM records JOIN users ON records.user_id=users.id WHERE 1=1"
 
    if status != 'All':
        query += " AND records.status='" + status + "'"
 
    if from_date_var.get() != '':
        query += " AND records.time>='" + from_date_var.get() + "'"
 
    if to_date_var.get() != '':
        query += " AND records.time<='" + to_date_var.get() + " 23:59:59'"
 
    records = c.execute(query).fetchall()
 
    for i in record_tree.get_children():
        record_tree.delete(i)
 
    for record in records:
        record_tree.insert('', 'end', values=(record[0], record[1], record[2], record[3]))
 
def export_records():
    status = status_var.get()
    query = "SELECT records.id, users.name, records.status, records.time FROM records JOIN users ON records.user_id=users.id WHERE 1=1"
 
    if status != 'All':
        query += " AND records.status='" + status + "'"
 
    if from_date_var.get() != '':
        query += " AND records.time>='" + from_date_var.get() + "'"
 
    if to_date_var.get() != '':
        query += " AND records.time<='" + to_date_var.get() + " 23:59:59'"
 
    records = c.execute(query).fetchall()
    df = pd.DataFrame(records, columns=['ID', 'Name', 'Status', 'Time'])
    df.to_csv('records.csv', index=False)
 
status_var = tk.StringVar(value='All')
 
status_label = ttk.Label(admin_frame, text='Status:')
status_label.grid(column=0, row=0, padx=10, pady=10)
 
status_combobox = ttk.Combobox(admin_frame, textvariable=status_var, values=('All', 'In', 'Out'), state='readonly', width=10)
status_combobox.grid(column=1, row=0, padx=10, pady=10)
 
from_date_label = ttk.Label(admin_frame, text='From:')
from_date_label.grid(column=2, row=0, padx=10, pady=10)
 
from_date_var = tk.StringVar()
from_date_entry = ttk.Entry(admin_frame, textvariable=from_date_var, width=10)
from_date_entry.grid(column=3, row=0, padx=10, pady=10)
 
to_date_label = ttk.Label(admin_frame, text='To:')
to_date_label.grid(column=4, row=0, padx=10, pady=10)
 
to_date_var = tk.StringVar()
to_date_entry = ttk.Entry(admin_frame, textvariable=to_date_var, width=10)
to

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/491104