python绘制简易聊天框 python聊天器

使用python实现 tcp/udp 多线程聊天器

• 套接字格式： socket(family,type[,protocal]) 使用给定的地址族、套接字类型、协议编号（默认为 0）来创建套接字。
• socket 类型
• socket 函数

• 注意事项
• 服务端 socket 函数
• 客户端 socket 函数
• 公共 socket 函数

• socket 编程思路

• TCP 服务端：
• TCP 客户端:
• 和客服聊天示例 tcp

• client
• server

• udp 群聊

• server
• client

套接字格式： socket(family,type[,protocal]) 使用给定的地址族、套接字类型、协议编号（默认为 0）来创建套接字。

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)

socket 函数

注意事项

• TCP 发送数据时，已建立好 TCP 连接，所以不需要指定地址。UDP 是面向无连接的，每次发送要指定是发给谁。
• 服务端与客户端不能直接发送列表，元组，字典。需要字符串化 repr(data)。

服务端 socket 函数

• s.bind(address) 将套接字绑定到地址, 在 AF_INET 下,以元组（host,port）的形式表示地址.
• s.listen(backlog) 开始监听 TCP 传入连接。backlog 指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为 1，大部分应用程序设为 5 就可以了。
• s.accept() 接受 TCP 连接并返回（conn,address）,其中 conn 是新的套接字对象，可以用来接收和发送数据。address 是连接客户端的地址。

客户端 socket 函数

• s.connect(address) 连接到 address 处的套接字。一般 address 的格式为元组（hostname,port），如果连接出错，返回 socket.error 错误。
• s.connect_ex(adddress) 功能与 connect(address)相同，但是成功返回 0，失败返回 errno 的值。

公共 socket 函数

• s.recv(bufsize[,flag]) 接受 TCP 套接字的数据。数据以字符串形式返回，bufsize 指定要接收的最大数据量。flag 提供有关消息的其他信息，通常可以忽略。
• s.send(string[,flag]) 发送 TCP 数据。将 string 中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于 string 的字节大小。
• s.sendall(string[,flag]) 完整发送 TCP 数据。将 string 中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回 None，失败则抛出异常。
• s.recvfrom(bufsize[.flag]) 接受 UDP 套接字的数据。与 recv()类似，但返回值是（data,address）。其中 data 是包含接收数据的字符串，address 是发送数据的套接字地址。
• s.sendto(string[,flag],address) 发送 UDP 数据。将数据发送到套接字，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() 创建一个与该套接字相关连的文件

socket 编程思路

TCP 服务端：

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

TCP 客户端:

• 1 创建套接字，连接远端地址socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.connect()
• 2 连接后发送数据和接收数据 # s.sendall(), s.recv()
• 3 传输完毕后，关闭套接字 #s.close()

和客服聊天示例 tcp

client

import socket
import threading
import sys
import signal


# AF_INET: IPV4, SOCK_STREAM: TCP
client = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8000))         # connect localhost:8000


# version 1 我发一条 客服回复一条 继续发送客服不回我会阻塞
'''
while True:
    re_data = input('请输入发送的消息:')                       # wait for user input
    client.send(re_data.encode('UTF-8'))    # send byte data
    if re_data == 'quit':
        break
    ge_data = client.recv(1024)             # receive data
    print('接收到的消息:%s' % ge_data.decode('UTF-8'))          # decode byte data
'''

# version 2  多线程


def receive_():
    while True:
        ge_data = client.recv(1024)
        # 测试得到结果 服务端按了ctrl c  这里无限收到消息长度为0 主动终止该线程
        if len(ge_data) == 0:
            print('服务端按了ctrl c 关闭收消息线程')
            # 直接泡异常 终止主线程
            # raise RuntimeError('终止主线程')

            break
        print('接收到的消息:%s' % ge_data.decode('UTF-8'))


def send_():
    while True:
        try:
            send_data = input('请输入发送的消息:')
            # 向客服发送消息
            client.send(send_data.encode('UTF-8'))
            if send_data == 'quit':
                client.close()             # close connection
                break
        except Exception as err:
            break


# 成功建立连接后 开启 收消息和发送消息的线程
# 一直监听消息的线程
# 子线程的daemon属性为True，主线程运行结束时不对这个子线程进行检查而直接退出，同时所有daemon值为True的子线程将随主线程一起结束，而不论是否运行完成
receive_thread = threading.Thread(target=receive_)
receive_thread.daemon = True
receive_thread.start()

# 发送消息的线程
send_thread = threading.Thread(target=send_)
send_thread.daemon = True
send_thread.start()


def signal_handler(signal, frame):
    print('You pressed Ctrl+C!')
    # client.close()
    # stop_thread()
    sys.exit(0)


# 监听ctrl c 主动中断脚本
signal.signal(signal.SIGINT, signal_handler)
while receive_thread.is_alive() and send_thread.is_alive():
    pass

server

import socket
import threading
from datetime import datetime
import sys

# AF_INET: IPV4, SOCK_STREAM: TCP
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
server.bind(('127.0.0.1', 8000))              # bind to localhost:8000
server.listen()                             # listen for clients
print('server is listen 8000')


# version 1  用户发一条 我必须回一条 才能继续收到另一条消息
'''
def process_client(socke, addr):
    sock = socke  # type:socket.socket

    print('收到客户端连接,地址为:{}'.format(addr))

    while True:
        ge_data = sock.recv(1024)               # receive data
        ge_str = str(ge_data.decode('UTF-8'))
        print('收到客户端%s发送的消息为:%s' % (addr, ge_str))
        if ge_str == 'quit':                    # if receive data 'quit', close connect
            print('客户端%s主动断开连接,终止连接' % (addr,))
            break
        print('处理客户端%s请求中。。。' % (addr,))

        res_data = input('请输入回复给%s的内容:' % (addr,))
        # res_data = str(datetime.now())
        print('响应客户端请求内容为:%s' % res_data)
        sock.send(res_data.encode('UTF-8'))      # send byte data

    sock.close()                                # close connection with

'''


# version 2
def process_client(socke, addr):
    sock = socke  # type:socket.socket

    print('收到客户端连接,地址为:{}'.format(addr))

    def receive_(sock, addr):
        while True:
            ge_data = sock.recv(1024)               # receive data

            # 测试得到结果 客户端按了ctrl c  这里无限收到消息长度为0 主动终止该线程
            if len(ge_data) == 0:
                print('客户端%sctrl c断开连接' % (addr,))
                sock.close()
                break

            ge_str = str(ge_data.decode('UTF-8'))
            print('收到客户端%s发送的消息为:%s' % (addr, ge_str))
            # quit 主动断开连接
            if ge_str == 'quit':
                print('客户端%s主动断开连接,终止连接' % (addr,))
                sock.close()
                break

            # print('处理客户端%s请求中。。。' % (addr,))

    def send_(sock, addr):
        while True:
            try:
                res_data = input('请输入回复给%s的内容:' % (addr,))
                sock.send(res_data.encode('UTF-8'))      # send byte data
            except Exception as err:
                print('send_send_send_', err)
                sock.close()
                break

    #  开启收消息线程
    receive_thread = threading.Thread(target=receive_, args=(sock, addr))
    send_thread = threading.Thread(target=send_, args=(sock, addr))

    # 开启发消息线程
    receive_thread.start()
    send_thread.start()

    # while receive_thread.is_alive() and send_thread.is_alive():
    #     pass


while True:
    # 接收到客户端的消息
    sock, addr = server.accept()
    # 开启一个线程去处理请求
    client_thread = threading.Thread(target=process_client, args=(sock, addr))
    client_thread.start()

server.close()

udp 群聊

server

import socket
import threading


# AF_INET: IPV4, SOCK_DGRAM: UDP
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
server.bind(('127.0.0.1', 8000))              # bind to localhost:8000
print('udp server is running...')

# 客户端集合 模拟群发 没有事先准备好的固定群员 只能是发了一条消息 认为他进入群聊
clients = set()

while True:
    # 其中 data 是包含接收数据的字节数组，address 是发送数据的套接字地址
    re_data, address = server.recvfrom(1024)
    data = re_data.decode('utf-8')

    # 是否是第一次发消息
    is_first_send = address in clients

    # 存入客户端列表
    clients.add(address)
    if not is_first_send:
        print('%s第一次进入了群聊😄,当前连接数量为%d' % (address, len(clients)))
        print('%s发了:%s' % (address, data))
    else:
        print('%s又发了:%s' % (address, data))

    # 群发的消息
    temp = str(address) + '____'

    # 如果是quit 这个人退出群聊 不群发
    if data == 'quit':
        print('%s退出群聊😯' % (address,))
        clients.remove(address)
        temp += '下线了😯____qq'
    else:
        temp += data

    send_data = temp.encode('utf-8')
    # 给所有的人群发消息  同时加上是谁谁谁发送的消息, 谁谁谁下线了
    print('群发中。。。')
    for client in clients:
        # 不给发的人再发送一遍
        if address != client:
            server.sendto(send_data, client)

    print('群发完成✅')


server.close()                              # close server

client

import socket
import threading
import sys

# AF_INET: IPV4, SOCK_DGRAM: UDP
client = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)


def receive_():
    while True:
        # 接收消息
        try:
            # 发送了quit之后 这里的client就会关闭  需要捕获异常
            re_data, address = client.recvfrom(1024)             # receive data
        except Exception as err:
            print(err)
            break

        data = re_data.decode('UTF-8').split('____')
        who = data[0]
        if len(data) > 2:
            print('接收到了消息:%s下线了😯 ' % (who))
        else:
            msg = data[1]
            print('接收到了消息:%s发送了 %s ' % (who, msg))


def send_():
    while True:
        send_data = input('请输入发送的消息:')
        # 向群发送了一条消息
        client.sendto(send_data.encode('UTF-8'), ('127.0.0.1', 8000))
        if send_data == 'quit':
            client.close()                              # close connection
            sys.exit(0)


# 一直监听消息的线程
receive_thread = threading.Thread(target=receive_)
receive_thread.start()

# 发送消息的线程
send_thread = threading.Thread(target=send_)
send_thread.start()