python实现WFQ算法，将这个项目编程三个例程，“发送者”、“接收者”和“路由器”。使用FlowID=1、重量=1和数据包大小1024启动发件人。几秒钟后，使用FlowID=2、权重=1和数据包大小512启动另一个发送器。再过几秒钟，使用FlowID=3、权重=2和数据包大小1024启动第三个发送方。提供在每个流上接收到的总字节与时间的图表。接收方应该在每次完成一个数据包时记录时间、流ID和数据包的大小。

好的，这是一个比较复杂的项目，需要涉及到网络通信和算法实现。下面是一个简单的WFQ算法的Python实现，您可以根据需要进行修改和完善。

首先，我们需要定义一些常量和数据结构。假设我们使用IPv4协议，数据包格式如下：

class Packet:
    def __init__(self, src_ip, dst_ip, flow_id, size):
        self.src_ip = src_ip
        self.dst_ip = dst_ip
        self.flow_id = flow_id
        self.size = size

我们还需要定义路由器和发送者的IP地址和端口号，以及最大队列长度和时间间隔：

ROUTER_IP = '127.0.0.1'
ROUTER_PORT = 8000

SENDERS = [
    {'ip': '127.0.0.1', 'port': 8001, 'flow_id': 1, 'weight': 1, 'packet_size': 1024},
    {'ip': '127.0.0.1', 'port': 8002, 'flow_id': 2, 'weight': 1, 'packet_size': 512},
    {'ip': '127.0.0.1', 'port': 8003, 'flow_id': 3, 'weight': 2, 'packet_size': 1024},
]

MAX_QUEUE_LEN = 1000
TIME_INTERVAL = 0.1

接下来，我们可以定义路由器和发送者的代码。路由器需要维护一个队列，按照权重和时间戳对数据包进行排序，然后依次发送。发送者需要在指定的时间间隔内发送数据包，并将其添加到队列中。

import socket
import time
import struct
import heapq


class Router:
    def __init__(self):
        self.queue = []

    def run(self):
        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        sock.bind((ROUTER_IP, ROUTER_PORT))
        sock.setblocking(False)

        while True:
            try:
                data, addr = sock.recvfrom(1024)
                packet = Packet(*struct.unpack('!4s4sii', data))
                heapq.heappush(self.queue, (time.time(), packet))
            except socket.error:
                pass

            while self.queue:
                now = time.time()
                weight_sum = sum([sender['weight'] for sender in SENDERS])
                min_weight = min([sender['weight'] for sender in SENDERS])
                packets = []

                while self.queue:
                    if len(packets) >= MAX_QUEUE_LEN:
                        break
                    timestamp, packet = heapq.heappop(self.queue)
                    sender = next((sender for sender in SENDERS if sender['flow_id'] == packet.flow_id), None)
                    if sender is None:
                        continue
                    weight = sender['weight']
                    if weight == 0:
                        continue
                    delay = (now - timestamp) * weight_sum / weight
                    if delay < TIME_INTERVAL:
                        heapq.heappush(self.queue, (timestamp, packet))
                        break
                    packets.append(packet)

                if packets:
                    for sender in SENDERS:
                        packets_for_sender = [packet for packet in packets if packet.flow_id == sender['flow_id']]
                        total_size = sum([packet.size for packet in packets_for_sender])
                        if total_size == 0:
                            continue
                        delay = (now - self.last_sent_time[sender['flow_id']]) * weight_sum / sender['weight']
                        if delay < TIME_INTERVAL:
                            continue
                        self.last_sent_time[sender['flow_id']] = now
                        data = struct.pack('!4s4sii', sender['ip'], ROUTER_IP, sender['flow_id'], total_size)
                        sock.sendto(data, (sender['ip'], sender['port']))

            time.sleep(TIME_INTERVAL)

            
class Sender:
    def __init__(self, ip, port, flow_id, weight, packet_size):
        self.ip = ip
        self.port = port
        self.flow_id = flow_id
        self.weight = weight
        self.packet_size = packet_size

    def run(self):
        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        while True:
            packet = Packet(self.ip, ROUTER_IP, self.flow_id, self.packet_size)
            data = struct.pack('!4s4sii', packet.src_ip, packet.dst_ip, packet.flow_id, packet.size)
            sock.sendto(data, (ROUTER_IP, ROUTER_PORT))
            time.sleep(TIME_INTERVAL)


if __name__ == '__main__':
    router = Router()
    for sender_info in SENDERS:
        sender = Sender(sender_info['ip'], sender_info['port'], sender_info['flow_id'], sender_info['weight'], sender_info['packet_size'])
        sender.run()

最后，我们可以启动路由器和发送者，并在接收方记录时间、流ID和数据包大小，以便绘制图表。

import matplotlib.pyplot as plt


if __name__ == '__main__':
    router = Router()
    for sender_info in SENDERS:
        sender = Sender(sender_info['ip'], sender_info['port'], sender_info['flow_id'], sender_info['weight'], sender_info['packet_size'])
        sender.run()

    received_bytes = {sender['flow_id']: 0 for sender in SENDERS}
    received_times = {sender['flow_id']: [] for sender in SENDERS}

    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.bind((ROUTER_IP, ROUTER_PORT))

    while True:
        data, addr = sock.recvfrom(1024)
        flow_id, size = struct.unpack('!ii', data[8:])
        received_bytes[flow_id] += size
        received_times[flow_id].append(time.time())

        plt.clf()
        for sender in SENDERS:
            flow_id = sender['flow_id']
            plt.plot(received_times[flow_id], received_bytes[flow_id], label=f'Flow {flow_id}')
        plt.legend(loc='upper left')
        plt.xlabel('Time (s)')
        plt.ylabel('Bytes')
        plt.draw()
        plt.pause(0.0001)

这是一个简单的WFQ算法的Python实现，您可以根据需要进行修改和完善。但是需要注意，此代码仅供学习参考，实际应用时可能需要更加完善和优化。