Python局域网远程监控电脑屏幕实现

爱写代码的小朋友2025-11-23 18:11

使用Python可以在局域网内实现远程监控电脑屏幕。以下是两种实现方法：

方法一：使用mss和socket实现屏幕共享

服务端（被监控端）

python 复制代码 
import mss
import mss.tools
import socket
import threading
import time
import zlib

class ScreenServer:
    def __init__(self, host='0.0.0.0', port=5000):
        self.host = host
        self.port = port
        self.running = False
        self.server_socket = None
        self.quality = 50  # 图像质量 (0-100)
        
    def start_server(self):
        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}")
        
        self.running = True
        while self.running:
            try:
                client_socket, addr = self.server_socket.accept()
                print(f"新的连接来自: {addr}")
                # 为每个客户端创建新线程
                client_thread = threading.Thread(
                    target=self.handle_client, 
                    args=(client_socket,)
                )
                client_thread.daemon = True
                client_thread.start()
            except Exception as e:
                if self.running:
                    print(f"接受连接时出错: {e}")
    
    def handle_client(self, client_socket):
        try:
            with mss.mss() as sct:
                # 获取所有显示器
                monitors = sct.monitors
                # 使用主显示器
                monitor = monitors[1]  # 索引0是所有显示器的合并区域，索引1是主显示器
                
                while self.running:
                    # 捕获屏幕
                    screenshot = sct.grab(monitor)
                    
                    # 转换为PNG并压缩
                    png_data = mss.tools.to_png(screenshot.rgb, screenshot.size)
                    compressed_data = zlib.compress(png_data, level=zlib.Z_BEST_COMPRESSION)
                    
                    # 发送数据大小和数据
                    size_data = len(compressed_data).to_bytes(4, byteorder='big')
                    client_socket.send(size_data + compressed_data)
                    
                    # 控制帧率
                    time.sleep(0.05)  # 约20FPS
                    
        except Exception as e:
            print(f"处理客户端时出错: {e}")
        finally:
            client_socket.close()
    
    def stop_server(self):
        self.running = False
        if self.server_socket:
            self.server_socket.close()

if __name__ == "__main__":
    server = ScreenServer()
    try:
        server.start_server()
    except KeyboardInterrupt:
        server.stop_server()
        print("服务器已停止")

客户端（监控端）

python 复制代码 
import socket
import cv2
import numpy as np
import zlib
import threading

class ScreenClient:
    def __init__(self, server_ip, server_port=5000):
        self.server_ip = server_ip
        self.server_port = server_port
        self.running = False
        self.client_socket = None
        
    def connect(self):
        try:
            self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.client_socket.connect((self.server_ip, self.server_port))
            self.running = True
            print(f"已连接到服务器 {self.server_ip}:{self.server_port}")
            return True
        except Exception as e:
            print(f"连接失败: {e}")
            return False
    
    def receive_screen(self):
        try:
            while self.running:
                # 接收数据大小
                size_data = self.client_socket.recv(4)
                if not size_data:
                    break
                    
                data_size = int.from_bytes(size_data, byteorder='big')
                
                # 接收压缩的图像数据
                received_data = b""
                while len(received_data) < data_size:
                    chunk = self.client_socket.recv(min(4096, data_size - len(received_data)))
                    if not chunk:
                        break
                    received_data += chunk
                
                if len(received_data) != data_size:
                    print("数据接收不完整")
                    continue
                
                # 解压并解码图像
                decompressed_data = zlib.decompress(received_data)
                nparr = np.frombuffer(decompressed_data, np.uint8)
                frame = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
                
                if frame is not None:
                    cv2.imshow('远程桌面', frame)
                    
                    # 按'q'退出
                    if cv2.waitKey(1) & 0xFF == ord('q'):
                        break
                        
        except Exception as e:
            print(f"接收数据时出错: {e}")
        finally:
            self.close()
    
    def close(self):
        self.running = False
        if self.client_socket:
            self.client_socket.close()
        cv2.destroyAllWindows()

if __name__ == "__main__":
    # 替换为服务端的IP地址
    server_ip = "192.168.1.100"  
    
    client = ScreenClient(server_ip)
    if client.connect():
        client.receive_screen()

方法二：使用PyAutoGUI和Flask实现Web界面监控

服务端（被监控端）

python 复制代码 
from flask import Flask, Response
import pyautogui
import cv2
import numpy as np
import threading
import time

app = Flask(__name__)

class ScreenStreamer:
    def __init__(self):
        self.frame = None
        self.running = True
        
    def capture_screen(self):
        while self.running:
            # 截取屏幕
            screenshot = pyautogui.screenshot()
            # 转换为OpenCV格式
            frame = cv2.cvtColor(np.array(screenshot), cv2.COLOR_RGB2BGR)
            # 编码为JPEG
            _, jpeg = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 70])
            self.frame = jpeg.tobytes()
            time.sleep(0.1)  # 控制帧率
    
    def get_frame(self):
        return self.frame
    
    def stop(self):
        self.running = False

streamer = ScreenStreamer()

def generate_frames():
    while True:
        frame = streamer.get_frame()
        if frame:
            yield (b'--frame\r\n'
                   b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')

@app.route('/')
def index():
    return '''
    <html>
      <head>
        <title>远程桌面监控</title>
      </head>
      <body>
        <h1>远程桌面监控</h1>
        <img src="/video_feed" width="80%">
      </body>
    </html>
    '''

@app.route('/video_feed')
def video_feed():
    return Response(generate_frames(),
                    mimetype='multipart/x-mixed-replace; boundary=frame')

if __name__ == '__main__':
    # 启动屏幕捕获线程
    capture_thread = threading.Thread(target=streamer.capture_screen)
    capture_thread.daemon = True
    capture_thread.start()
    
    # 启动Flask服务器
    app.run(host='0.0.0.0', port=5000, threaded=True)

安装必要的库

bash 复制代码 
pip install mss opencv-python pyautogui flask pillow zlib

使用说明

  1. 方法一：

    • 在被监控电脑上运行服务端代码
    • 在监控电脑上运行客户端代码，并设置正确的服务端IP地址
    • 客户端会显示一个窗口展示远程桌面

  2. 方法二：

    • 在被监控电脑上运行Flask服务端
    • 在浏览器中访问 http://被监控电脑IP:5000 即可查看远程桌面

注意事项

  • 安全性：这些代码仅用于学习和授权的监控用途，请确保你有权限监控目标电脑
  • 性能：屏幕共享可能会占用较多网络带宽，请根据网络情况调整图像质量和帧率
  • 防火墙：确保相关端口（如5000）在防火墙中已开放

优化建议

  1. 可以根据网络状况动态调整图像质量
  2. 可以只传输屏幕变化的部分以减少数据量
  3. 可以添加身份验证机制增强安全性
  4. 对于高分辨率屏幕，可以考虑缩放图像以减少数据量
相关推荐
岚天start1 小时前
Java程序生成Heap Dump堆内存快照文件的多种方法
开发语言·python·pycharm
兆。1 小时前
python全栈-人工智能基础-机器学习
人工智能·python·机器学习
深度学习lover2 小时前
＜项目代码＞yolo遥感航拍船舶识别＜目标检测＞
人工智能·python·yolo·目标检测·计算机视觉·遥感船舶识别
8***B2 小时前
Python机器学习库Scikit-learn使用
python·机器学习·scikit-learn
xinxingrs3 小时前
贪心算法、动态规划以及相关应用（python）
笔记·python·学习·算法·贪心算法·动态规划
不知更鸟3 小时前
无法联系上下文
python·django
U***e634 小时前
Python测试
开发语言·python
金色熊族4 小时前
win11安装matplotlib过程
python·matplotlib
热门推荐
01GitHub 镜像站点02BongoCat - 跨平台键盘猫动画工具03【保姆级教程】免费使用Gemini3的5种方法！免翻墙/国内直连04UV安装并设置国内源05Google Antigravity：无法登录？早期错误、登录修复和用户反馈指南06安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）07Linux下V2Ray安装配置指南08今天 Cloudflare 全球事故，连 GPT 和你的网站都一起“掉线”了09全球最强模型Grok4，国内已可免费使用！（附教程）1046个Nano-banana 精选提示词，持续更新中