Socket编程,简单的实现多人同时猜数字，使用线程实现

TCP: 基础的猜数字游戏，使用随机数模块产生式随机数，使用线程，每连接一次启动一个线程，则产生一个新的随机数，每个客户端有5次机会，机会用完之后可以选择是否继续玩游戏，继续则产生新的随机数，开始新的一轮游戏，猜对了则关闭当前游戏。服务器可以一直开启，只要检测到客户端上线，则产生随机数，没有客户端连接，则处于等待状态。

服务器代码：

#TCPserver.py(TCP服务器)

import socket
import threading
import random

def server_recv(server_addr,server_port):
	#使用随机数包产生式随机数
    random_number = random.randint(1,101)
    print("产生的随机数是：",random_number)
    #定义count变量，记录客户端猜测次数
    count = 0
    while True:
    	#接受客户端信息
        message = server_addr.recv(1024).decode("utf-8")
        #每接收一次则次数加一
        count = count+1
        #判断次数是否小于5次
        if count <= 5:
        	#次数小于5次则比较客户端猜测的数字与产生的随机数大小关系，并且返回给客户端。如果猜对了则关闭当前用户连接
            if int(message)>random_number:
                server_addr.sendall(('猜大了').encode("utf-8"))
            elif int(message)<random_number:
                server_addr.sendall(('猜小了').encode("utf-8"))
            else:
                server_addr.sendall(('恭喜你猜对了').encode("utf-8"))
                print("断开当前连接")
                server_addr.close()
                break
		#如果count次数大于五，则本一轮游戏结束，客户端选择是否继续游戏
        elif count > 5:
            server_addr.sendall(('没有机会了').encode("utf-8"))
            message1 = server_addr.recv(1024).decode("utf-8")
            if message1 == 'N':
                print("继续新的一轮游戏")
                server_recv(server_addr,server_port)
            else:
                print("断开当前连接")
                server_addr.close()
                break
            break


if __name__ == "__main__":
    # 创建套接字
    tcp_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 绑定地址、端口号
    tcp_server.bind(("localhost", 9999))
    # 监听
    tcp_server.listen(5)
    print("服务器上线")
    while True:
        # 接收客户端信息
        tcp_server_client, addr = tcp_server.accept()
        print("客户端%已连接" , addr)
        tcp_server_client.sendall(('请开始猜数字：').encode("utf-8"))
        # 创建一个线程来接受数据并打印
        tcp_thread = threading.Thread(target=server_recv, args=(tcp_server_client, addr))
        tcp_thread.start()

客户端代码：

#TCPclient.py

import socket
import threading

def client_recv(client_addr):
    while True:
        accept_date = input("输入猜测的数字：")
        client_addr.sendall(accept_date.encode("utf-8"))
        recv_data1 = client_addr.recv(1024).decode("utf-8")
        print("服务器说：",recv_data1)
        if recv_data1 == '恭喜你猜对了':
            print("客户端已关闭")
            client_addr.close()
            break

        elif recv_data1 == '没有机会了':
            message= input("是否关闭连接Y/N：")
            client_addr.sendall(message.encode("utf-8"))
            if message == "Y":
                print("客户端已关闭")
                client_addr.close()
                break
            else:
                client_recv(client_addr)

if __name__ == "__main__":
    # 创建tcp套接字
    tcp_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 绑定服务器地址，端口
    client_addr = 'localhost'
    client_prot = 9999
    tcp_client.connect((client_addr,client_prot))
    print("客户端上线")
    recv_data = tcp_client.recv(1024).decode("utf-8")
    print("服务器说：", recv_data)
    #创建线程调用猜数字函数
    client_thread = threading.Thread(target=client_recv, args=(tcp_client,))
    client_thread.start()
    client_thread.join()

UDP: 功能和上述TCP功能大同小异，只是当服务器打开时，产生随机数，当有用户连接的时候，给客户端发送猜数字消息，如果用多个用户连接，其中某一个用户猜测对了产生的随机数，则重新产生新的随机数，如果超过次数，则可以选择是否继续游戏，当前如果没有客户端连接，则服务器产生随机数等待，有用户连接则可以直接进行猜测。

服务器代码如下：

#UDPserver.py

import socket
import random
import threading

def udp_recv(serverSocket1):
    # 产生随机数
    random_number = random.randint(1, 101)
    print("产生的随机数是：", random_number)
    #定义变量记录每一个随机数猜测的次数
    count = 1
    while True:
    	#从客户端接收信息
        message, clientAddress = serverSocket1.recvfrom(2048)
        print(clientAddress,":",int(message))
        #每接收一次猜测的数据则次数加1
        count = count + 1
        #次数小于5的时候进入数据比较阶段，并且返回消息给客户端
        if count <= 5:
            if int(message) > random_number:
                serverSocket1.sendto(('猜大了').encode("utf-8"),clientAddress)
            elif int(message) < random_number:
                serverSocket1.sendto(('猜小了').encode("utf-8"),clientAddress)
            else:
                serverSocket1.sendto(('恭喜你猜对了').encode("utf-8"),clientAddress)
                print("断开当前连接")
                serverSocket1.close()
                main()
		#次数大于5的时候客户端选择是否继续，如果继续则重新开始新的随机数猜测，否则关闭当前客户连接
        elif count > 5:
            serverSocket1.sendto(("机会已经用完了").encode("utf-8"),clientAddress)
            message1,clientAddress1 = serverSocket1.recvfrom(1024)
            message2 = message1.decode("utf-8")
            if message2 == 'N':
                print("继续新的一轮游戏")
                udp_recv(serverSocket1)
            else:
                print("断开当前连接")
                serverSocket1.close()
                main()

def main():
    #服务器地址
    serverHost = ''
    # 服务器指定的端口
    serverPort = 12000
    # 创建UDP套接字
    serverSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    # 将套接字绑定到之前指定的端口
    serverSocket.bind((serverHost, serverPort))
    print("我是UDP服务端，我来了！")
	#创建线程
    udp_thread = threading.Thread(target=udp_recv,args=(serverSocket,))
    udp_thread.start()
    udp_thread.join()


if __name__ == "__main__":
    main()

客户端代码：

UDPclient.py

import socket
import threading

def server_udp(server_ip,server_prot):
    while True:
        # 创建UDP套接字
        clientSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        # 用户输入信息，并编码为bytes以便发送
        message = input('输入你猜测的数字：').encode("utf-8")
        # 将信息发送到服务器
        clientSocket.sendto(message, (server_ip, server_prot))
        # 从服务器接收信息，同时也能得到服务器地址
        modifiedMessage,serverAddress = clientSocket.recvfrom(2048)
        # 显示服务器返回的信息
        modifiedMessage1 = modifiedMessage.decode("utf-8")
        print("服务端回复说:",modifiedMessage1)
        if modifiedMessage1 == '恭喜你猜对了':
            print("客户端已关闭")
            clientSocket.close()
            break

        elif modifiedMessage1 == '机会已经用完了':
            message = input("是否关闭连接Y/N：")
            clientSocket.sendto(message.encode("utf-8"),(server_ip,server_prot))
            if message == "Y":
                print("客户端已关闭")
                clientSocket.close()
                break
            else:
                server_udp(server_ip,server_prot)


if __name__ == "__main__":
    serverIp = 'localhost'  # 服务器地址，本例中使用一台远程主机
    serverPort = 12000  # 服务器指定的端口
    print("客户端上线！")
    #创建线程，调用猜测猜测函数
    server_thread = threading.Thread(target=server_udp, args=(serverIp, serverPort))
    server_thread.start()