Contents

socket编程

15.2. socket编程 ¶

socket是基于C/S架构的，也就是说进行socket网络编程，通常需要编写两个py文件，一个服务端，一个客户端。
导入Python中的socket模块： import socket

15.2.1. Python中的socket通信逻辑如下图所示（图片来自网络）：¶

在Python中，import socket后，用socket.socket()方法来创建套接字，语法格式如下：

sk = socket.socket([family[, type[, proto]]])
参数说明：
    family: 套接字家族，可以使AF_UNIX或者AF_INET。
    type: 套接字类型，根据是面向连接的还是非连接分为SOCK_STREAM或SOCK_DGRAM，也就是TCP和UDP的区别。
    protocol: 一般不填默认为0。
    直接socket.socket()，则全部使用默认值。

具体的参数定义：

socket类型                            描述
socket.AF_UNIX              只能够用于单一的Unix系统进程间通信
socket.AF_INET              IPv4
socket.AF_INET6             IPv6
socket.SOCK_STREAM              流式socket , for TCP
socket.SOCK_DGRAM               数据报式socket , for UDP
socket.SOCK_RAW             原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。
socket.SOCK_SEQPACKET       可靠的连续数据包服务
创建TCP Socket：               s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
创建UDP Socket：               s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

s = socket.socket()方法，我们可以获得一个socket对象s，也就是通常说的获取了一个“套接字”

15.2.2. socket.socket()方法 ¶

方法  描述
服务器端方法
s.bind()    绑定地址（host,port）到套接字，在AF_INET下,以元组（host,port）的形式表示地址。
s.listen(backlog)   开始监听。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了。
s.accept()  被动接受客户端连接,(阻塞式)等待连接的到来，并返回（conn,address）二元元组,其中conn是一个通信对象，可以用来接收和发送数据。address是连接客户端的地址。


客户端方法
s.connect(address)  客户端向服务端发起连接。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误。
s.connect_ex()  connect()函数的扩展版本,出错时返回出错码,而不是抛出异常


公共方法
s.recv(bufsize) 接收数据，数据以bytes类型返回，bufsize指定要接收的最大数据量。
s.send()    发送数据。返回值是要发送的字节数量。
s.sendall() 完整发送数据。将数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
s.recvform()    接收UDP数据，与recv()类似，但返回值是（data,address）。其中data是包含接收的数据，address是发送数据的套接字地址。
s.sendto(data,address)  发送UDP数据，将数据data发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。
s.close()   关闭套接字，必须执行。
s.getpeername() 返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
s.getsockname() 返回套接字自己的地址。通常是一个元组(ipaddr,port)
s.setsockopt(level,optname,value)   设置给定套接字选项的值。
s.getsockopt(level,optname[.buflen])    返回套接字选项的值。
s.settimeout(timeout)   设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()）
s.gettimeout()  返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。
s.fileno()  返回套接字的文件描述符。
s.setblocking(flag) 如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。
s.makefile()    创建一个与该套接字相关连的文件

注意事项：

Python3以后，socket传递的都是bytes类型的数据，字符串需要先转换一下，string.encode()即可；另一端接收到的bytes数据想转换成字符串，只要bytes.decode()一下就可以。`
在正常通信时，accept()和recv()方法都是阻塞的。所谓的阻塞，指的是程序会暂停在那，一直等到有数据过来。

15.2.3. socket编程思路：¶

Python的socket编程，通常可分为TCP和UDP编程两种

TCP是带连接的可靠传输服务，每次通信都要握手，结束传输也要挥手，数据会被检验，是使用最广的通用模式； UDP是不带连接的传输服务，简单粗暴，不加控制和检查的一股脑将数据发送出去的方式，但是传输速度快，通常用于安全和可靠等级不高的业务场景，比如文件下载。

15.2.4. TCP编程 ¶

服务端 ¶

创建套接字，绑定套接字到本地IP与端口：socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.bind()
开始监听连接：s.listen()
进入循环，不断接受客户端的连接请求：s.accept()
接收传来的数据，或者发送数据给对方：s.recv() , s.sendall()
传输完毕后，关闭套接字：s.close()

s = socket()        #建立套接字
s.bind()            #绑定本机地址
s.listen()          #开始监听
c,a = s.accept()    #等待连接
c.recv()            #接收数据
c.send()            #发送数据
s.close()           #关闭套接字

服务端代码示例 S-1¶

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket
HOST = ''
PORT = 10888

s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind((HOST,PORT))
s.listen(1)

conn, addr = s.accept()
print("Client\'s Address:", addr)
while True:
    data = conn.recv(1024)
    if not data:
        break
    print("Receive Data:", data.decode("utf-8"))
    conn.send(data)
conn.close()

代码示例 2 S-2¶

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import socket

ip_port = ('127.0.0.1', 9999)

sk = socket.socket()            # 创建套接字
sk.bind(ip_port)                # 绑定服务地址
sk.listen(5)                    # 监听连接请求
print('启动socket服务，等待客户端连接...')
conn, address = sk.accept()     # 等待连接，此处自动阻塞
while True:     # 一个死循环，直到客户端发送‘exit’的信号，才关闭连接
    client_data = conn.recv(1024).decode()      # 接收信息
    if client_data == "exit":       # 判断是否退出连接
        exit("通信结束")
    print("来自%s的客户端向你发来信息：%s" % (address, client_data))
    conn.sendall('服务器已经收到你的信息'.encode())    # 回馈信息给客户端
conn.close()    # 关闭连接

eg

# -*- coding:utf-8 -*-
import socket               #导入socket模块
host = '127.0.0.1'          #主机IP
port = 8080                     #端口号
web = socket.socket()           #创建 socket 对象
web.bind((host,port))       #绑定端口
web.listen(5)               #设置最多连接数
print ('服务器等待客户端连接...')
#开启死循环
while True:
    conn,addr = web.accept()    #建立客户端连接
    data = conn.recv(1024)      #获取客户端请求数据
    print(data)             #打印接收到的数据
    conn.sendall(b'HTTP/1.1 200 OK\r\n\r\nHello World')     #向客户端发送数据
    conn.close()            #关闭连接

模拟网页访问客户端，可以使用网页访问127.0.0.1:8080

一个简易的聊天系统 ¶

Tcp-Server

import socket  # 导入socket模块

host = socket.gethostname()  # 获取主机地址
port = 12345  # 设置端口号
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 创建TCP/IP套接字
s.bind((host, port))  # 绑定地址（host,port）到套接字
s.listen(1)  # 设置最多连接数量
sock, addr = s.accept()  # 被动接受TCP客户端连接
print('连接已经建立')
info = sock.recv(1024).decode()  # 接收客户端数据
while info != 'byebye':  # 判断是否退出
    if info:
        print('接收到的内容:' + info)
    send_data = input('输入发送内容：')  # 发送消息
    sock.send(send_data.encode())  # 发送TCP数据
    if send_data == 'byebye':  # 如果发送byebye,则退出
        break
    info = sock.recv(1024).decode()  # 接收客户端数据
sock.close()  # 关闭客户端套接字
s.close()  # 关闭服务器套接字

Tcp-Client

import socket  # 导入socket模块

s = socket.socket()  # 创建TCP/IP套接字
host = socket.gethostname()  # 获取主机地址
port = 12345  # 设置端口号
s.connect((host, port))  # 主动初始化TCP服务器连接
print('已连接')
info = ''
while info != 'byebye':  # 判断是否退出
    send_data = input('输入发送内容：')  # 输入内容
    s.send(send_data.encode())  # 发送TCP数据
    if send_data == 'byebye':  # 判断是否退出
        break
    info = s.recv(1024).decode()  # 接收服务器数据
    print('接收到的内容:' + info)
s.close()  # 关闭套接字

客户端 ¶

创建套接字，连接服务器地址：socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.connect()
连接后发送数据和接收数据：s.sendall(), s.recv()
传输完毕后，关闭套接字：s.close()

s = socket()        #建立套接字
s.connect()         #连接服务器
c.recv()            #接收数据
c.send()            #发送数据
s.close()           #关闭套接字

代码示例 C-1—>S-1 ¶

import socket
HOST = "localhost"
PROST =10888

s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect((HOST,PROST))
data = "你好！"
while data:
    s.sendall(data.encode("utf-8"))
    data = s.recv(512)
    print("Receive from server:\n",data.decode("utf-8"))
    data = input("please input a info:\n")
s.close()

客户端代码示例 2 C-2—>S-2 ¶

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import socket

ip_port = ('127.0.0.1', 9999)

s = socket.socket()     # 创建套接字

s.connect(ip_port)      # 连接服务器

while True:     # 通过一个死循环不断接收用户输入，并发送给服务器
    inp = input("请输入要发送的信息： ").strip()
    if not inp:     # 防止输入空信息，导致异常退出
        continue
    s.sendall(inp.encode())

    if inp == "exit":   # 如果输入的是‘exit’，表示断开连接
        print("结束通信！")
        break

    server_reply = s.recv(1024).decode()
    print(server_reply)

s.close()       # 关闭连接

这个过程中，一定要注意，收发是一一对应的，有发就要有收，并且recv()方法默认是阻塞的。

15.2.5. TCP Socket文件上传工具 ¶

Server

#!/usr/bin/env python
# -*- coding:utf8 -*-
# auther; 18793
# Date：2019/5/22 13:16
# filename: 文件上传工具Server.py
import socket

HOST = ''
PORT = 8888

f_name = 'coco2dxcplu_copy.jpg'

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, PORT))
    s.listen(10)
    print("服务器启动.........")

    while True:
        with s.accept()[0] as conn:
            # 创建字节序列对象列表，作为接受数据的缓冲区
            buffer = []
            while True:
                data = conn.recv(1024)
                if data:
                    # 接收的数据添加到缓冲区
                    buffer.append(data)
                else:
                    # 没有接收到数据则退出
                    break
            b = bytes().join(buffer)        #将buffer中的字节连接合并为一字节序列对象，bytes()是创建一个空的字节序列对象
            with open(f_name, "wb") as f:
                f.write(b)

            print("服务器接收完成。")

Client

#!/usr/bin/env python
# -*- coding:utf8 -*-
# auther; 18793
# Date：2019/5/22 13:24
# filename: 文件上传工具Client.py
import socket

Host = '127.0.0.1'
PORT = 8888
f_name = 'coco2dxcplus_copy.jpg'

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect((Host, PORT))
    with open(f_name, 'rb') as f:
        b = f.read()
        s.sendall(b)
        print("客户端上传数据完成........")

15.2.6. UDP Socket文件上传工具 ¶

Server

#!/usr/bin/env python
#-*- coding:utf8 -*-
# auther; 18793
# Date：2019/5/22 13:39
# filename: UDP文件上传下载Server.py

import socket

HOST = '127.0.0.1'
PORT = 8888

f_name = 'test_copy.txt'

with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
    s.bind((HOST, PORT))
    print("服务器启动.........")

    # 创建字节序列对象列表，作为接受数据的缓冲区
    buffer = []
    while True:         #反复接收数据
            data, _ = s.recvfrom(1024)
            if data:
                # 接收的数据添加到缓冲区
                flag = data.decode()
                if flag == "bye":
                    break
                buffer.append(data)
            else:
                #没有接收到数据，进入下次循环继续接收
                continue

            # 将buffer中的字节连接合并为一字节序列对象，bytes()是创建一个空的字节序列对象
            b = bytes().join(buffer)
            with open(f_name, "w") as f:
                f.write(b.decode())

            print("服务器接收完成。")

Client

#!/usr/bin/env python
#-*- coding:utf8 -*-
# auther; 18793
# Date：2019/5/22 13:44
# filename: UDP文件上传下载Client.py


import socket

Host = '127.0.0.1'
PORT = 8888
f_name = 'test.txt'

#服务器地址
server_address = (Host, PORT)

with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
    with open(f_name, 'r') as f:
        while True:
            data = f.read(1024)
            if data:
                #发送数据
                s.sendto(data.encode(), server_address)
            else:
                s.sendto(b'bye', server_address)

                #文件中没有可读取的数据则退出
                break

        print("客户端上传数据完成......")

15.2.7. UDP编程 ¶

服务端 ¶

#!/usr/bin/env python
#-*- coding:utf8 -*-
'''
s = socket()        #建立套接字
s.bind()            #绑定本机地址
s.recvfrom()        #接收数据
s.sendto()          #发送数据
s.close()           #关闭套接字
'''

import socket

HOST = ''
PORT = 10888

s = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
s.bind((HOST,PORT))
data = True
while data:
    data,address = s.recvfrom(1024)
    if data==b'bye':
        break
    print("Received String:",data.decode("utf-8"))
    s.sendto(data,address)
s.close()

客户端 ¶

#!/usr/bin/env python
#-*- coding:utf8 -*-
'''
s = socket()    # 建立套接字
s.recvfrom()    #接收数据
s.sendto()      #发送数据
s.close()       #关闭套接字
'''
import socket

HOST = 'localhost'
PROT = 10888

s = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
data = "你好！"
while data:
    s.sendto(data.encode("utf-8"),(HOST,PROT))
    if data == "bye":
        break
    data,addr = s.recvfrom(512)
    print("Receive from server:\n",data.decode("utf-8"))
    data = input("please input a info:\n")
s.close()

15.2.8. socket模块创建多线程服务器 ¶

代码示例 ¶

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import socket
import threading        # 导入线程模块


def link_handler(link, client):
    """
    该函数为线程需要执行的函数，负责具体的服务器和客户端之间的通信工作
    :param link: 当前线程处理的连接
    :param client: 客户端ip和端口信息，一个二元元组
    :return: None
    """
    print("服务器开始接收来自[%s:%s]的请求...." % (client[0], client[1]))
    while True:     # 利用一个死循环，保持和客户端的通信状态
        client_data = link.recv(1024).decode()
        if client_data == "exit":
            print("结束与[%s:%s]的通信..." % (client[0], client[1]))
            break
        print("来自[%s:%s]的客户端向你发来信息：%s" % (client[0], client[1], client_data))
        link.sendall('服务器已经收到你的信息'.encode())
    link.close()


ip_port = ('127.0.0.1', 9999)
sk = socket.socket()            # 创建套接字
sk.bind(ip_port)                # 绑定服务地址
sk.listen(5)                    # 监听连接请求

print('启动socket服务，等待客户端连接...')

while True:     # 一个死循环，不断的接受客户端发来的连接请求
    conn, address = sk.accept()  # 等待连接，此处自动阻塞
    # 每当有新的连接过来，自动创建一个新的线程，
    # 并将连接对象和访问者的ip信息作为参数传递给线程的执行函数
    t = threading.Thread(target=link_handler, args=(conn, address))
    t.start()

客户端代码保持不变

启动这个多线程服务器，然后多运行几个客户端，可以很明显地看到，服务器能够同时与多个客户端通信，基本达到我们的目的。

15.2.9. 一个TCP的聊天程序 ¶

tcp_server.py

#!/usr/bin/env python
# -*- coding:utf8 -*-
# auther; 18793
# Date：2019/9/6 11:35
# filename: tcp_server.py
import tkinter
import tkinter.font as tkFont
import socket
import threading
import sys
import time


class ServerUI():
    local = "127.0.0.1"
    port = 5505
    global serverSock
    flag = False

    def __init__(self):
        '''
        初始类相关属性的构造函数
        '''
        self.root = tkinter.Tk()
        self.root.title('Python在线聊天-服务器V1.0')
        # 窗口面板，用4个frame面板布局
        self.frame = [tkinter.Frame(), tkinter.Frame(), tkinter.Frame(), tkinter.Frame()]
        # 显示消息Text右边的滚动条
        self.chatTextScrollBar = tkinter.Scrollbar(self.frame[0])
        self.chatTextScrollBar.pack(side=tkinter.RIGHT, fill=tkinter.Y)

        # 显示消息Text，并绑定上面的滚动条
        ft = tkFont.Font(family='Fixdsys', size=11)
        self.chatText = tkinter.Listbox(self.frame[0], width=70, height=18, font=ft)
        self.chatText['yscrollcommand'] = self.chatTextScrollBar.set
        self.chatText.pack(expand=1, fill=tkinter.BOTH)
        self.chatTextScrollBar['command'] = self.chatText.yview()
        self.frame[0].pack(expand=1, fill=tkinter.BOTH)

        # 输入消息Text的滚动条
        self.inputTextScrollBar = tkinter.Scrollbar(self.frame[2])
        self.inputTextScrollBar.pack(side=tkinter.RIGHT, fill=tkinter.Y)

        # 输入消息Text，并与滚动条绑定
        ft = tkFont.Font(family='Fixdsys', size=11)
        self.inputText = tkinter.Text(self.frame[2], width=70, height=8, font=ft)
        self.inputText['yscrollcommand'] = self.inputTextScrollBar.set
        self.inputText.pack(expand=1, fill=tkinter.BOTH)
        self.inputTextScrollBar['command'] = self.chatText.yview()
        self.frame[2].pack(expand=1, fill=tkinter.BOTH)

        # “发送”按钮
        self.sendButton = tkinter.Button(self.frame[3], text="发送", width=10, command=self.sendMessage)
        self.sendButton.pack(expand=1, side=tkinter.Button and tkinter.RIGHT, padx=25, pady=5)

        # “关闭”按钮
        self.closeButton = tkinter.Button(self.frame[3], text="关闭", width=10, command=self.close)
        self.closeButton.pack(expand=1, side=tkinter.RIGHT, padx=25, pady=5)
        self.frame[3].pack(expand=1, fill=tkinter.BOTH)

    def receiveMessage(self):
        """
        接收消息
        """
        # 建立Socket连接
        self.serverSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.serverSock.bind((self.local, self.port))
        self.serverSock.listen(15)
        self.buffer = 1024
        self.chatText.insert(tkinter.END, "服务器已经就绪............")

        # 循环接受客户端的连接请求
        while True:
            self.connection, self.address = self.serverSock.accept()
            self.flag = True
            while True:
                # 接收客户端发送的消息
                self.cientMsg = self.connection.recv(self.buffer).decode('utf-8')
                if not self.cientMsg:
                    continue
                elif self.cientMsg == 'Y':
                    self.chatText.insert(tkinter.END, '服务器已经与客户端建立连接.......')
                    self.connection.send(b'Y')
                elif self.cientMsg == 'N':
                    self.chatText.insert(tkinter.END, '服务器与客户端建立连接失败...........')
                    self.connection.send(b'N')
                else:
                    theTime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
                    self.chatText.insert(tkinter.END, '客户端' + theTime + '说：\n')
                    self.chatText.insert(tkinter.END, ' ' + self.cientMsg)

    def sendMessage(self):
        '''
        发送消息
        :return:
        '''

        # 得到用户在Text中输入的消息
        message = self.inputText.get('1.0', tkinter.END)
        # 格式化当前的时间
        theTime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
        self.chatText.insert(tkinter.END, '服务器' + theTime + "说：\n")
        self.chatText.insert(tkinter.END, ' ' + message + '\n')
        if self.flag == True:
            # 将消息发送到客户端
            self.connection.send(message.encode())
            self.inputText.delete(0.0, message.__len__() - 1.0)
        else:
            # Socket连接没有建立，提示用户
            self.chatText.insert(tkinter.END, '您还未与客户端建立连接，客户端无法收到您的消息\n')
            # 清空用户在Text中输入的消息
            self.inputText.delete(0.0, message.__len__() - 1.0)

    def close(self):
        '''
        关闭消息窗口并退出
        :return:
        '''
        sys.exit()

    def startNewThread(self):
        '''
        启动一个新线程来接收客户端的消息
        :return:
        '''
        thread = threading.Thread(target=self.receiveMessage, args=())
        thread.setDaemon(True)
        thread.start()


def main():
    server = ServerUI()
    server.startNewThread()
    server.root.mainloop()


if __name__ == '__main__':
    main()

tcp_client.py

#!/usr/bin/env python
# -*- coding:utf8 -*-
# auther; 18793
# Date：2019/9/6 11:35
# filename: tcp_server.py
import tkinter
import tkinter.font as tkFont
import socket
import threading
import sys
import time


class ServerUI():
    local = "127.0.0.1"
    port = 5505
    global serverSock
    flag = False

    def __init__(self):
        '''
        初始类相关属性的构造函数
        '''
        self.root = tkinter.Tk()
        self.root.title('Python在线聊天-服务器V1.0')
        # 窗口面板，用4个frame面板布局
        self.frame = [tkinter.Frame(), tkinter.Frame(), tkinter.Frame(), tkinter.Frame()]
        # 显示消息Text右边的滚动条
        self.chatTextScrollBar = tkinter.Scrollbar(self.frame[0])
        self.chatTextScrollBar.pack(side=tkinter.RIGHT, fill=tkinter.Y)

        # 显示消息Text，并绑定上面的滚动条
        ft = tkFont.Font(family='Fixdsys', size=11)
        self.chatText = tkinter.Listbox(self.frame[0], width=70, height=18, font=ft)
        self.chatText['yscrollcommand'] = self.chatTextScrollBar.set
        self.chatText.pack(expand=1, fill=tkinter.BOTH)
        self.chatTextScrollBar['command'] = self.chatText.yview()
        self.frame[0].pack(expand=1, fill=tkinter.BOTH)

        # 输入消息Text的滚动条
        self.inputTextScrollBar = tkinter.Scrollbar(self.frame[2])
        self.inputTextScrollBar.pack(side=tkinter.RIGHT, fill=tkinter.Y)

        # 输入消息Text，并与滚动条绑定
        ft = tkFont.Font(family='Fixdsys', size=11)
        self.inputText = tkinter.Text(self.frame[2], width=70, height=8, font=ft)
        self.inputText['yscrollcommand'] = self.inputTextScrollBar.set
        self.inputText.pack(expand=1, fill=tkinter.BOTH)
        self.inputTextScrollBar['command'] = self.chatText.yview()
        self.frame[2].pack(expand=1, fill=tkinter.BOTH)

        # “发送”按钮
        self.sendButton = tkinter.Button(self.frame[3], text="发送", width=10, command=self.sendMessage)
        self.sendButton.pack(expand=1, side=tkinter.Button and tkinter.RIGHT, padx=25, pady=5)

        # “关闭”按钮
        self.closeButton = tkinter.Button(self.frame[3], text="关闭", width=10, command=self.close)
        self.closeButton.pack(expand=1, side=tkinter.RIGHT, padx=25, pady=5)
        self.frame[3].pack(expand=1, fill=tkinter.BOTH)

    def receiveMessage(self):
        """
        接收消息
        """
        # 建立Socket连接
        self.serverSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.serverSock.bind((self.local, self.port))
        self.serverSock.listen(15)
        self.buffer = 1024
        self.chatText.insert(tkinter.END, "服务器已经就绪............")

        # 循环接受客户端的连接请求
        while True:
            self.connection, self.address = self.serverSock.accept()
            self.flag = True
            while True:
                # 接收客户端发送的消息
                self.cientMsg = self.connection.recv(self.buffer).decode('utf-8')
                if not self.cientMsg:
                    continue
                elif self.cientMsg == 'Y':
                    self.chatText.insert(tkinter.END, '服务器已经与客户端建立连接.......')
                    self.connection.send(b'Y')
                elif self.cientMsg == 'N':
                    self.chatText.insert(tkinter.END, '服务器与客户端建立连接失败...........')
                    self.connection.send(b'N')
                else:
                    theTime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
                    self.chatText.insert(tkinter.END, '客户端' + theTime + '说：\n')
                    self.chatText.insert(tkinter.END, ' ' + self.cientMsg)

    def sendMessage(self):
        '''
        发送消息
        :return:
        '''

        # 得到用户在Text中输入的消息
        message = self.inputText.get('1.0', tkinter.END)
        # 格式化当前的时间
        theTime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
        self.chatText.insert(tkinter.END, '服务器' + theTime + "说：\n")
        self.chatText.insert(tkinter.END, ' ' + message + '\n')
        if self.flag == True:
            # 将消息发送到客户端
            self.connection.send(message.encode())
            self.inputText.delete(0.0, message.__len__() - 1.0)

        else:
            # Socket连接没有建立，提示用户
            self.chatText.insert(tkinter.END, '您还未与客户端建立连接，客户端无法收到您的消息\n')
            # 清空用户在Text中输入的消息
            self.inputText.delete(0.0, message.__len__() - 1.0)

    def close(self):
        '''
        关闭消息窗口并退出
        :return:
        '''
        sys.exit()


    def startNewThread(self):
        '''
        启动一个新线程来接收客户端的消息
        :return:
        '''
        thread = threading.Thread(target=self.receiveMessage, args=())
        thread.setDaemon(True)
        thread.start()


def main():
    server = ServerUI()
    server.startNewThread()
    server.root.mainloop()


if __name__ == '__main__':
    main()

执行如下 ¶

服务端 代码示例 S-1¶

代码示例 2 S-2¶

服务端代码示例 S-1¶