做个一个监控电脑 控制电脑的软件 py代码 局域网使用。 python代码

pyautogui==0.9.54

Pillow==10.0.0

代码功能说明：

1. 服务端功能：

• 监听指定端口等待客户端连接7

• 接收客户端命令并执行相应操作

• 支持屏幕截图、鼠标控制和键盘控制1922

• 多线程处理多个客户端连接

2. 客户端功能：

• 图形界面显示远程电脑屏幕16

• 发送控制命令到服务端

• 支持鼠标移动、点击和键盘按键操作20

• 实时获取远程电脑屏幕截图

server.py

import socket
import threading
import pyautogui
from PIL import ImageGrab
import io
import struct

class RemoteServer:
    def __init__(self, host='0.0.0.0', port=9999):
        self.host = host
        self.port = port
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.server_socket.bind((self.host, self.port))
        self.server_socket.listen(5)
        print(f"服务器已启动，监听 {self.host}:{self.port}")

    def handle_client(self, client_socket):
        try:
            while True:
                cmd = client_socket.recv(1024).decode().lower()
                if not cmd:
                    break

                if cmd == 'screenshot':
                    # 截屏并发送
                    screenshot = ImageGrab.grab()
                    img_byte_arr = io.BytesIO()
                    screenshot.save(img_byte_arr, format='PNG')
                    img_data = img_byte_arr.getvalue()
                    
                    # 先发送图片大小
                    client_socket.send(struct.pack('!I', len(img_data)))
                    # 再发送图片数据
                    client_socket.sendall(img_data)
                
                elif cmd.startswith('mouse'):
                    # 处理鼠标控制命令
                    _, x, y = cmd.split()
                    pyautogui.moveTo(int(x), int(y))
                
                elif cmd.startswith('click'):
                    pyautogui.click()
                
                elif cmd.startswith('key'):
                    # 处理键盘控制命令
                    key = cmd.split()[1]
                    pyautogui.press(key)
                
        except Exception as e:
            print(f"客户端连接错误: {e}")
        finally:
            client_socket.close()

    def start(self):
        while True:
            client_socket, addr = self.server_socket.accept()
            print(f"客户端 {addr} 已连接")
            client_thread = threading.Thread(
                target=self.handle_client, 
                args=(client_socket,)
            )
            client_thread.start()

if __name__ == '__main__':
    server = RemoteServer()
    server.start()

client.py

import socket
import struct
from PIL import Image
import io
import tkinter as tk
from tkinter import ttk
import threading
import pyautogui

class RemoteClient:
    def __init__(self, host, port=9999):
        self.host = host
        self.port = port
        self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.root = tk.Tk()
        self.setup_gui()

    def setup_gui(self):
        self.root.title("远程监控控制客户端")
        
        # 屏幕显示区域
        self.screen_label = tk.Label(self.root)
        self.screen_label.pack()

        # 控制按钮区域
        control_frame = ttk.Frame(self.root)
        control_frame.pack(fill=tk.X, padx=5, pady=5)
        
        ttk.Button(control_frame, text="获取屏幕", command=self.get_screenshot).pack(side=tk.LEFT)
        ttk.Button(control_frame, text="鼠标左键", command=self.send_click).pack(side=tk.LEFT)
        
        # 键盘控制区域
        key_frame = ttk.Frame(self.root)
        key_frame.pack(fill=tk.X, padx=5, pady=5)
        
        keys = ['Enter', 'Esc', 'Tab', 'Space']
        for key in keys:
            ttk.Button(key_frame, text=key, 
                      command=lambda k=key: self.send_key(k)).pack(side=tk.LEFT)

        # 鼠标移动区域
        self.mouse_x = tk.IntVar(value=0)
        self.mouse_y = tk.IntVar(value=0)
        
        mouse_frame = ttk.Frame(self.root)
        mouse_frame.pack(fill=tk.X, padx=5, pady=5)
        
        ttk.Label(mouse_frame, text="X:").pack(side=tk.LEFT)
        ttk.Entry(mouse_frame, textvariable=self.mouse_x, width=5).pack(side=tk.LEFT)
        ttk.Label(mouse_frame, text="Y:").pack(side=tk.LEFT)
        ttk.Entry(mouse_frame, textvariable=self.mouse_y, width=5).pack(side=tk.LEFT)
        ttk.Button(mouse_frame, text="移动鼠标", 
                  command=self.send_mouse_move).pack(side=tk.LEFT)

    def connect(self):
        try:
            self.client_socket.connect((self.host, self.port))
            print(f"已连接到服务器 {self.host}:{self.port}")
            return True
        except Exception as e:
            print(f"连接服务器失败: {e}")
            return False

    def get_screenshot(self):
        try:
            self.client_socket.send('screenshot'.encode())
            
            # 接收图片大小
            size_data = self.client_socket.recv(4)
            if not size_data:
                return
                
            size = struct.unpack('!I', size_data)[0]
            img_data = b''
            
            # 接收图片数据
            while len(img_data) < size:
                packet = self.client_socket.recv(size - len(img_data))
                if not packet:
                    break
                img_data += packet
                
            # 显示图片
            img = Image.open(io.BytesIO(img_data))
            img.thumbnail((800, 600))
            photo = tk.PhotoImage(data=img.tobytes())
            self.screen_label.config(image=photo)
            self.screen_label.image = photo
            
        except Exception as e:
            print(f"获取屏幕截图失败: {e}")

    def send_mouse_move(self):
        try:
            x = self.mouse_x.get()
            y = self.mouse_y.get()
            self.client_socket.send(f'mouse {x} {y}'.encode())
        except Exception as e:
            print(f"发送鼠标移动命令失败: {e}")

    def send_click(self):
        try:
            self.client_socket.send('click'.encode())
        except Exception as e:
            print(f"发送点击命令失败: {e}")

    def send_key(self, key):
        try:
            self.client_socket.send(f'key {key}'.encode())
        except Exception as e:
            print(f"发送按键命令失败: {e}")

    def start(self):
        if self.connect():
            self.root.mainloop()
        else:
            self.root.destroy()

if __name__ == '__main__':
    import sys
    if len(sys.argv) < 2:
        print("用法: python client.py <服务器IP>")
        sys.exit(1)
        
    client = RemoteClient(sys.argv[1])
    client.start()