Python3小白笔记-用tkinter制作简易的Socket聊天窗口

最新推荐文章于 2024-07-17 23:23:48 发布

我的内心只有学习

最新推荐文章于 2024-07-17 23:23:48 发布

阅读量1.8k

点赞数 7

分类专栏： python 文章标签： python socket

本文链接：https://blog.csdn.net/m0_37138074/article/details/115416561

版权

python 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

前言
一、什么是 Socket？
- 1、socket()函数
- - 1.1、参数
二、什么是tkinter
三、源码（仅供参考）
总结：

前言

本内容为python课作业而做的简要笔记。
我使用的工具为python3，pycharm专业版（试用30天）

一、什么是 Socket？

链接: 菜鸟教程（Python 网络编程）
链接: Python 手册（网络编程的基本概念）
也许刚接触 “套接字”的人会直接懵了，又翻译为“插座”，但是这个名字叫什么其实并不重要，现阶段不用去纠结它的中文意思。

1、socket()函数

					socket.socket([family[, type[, proto]]])

1.1、参数

family: 套接字家族可以使 AF_UNIX 或者 AF_INET。
（AF_INET 表示 IPv4，AF_UNIX 表示 IPv6，既你要使用的IP类型）

type: 套接字类型可以根据是面向连接的还是非连接分为 SOCK_STREAM 或 SOCK_DGRAM。
（SOCK_STREAM 为 TCP协议，SOCK_DGRAM 为 UDP协议）

protocol: 一般不填默认为 0。

Socket就是网络中每个主机进程之间交互信息的网络协议

二、什么是tkinter

该Tkinter模块（“Tk接口”）是Tk GUI工具包的标准Python接口。Tk和Tkinter在大多数Unix平台以及Windows系统上均可用。（Tk本身不是Python的一部分;它保存在ActiveState中。）

链接: tkinter视频学习
链接: Python 手册（Tkinter）
链接: Python 官网（ Interfaces with Tk）

三、源码（仅供参考）

1.服务端server.py

import socket
import threading
import time

# 创建TCP Socket, 类型为服务器之间网络通信，流式Socket
mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 绑定服务器端的IP和端口
mySocket.bind((socket.gethostbyname('localhost'), 10000))
# 开始监听TCP传入连接，并设置操作系统可以挂起的最大连接数量
mySocket.listen(5)

print('服务器已启动 ', socket.gethostbyname('localhost'), '正在连接 ...')
# 创建字典，用于存储客户端的用户
mydict = dict()
# 创建字典，用于存储用户名和密码
userDict = {'aaa': '123123', 'bbb': '123123', 'ccc': '123123', 'ddd': '123123', 'eee': '123123'}
# 创建列表，用于存储客户端的连接
mylist = list()
# 创建列表，用户单独存储用户名
userList = list()

"""
000: 用户发送的信息
100: 所有用户名的列表
 110: 聊天窗口关闭
200: 系统发送到聊天窗口的信息
300: 返回到客户端的弹窗信息
400: 注册信息
  401: 注册成功
  402: 注册失败
500: 用户登录（ID和密码）
999: 跳过（收到提示）
"""

# 把 信息 发送给所有人(包括自己)
def chatMsgToAllOne(chatMsg):
    for c in mylist:
        try:
            # 向客户端发送消息
            c.send(chatMsg.encode("utf-8"))
        except:
            pass


# 保持与客户端连接的子线程的处理逻辑
def subThreadProcess(myconnection, connNumber, username):  # connNumber为标记符
    global mydict, mylist
    # 接收客户端消息
    print('客户端连接标记符:', connNumber, ' 昵称:', username)
    chatMsgToAllOne('200*系统提示：' + username + '已经进入聊天室，赶快和他（她）打招呼吧*')
    while True:
        try:
            # 接收客户端消息
            recvedMsg = str(myconnection.recv(1024).decode("utf-8")).rstrip().lstrip()
            prefix = recvedMsg[0:3]  # 信息标记符
            recvedMsg = recvedMsg[3:]  # 可见信息
            if prefix == '000':  # 000表示用户输入框的信息
                chatMsgToAllOne('000' + mydict[connNumber] + ':' + recvedMsg)
            elif prefix == '110':
                userList.remove(recvedMsg)  # 用户名删除
                mylist.remove(myconnection)  # 客户端链接删除
                chatMsgToAllOne('100' + str(userList))  # 重新发送用户列表
        except (OSError, ConnectionResetError):
            try:
                mylist.remove(myconnection)
            except:
                pass
            print(mydict[connNumber], '已存在, ', len(mylist), ' 人员保存!')
            chatMsgToAllOne('200*系统提示：' + mydict[connNumber] + ' 已经离开聊天室*')
            mydict.pop(connNumber, '没有找到key')
            myconnection.close()
            return


def recvThreadProcess():
    global mydict, userList
    while True:
        # 接受TCP连接并返回（connection,address）,其中connection是新的Socket对象，可以用来接收和发送数据,address是连接客户端的地址。
        connection, address = mySocket.accept()  # 阻塞，等待消息
        print("server connection:", connection)
        print('新的连接访问', connection.getsockname(), '标记符:' + str(connection.fileno()))
        try:
            # 接收客户端消息
            buf = connection.recv(1024).decode("utf-8")
            if buf == '1':
                # 向客户端发送消息
                connection.send('连接成功, 欢迎来到聊天室!'.encode("utf-8"))  # （只发给自己，不发给他人）
                mylist.append(connection)  # 用户地址信息
                while True:
                    clientInfo = connection.recv(1024).decode("utf-8")
                    # print("clientInfo1:", clientInfo)
                    cLprefix = clientInfo[0:3]
                    clientInfo = clientInfo[3:]
                    # print("clientInfo1:", clientInfo, "clprefix:", cLprefix)
                    if cLprefix == '400':  # 注册信息
                        clientInfo = eval(clientInfo)
                        if clientInfo[0] in userDict:
                            print("no")
                            chatMsgToAllOne('402'+'用户名存在')
                        else:
                            print("yes")
                            userDict[clientInfo[0]] = clientInfo[1]
                            chatMsgToAllOne('401'+'注册成功')
                            print("userDict[", clientInfo[0], "]=", userDict[clientInfo[0]])
                    elif cLprefix == '500':  # 用户登录信息
                        clientInfo = eval(clientInfo)
                        if clientInfo[0] in userDict:  # 校验用户名
                            tempDict = clientInfo[1]
                            if tempDict[str(clientInfo[0])] == userDict[str(clientInfo[0])]:  # 检验密码
                                chatMsgToAllOne('999')
                                time.sleep(0.5)
                                mydict[connection.fileno()] = clientInfo[0]  # 按 标记符 存放 用户名
                                userList.append(clientInfo[0])
                                # 把更新后的 mylist 发送给所有用户
                                chatMsgToAllOne('100' + str(userList))
                                time.sleep(1)

                                # 为当前连接创建一个新的子线程来保持通信
                                myThread = threading.Thread(target=subThreadProcess,
                                                            args=(connection, connection.fileno(), clientInfo[0]))  # .fileno()为标记符
                                myThread.setDaemon(True)
                                myThread.start()
                                break
                            else:
                                chatMsgToAllOne('300')  # 300——客户端弹窗信息
                                print("用户名或密码错误")
                        else:
                            chatMsgToAllOne('300')  # 300——客户端弹窗信息
                            print("用户名或密码错误")

                """ 查看线程数量"""
                # count = len(threading.enumerate())
                # print("当前线程的数量：", count)
            else:
                # 向客户端发送消息
                connection.send('200连接失败, 请离开!'.encode("utf-8"))
                connection.close()
        except:
            pass

# 类型判断
def typeCheck(string):
    if string[0] == '[' and string[-1] == ']':
        return 'list'
    elif string[0] == '{' and string[-1] == '}':
        return 'dict'
    elif string[0] == '(' and string[-1] == ')':
        if isinstance(string, tuple):
            return 'tuple'
        else:
            return 'string'
    else:
        return 'string'

if __name__ == '__main__':
    recvThreadProcess()

1.1 服务器如何发送信息到客户端？

1）在thread()方法的第4行，accept()返回一个元组类型，其中connection是新的Socket对象（与发送信息的客户端所创建的Socket不是同一个Socket）。
2）connection中存储着客户端的IP地址和端口，每个新connection唯一指向一个客户端（网络主机进程），用mylist列表存储各个客户端的Socket。
3）由connection.recv()接收客户端的发来的信息（服务端连接了多少个客户端，服务端就开了多少个subThreadProcess()线程，每个子线程唯一对应一个客户端）
4）在chatMsgToAllOne()方法中发送信息给所有客户端

1.2 自己的客户端如何发送信息到其他主机的客户端？

1）在Client.py中，客户端用socket.send()发送输入的信息给服务器，服务器在subThreadProcess()方法中接收到某个客户端发来的信息，紧接着调用chatMsgToAllOne()方法把信息发给所有已连接的客户端（mylist），再在客户端通过socket.recv()来接收服务器信息，随之打印出来。
2）不管是服务器还是客户端，接收信息的socket.recv()方法都在死循环中，用线程将它们分隔开来就可以做其他的事情了

1.3 如何发送特殊指令不让指令显示在客户端信息窗？

1）可以模仿网络通信协议给信息打包，到指定主机再一一解包。
2）这里我采用简单的标记符的方式给信息分门别类。规定发送的任何信息前三个字符必须在000-999区间，用户发送的信息默认会在首部添加‘000’标记符，标记符由服务器客户端一同进行处理，其他客户端收到的信息不含有标记符，并且用户发送的信息不会干扰到标记符的正常处理。

2.客户端client.py

import socket
import threading
from tkinter import *
import time
import tkinter.messagebox as messagebox
import sys


fon = ("宋体", 18)
usersList = {}  # 所有用户名列表
usersDict = {}  # 用户名:密码
myName = ""  # 用户名

# 注册信息
tempUandP = []

"""
000: 用户发送的信息
100: 所有用户名的列表
 110: 聊天窗口关闭
200: 系统发送到聊天窗口的信息
300: 返回到客户端的弹窗信息
400: 注册信息
  401: 注册成功
  402: 注册失败
500: 用户登录（ID和密码）
999: 跳过（收到提示）
"""

"""聊天窗口800x600"""
class Application():

    def __init__(self):
        # 创建容器
        # 顶部——标签
        self.titleTop = Label(root, text="聊天群", fg="black", font=fon)
        self.titleTop.pack(side='top', fill='both')
        # 底部——输入框
        self.f1 = Frame(root, width=10, height=100)
        self.f1.pack(side="bottom", fill='x')
        # 中部左——聊天信息显示界面
        self.listboxLeft = Listbox(root, width=55, height=16, font=fon, yscrollcommand="true")
        self.listboxLeft.pack(side='left', fill='y')
        # 中部右——用户列表
        self.fRight = Frame(root, width=140)
        self.fRight.pack(side='right', fill="both", expand="no")
        self.f_labelTop = Label(self.fRight, text="用户列表", fg="black", font=fon, padx=20)
        self.f_labelTop.pack(side='top',fill='y')
        self.f_listboxBottom = Listbox(self.fRight, font=fon)
        self.f_listboxBottom.pack(side='top', fill="both", expand="yes")
        # 底部——输入框
        self.textBottom = Text(self.f1, width=54, height=3, font=fon, yscrollcommand="true", padx=5)
        self.textBottom.pack(side="left", fill='both')
        # 底部——确认按钮
        self.buttonR = Button(self.f1, width=18, text="发送", font=fon, command=self.sendThreadProcess)
        self.buttonR.pack(side='right', fill='y')

        # 设置聊天窗口顶部标签
        self.titleTop['text'] = "五邑聊天群(" + str(myName) + ")"

        self.thead()

    # 向服务器端发送消息的处理逻辑
    def sendThreadProcess(self):
        try:
            inputText = self.textBottom.get(1.0, END)
            sock.send(('000'+inputText).encode("utf-8"))  # 000表示用户发送输入框的信息
            self.textBottom.delete(0.0, END)
        except ConnectionAbortedError:
            print('服务端已经关闭这个连接!')
        except ConnectionResetError:
            print('服务器已关闭!')

    # 向服务器端接收消息的处理逻辑
    def recvThreadProcess(self):
        global usersList
        while True:
            try:
                self.otherMsg = sock.recv(1024).decode("utf-8")
                otherMsg_prefix = self.otherMsg[0:3]  # 前缀 信息标识符
                self.otherMsg = self.otherMsg[3:]  # 信息
                print('prefix:', otherMsg_prefix)
                if otherMsg_prefix == '000':
                    if len(self.otherMsg.rstrip().lstrip()) > len(myName) + 1:  # 空格不发送 .rstrip()去除尾空格 .lstrip()去除首空格
                        # 消息放入显示面板
                        self.listboxLeft.insert(END, self.otherMsg)
                elif otherMsg_prefix == '100': # 100表示用户列表
                    usersList = eval(self.otherMsg.rstrip().lstrip())  # 添加用户到元组列表
                    self.f_listboxBottom.delete(0, END)                  # 清除用户列表
                    for i in range(len(usersList)):                      # 显示在线人员
                        self.f_listboxBottom.insert(END, usersList[i])
                elif otherMsg_prefix == '200':
                    self.listboxLeft.insert(END, self.otherMsg)
                else:
                    pass
            except ConnectionAbortedError:
                print('服务端已经关闭这个连接!')
                break
            except ConnectionResetError:
                print('服务器已关闭!')
                break

    # 关闭窗口 并更新聊天界面的“用户列表”
    def closeWin(self):
        print("110"+myName)
        sock.send(("110"+myName).encode("utf-8"))
        root.destroy()

    # 创建发送和接收消息的子线程
    def thead(self):
        recvThread = threading.Thread(target=self.recvThreadProcess, daemon=True)
        recvThread.start()

"""登录窗口400x300"""
class loginWin(Frame):
    def __init__(self, master=None):
        super().__init__(master)
        self.master = master
        self.pack()
        self.createWidget()

    def createWidget(self):
        self.frame01 = Frame(login, width=400, height=100)
        self.frame02 = Frame(login, width=400, height=100)
        self.frame03 = Frame(login, width=400, height=100)
        self.frame04 = Frame(login, width=400, height=100)

        self.frame01.pack()
        self.frame02.pack()
        self.frame03.pack()
        self.frame04.pack()

        self.tittle01 = Label(self.frame01, text="欢迎登录五邑", font=fon)
        self.label01 = Label(self.frame02, text="用户名：", font=fon)
        self.label02 = Label(self.frame03, text="密  码：", font=fon)
        self.entry01 = Entry(self.frame02, width=16, font=fon, bg='white', xscrollcommand='true')
        self.entry02 = Entry(self.frame03, width=16, font=fon, bg='white', xscrollcommand='true', show="*")
        self.B_login = Button(self.frame04, width=10, height=1, text="登录", font=fon, command=self.logins)
        self.B_regist = Button(self.frame04, width=10, height=1, text="注册", font=fon, command=regist)

        self.tittle01.pack(pady=20)
        self.label01.pack(side='left', fill='both', padx=20, pady=20)
        self.label02.pack(side='left', fill='both', padx=20, pady=20)
        self.entry01.pack(side='right', fill='x', pady=20)
        self.entry02.pack(side='right', fill='x', pady=20)
        self.B_login.pack(side='left', fill='both', padx=20, pady=20)
        self.B_regist.pack(side='right', fill='both', padx=20, pady=20)

    def logins(self):
        global myName, usersDict
        myName = self.entry01.get()  # 输入用户名
        usersDict[str(myName)] = self.entry02.get()  # dict存放用户名和密码
        # 向服务器发送 登录窗口 用户名 和 密码
        sock.send(('500'+str([myName, usersDict])).encode("utf-8"))
        info = sock.recv(1024).decode("utf-8")
        if info == '300':
            messagebox.showinfo("错误", "用户名或密码错误")
        else:
            login.destroy()

    def closeWin(self):
        login.destroy()
        sys.exit()  # 程序关闭

"""注册窗口400x300"""
class registers(Frame):
    def __init__(self, master=None):
        super().__init__(master)
        self.master = master
        self.place()
        self.createWidget()

    def createWidget(self):
        self.lable01 = Label(reg, text="用 户 名：", font=fon)
        self.lable02 = Label(reg, text="密   码：", font=fon)
        self.lable03 = Label(reg, text="确认密码：", font=fon)
        self.entry01 = Entry(reg, font=fon)
        self.entry02 = Entry(reg, font=fon, show="·")
        self.entry03 = Entry(reg, font=fon, show="·")
        self.b1 = Button(reg, text='注册', font=fon, command=self.regButton)
        self.b2 = Button(reg, text='取消', font=fon, command=self.cancel)

        self.lable01.place(x=10, y=25)
        self.lable02.place(x=10, y=85)
        self.lable03.place(x=10, y=145)
        self.entry01.place(x=130, y=25)
        self.entry02.place(x=130, y=85)
        self.entry03.place(x=130, y=145)
        self.b1.place(x=80, y=210)
        self.b2.place(x=280, y=210)

    def regButton(self):
        global tempUandP
        # 获取注册信息
        try:
            if len(self.entry01.get()) >= 1:
                tempUandP.append(self.entry01.get())  # 用户名
            if len(self.entry02.get()) >= 6:
                tempUandP.append(self.entry02.get())  # 密码
            if len(self.entry03.get()) >= 6:
                tempUandP.append(self.entry03.get())  # 重复密码
            if tempUandP[1] == tempUandP[2]:
                # 向服务器发送 注册窗口 用户名、密码和重复密码
                sock.send(('400'+str(tempUandP)).encode("utf-8"))
                info = sock.recv(1024).decode("utf-8")
                info_prefix = info[0:3]
                info = info[3:]
                if info_prefix == '401':  # 成功
                    messagebox.showinfo("注册", "注册成功")
                    reg.destroy()
                elif info_prefix == '402':  # 失败
                    messagebox.showinfo("错误", info)
                    raise_above_all(reg)
            else:
                messagebox.showinfo("错误", "密码不相同")
        except:
            pass
    def cancel(self):
        reg.destroy()

"""创建Socket"""
def createSocket():
    global sock
    # 创建TCP Socket, 类型为服务器之间网络通信，流式Socket
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 通过IP和端口号连接服务器端Socket, 类型为服务器之间网络通信，流式Socket
    sock.connect((socket.gethostbyname('localhost'), 10000))
    # 向服务器发送连接请求
    sock.send(b'1')
    # 从服务器接收到的消息
    print(sock.recv(1024).decode("utf-8"))

# 窗口显示在最前
def raise_above_all(win):
    win.attributes('-topmost', 1)
    win.attributes('-topmost', 0)

# 注册窗口
def regist():
    global reg
    reg = Tk()
    reg.title("用户注册")
    reg.geometry("400x300+700+300")
    reg.resizable(0, 0)
    app3 = registers(master=reg)
    reg.mainloop()

# 登录窗口
def loginStart():
    global login
    login = Tk()
    login.title("用户登录")
    login.geometry("400x300+700+300")
    login.resizable(0, 0)    # 禁止窗口大小改变
    app2 = loginWin(master=login)
    login.protocol("WM_DELETE_WINDOW", app2.closeWin)
    raise_above_all(login)
    login.mainloop()

# 聊天窗口
def rootStart():
    global root
    root = Tk()
    root.title("聊天窗口")
    root.geometry("800x600+500+100")
    root.resizable(0, 0)    # 禁止窗口大小改变
    app1 = Application()
    root.protocol("WM_DELETE_WINDOW", app1.closeWin)
    raise_above_all(root)
    root.mainloop()

if __name__ == '__main__':
    createSocket()
    loginStart()
    rootStart()

总结：

有待改进……

> 引用文本《Python网络编程-从入门到精通》苟英张小华高博·编著

我的内心只有学习

关注

7
点赞
踩
40

收藏

觉得还不错? 一键收藏
0
评论
Python3小白笔记-用tkinter制作简易的Socket聊天窗口

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结前言提示：这里可以添加本文要记录的大概内容：例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考一、pandas是什么？示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。二、使用步骤1.引入库代码
复制链接

扫一扫

专栏目录