Python 我正在运行一个程序，通过两个套接字发送图片，我没有收到任何错误，但程序卡住了

我用python创建了一个服务器和一个客户机，这样我就可以通过两个套接字发送一个图像，但当我运行客户机时，它会接收数据，但一旦到达文件的末尾，它就会卡住。它不会引发错误，也不会崩溃，因为终端就在那里卡住了

我试过稍微修改一下代码，但没有用。我还是个初学者

client.py

import socket
import cv2 
import numpy as np
import pickle

client_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

client_socket.bind(('127.0.0.1',5000))

host_ip = ('127.0.0.1',400)

client_socket.connect(host_ip)

serialized_img = b""
while True:
    packet = client_socket.recv(1024)
    if not packet :
        break
    serialized_img += packet


image = pickle.loads(serialized_img)
cv2.imshow("a",image)

import socket
import cv2
import numpy as np
import pickle

server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

server_socket.bind(('127.0.0.1',400))

cap = cv2.VideoCapture(0)

ret,img = cap.read()

cv2.imshow('image',img)
cv2.waitKey(0)
cap.release()
cv2.destroyAllWindows()

serialized_img = pickle.dumps(img)
print(serialized_img)
while ret:
   try:
     server_socket.listen()

     client_socket,client_address =  server_socket.accept()

     print(client_address)

     client_socket.sendall(serialized_img)
   except socket.timeout :
        print("time out")


server_socket.close()

server.py

import socket
import cv2 
import numpy as np
import pickle

client_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

client_socket.bind(('127.0.0.1',5000))

host_ip = ('127.0.0.1',400)

client_socket.connect(host_ip)

serialized_img = b""
while True:
    packet = client_socket.recv(1024)
    if not packet :
        break
    serialized_img += packet


image = pickle.loads(serialized_img)
cv2.imshow("a",image)

import socket
import cv2
import numpy as np
import pickle

server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

server_socket.bind(('127.0.0.1',400))

cap = cv2.VideoCapture(0)

ret,img = cap.read()

cv2.imshow('image',img)
cv2.waitKey(0)
cap.release()
cv2.destroyAllWindows()

serialized_img = pickle.dumps(img)
print(serialized_img)
while ret:
   try:
     server_socket.listen()

     client_socket,client_address =  server_socket.accept()

     print(client_address)

     client_socket.sendall(serialized_img)
   except socket.timeout :
        print("time out")


server_socket.close()

---

我希望客户端能够显示图像。

关闭服务器中的

client\u socket

，通知客户端数据已结束

client_socket.sendall(serialized_img)
client_socket.close()

在客户端中，您必须等待密钥以保持窗口打开

cv2.imshow("a", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

---

服务器：

import socket
import cv2
import pickle

server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(('127.0.0.1', 4000))

cap = cv2.VideoCapture(0)
ret, img = cap.read()
cap.release()

cv2.imshow("server", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

serialized_img = pickle.dumps(img)

while ret:
    try:
        server_socket.listen()

        client_socket,client_address = server_socket.accept()
        print(client_address)

        client_socket.sendall(serialized_img)
        client_socket.close()
        print('closed')

    except socket.timeout :
        print("time out")

server_socket.close()

import socket
import cv2
import pickle

server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(('127.0.0.1', 4000))

cap = cv2.VideoCapture(0)

while True:
    try:
        server_socket.listen()

        print('waiting ...')
        client_socket,client_address =  server_socket.accept()
        print(client_address)

        while True:
            try:
                ret, img = cap.read()

                serialized_img = pickle.dumps(img)
                print('serialized_len:', len(serialized_img))

                serialized_len = pickle.dumps(len(serialized_img))
                #print('len(serialized_len):', len(serialized_len)) # always length 8

                client_socket.sendall(serialized_len) # always length 8
                client_socket.sendall(serialized_img)
            except Exception as ex:
                print(ex)
                # exit loop when errro, ie. when client close connection
                break 

        client_socket.close()
        print('closed')

    except socket.timeout:
        print('time out')

cap.release()
server_socket.close()

客户：

import socket
import cv2 
import pickle

client_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client_socket.connect(('127.0.0.1', 4000))

serialized_img = b""

while True:
    packet = client_socket.recv(1024)
    if not packet :
        break
    serialized_img += packet

image = pickle.loads(serialized_img)

cv2.imshow("client", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

import socket
import cv2 
import pickle

client_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client_socket.connect(('127.0.0.1', 4000))

cv2.namedWindow('client')

while True:
    serialized_image = b""

    serialized_len = client_socket.recv(8) # always length 8
    length = pickle.loads(serialized_len) 
    #print('length:', length)

    while length > 0:
        if length < 1024:
            packet = client_socket.recv(length)
        else:
            packet = client_socket.recv(1024)

        if not packet:
            print('error: no data')
            break

        serialized_image += packet
        length -= len(packet)

    #print('received:', len(serialized_image))

    image = pickle.loads(serialized_image)
    cv2.imshow('client', image)

    # it need it to display image (maybe it has to receive events from system)
    # it `waitKey` waits 10ms so it doesn't block loop
    key = cv2.waitKey(10) & 0XFF
    if key == 27:
        break

cv2.destroyAllWindows()

---

若您想发送实时视频，那个么服务器必须在ret时使用摄像头或

运行单独的线程。每个客户机_套接字在
中的单独线程中运行，而True则在
循环中运行。问题是如何通知客户一帧的结束位置和下一帧的开始位置。您无法为此使用
close（）


编辑：此代码从摄像机中传输图像，以便客户端可以实时查看-延迟很小

它先发送图像的大小，然后再发送图像，这样客户端就知道要接收多少字节才能得到完整的图像。序列化的整数总是有8个字节，所以我总是在映像之前收到8个字节

我在客户端中使用
cv2.waitKey（10）
来选中按钮，不仅可以关闭窗口，而且如果没有这个按钮，它不会显示图像。可能Windows必须从系统接收事件才能正常工作（并刷新窗口），就像在其他模块中一样-例如PyGame-并且
waitKey（）
正在检查事件

服务器：

import socket
import cv2
import pickle

server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(('127.0.0.1', 4000))

cap = cv2.VideoCapture(0)
ret, img = cap.read()
cap.release()

cv2.imshow("server", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

serialized_img = pickle.dumps(img)

while ret:
    try:
        server_socket.listen()

        client_socket,client_address = server_socket.accept()
        print(client_address)

        client_socket.sendall(serialized_img)
        client_socket.close()
        print('closed')

    except socket.timeout :
        print("time out")

server_socket.close()

import socket
import cv2
import pickle

server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(('127.0.0.1', 4000))

cap = cv2.VideoCapture(0)

while True:
    try:
        server_socket.listen()

        print('waiting ...')
        client_socket,client_address =  server_socket.accept()
        print(client_address)

        while True:
            try:
                ret, img = cap.read()

                serialized_img = pickle.dumps(img)
                print('serialized_len:', len(serialized_img))

                serialized_len = pickle.dumps(len(serialized_img))
                #print('len(serialized_len):', len(serialized_len)) # always length 8

                client_socket.sendall(serialized_len) # always length 8
                client_socket.sendall(serialized_img)
            except Exception as ex:
                print(ex)
                # exit loop when errro, ie. when client close connection
                break 

        client_socket.close()
        print('closed')

    except socket.timeout:
        print('time out')

cap.release()
server_socket.close()

客户：

import socket
import cv2 
import pickle

client_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client_socket.connect(('127.0.0.1', 4000))

serialized_img = b""

while True:
    packet = client_socket.recv(1024)
    if not packet :
        break
    serialized_img += packet

image = pickle.loads(serialized_img)

cv2.imshow("client", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

import socket
import cv2 
import pickle

client_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client_socket.connect(('127.0.0.1', 4000))

cv2.namedWindow('client')

while True:
    serialized_image = b""

    serialized_len = client_socket.recv(8) # always length 8
    length = pickle.loads(serialized_len) 
    #print('length:', length)

    while length > 0:
        if length < 1024:
            packet = client_socket.recv(length)
        else:
            packet = client_socket.recv(1024)

        if not packet:
            print('error: no data')
            break

        serialized_image += packet
        length -= len(packet)

    #print('received:', len(serialized_image))

    image = pickle.loads(serialized_image)
    cv2.imshow('client', image)

    # it need it to display image (maybe it has to receive events from system)
    # it `waitKey` waits 10ms so it doesn't block loop
    key = cv2.waitKey(10) & 0XFF
    if key == 27:
        break

cv2.destroyAllWindows()

导入套接字
进口cv2
进口泡菜
client\u socket=socket.socket（socket.AF\u INET，socket.SOCK\u流）
客户端_套接字连接（'127.0.0.1'，4000））
cv2.namedWindow（“客户”）
尽管如此：
序列化的_映像=b“”
序列化的_len=client_socket.recv（8）#始终长度为8
长度=pickle.load（序列化）
#打印（'长度：'，长度）
当长度>0时：
如果长度<1024：
packet=client_socket.recv（长度）
其他：
packet=client_socket.recv（1024）
如果不是数据包：
打印（'错误：无数据'）
打破
序列化的_映像+=数据包
长度-=len（数据包）
#打印（'received:'，len（序列化图像））
image=pickle.load（序列化的_映像）
cv2.imshow（“客户”，图像）
#它需要它来显示图像（可能它必须从系统接收事件）
#它等待10毫秒，这样就不会阻塞循环
key=cv2.waitKey（10）和0XFF
如果键==27：
打破
cv2.destroyAllWindows（）
使用
print（）
在不同时刻显示信息，以查看代码的哪一部分会产生问题。也许它会等待更多的数据。您可以关闭服务器中的
客户端\u套接字
，通知客户端它已结束数据。