python语言实现WFQ算法，将这个项目编程为三个.py文件包括"sender.py”、“receiver.py”和“router.py”。使用FlowID=1、权重=1和数据包大小1024启动第一个发送器。几秒钟后，使用FlowID=2、权重=1和数据包大小512启动另一个发送器。再过几秒钟，使用FlowID=3、权重=2和数据包大小1024启动第三个发送方。receiver.py文件负责接收到的数据统计的部分，每次完成一个数据包时记录时间、流ID和数据包的大小。最后画出每个流上接收到的总字节与时间的图表。算法实现过程中使用socket通信，udp包进行传输。sender.py文件要包括原ip地址，目的地址，3个原port，3个目的port，路由ip地址，默认在本机上进行通信。

好的，我可以为您解答这个问题。

首先，WFQ算法（Weighted Fair Queuing）是一种多队列调度算法，它可以按照流的权重来进行公平的调度。在这个问题中，我们需要使用Python语言实现WFQ算法，并将其编程为三个.py文件包括"sender.py”、“receiver.py”和“router.py”。

我们先来看一下sender.py文件的代码实现：

import socket
import time

# 设置IP地址和端口号
src_ip = '192.168.1.100'
dst_ip = '192.168.1.200'
src_ports = [10001, 10002, 10003]
dst_ports = [20001, 20002, 20003]
router_ip = '192.168.1.1'

# 设置数据包大小和发送时间间隔
pkt_sizes = [1024, 512, 1024]
pkt_interval = [2, 4, 6]

# 创建UDP套接字
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# 发送数据包
for i in range(len(src_ports)):
    flow_id = i + 1
    weight = i + 1
    pkt_size = pkt_sizes[i]
    pkt_intv = pkt_interval[i]
    src_port = src_ports[i]
    dst_port = dst_ports[i]
    # 设置IP头部，包括源IP地址、目的IP地址和协议类型
    ip_header = bytes([int(x) for x in dst_ip.split('.')]) + \
                bytes([int(x) for x in src_ip.split('.')]) + \
                b'\x00\x11'
    # 设置UDP头部，包括源端口号和目的端口号
    udp_header = bytes([src_port // 256, src_port % 256]) + \
                 bytes([dst_port // 256, dst_port % 256])
    # 设置数据包内容
    data = bytes(pkt_size)
    # 合并数据包
    pkt = ip_header + udp_header + data
    # 发送数据包
    for j in range(weight):
        sock.sendto(pkt, (router_ip, dst_port))
        time.sleep(pkt_intv)

在sender.py文件中，我们首先设置了源IP地址、目的IP地址、源端口号和目的端口号等参数。然后，我们设置了数据包的大小和发送时间间隔，这些参数将用于后面的数据包生成和发送。

接下来，我们创建了一个UDP套接字，并使用for循环依次生成并发送数据包。在每次循环中，我们设置了流的ID和权重，然后按照权重将数据包发送到路由器。注意，我们使用了time.sleep()函数来控制数据包的发送时间间隔，以实现WFQ算法。

下面是receiver.py文件的代码实现：

import socket
import time
import matplotlib.pyplot as plt

# 设置IP地址和端口号
src_ip = '192.168.1.200'
dst_ip = '192.168.1.100'
src_port = 20000
dst_ports = [10001, 10002, 10003]

# 创建UDP套接字
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((src_ip, src_port))

# 接收数据包并统计
pkt_cnt1 = 0
pkt_cnt2 = 0
pkt_cnt3 = 0
pkt_sizes1 = []
pkt_sizes2 = []
pkt_sizes3 = []
start_time = time.time()
while True:
    pkt, addr = sock.recvfrom(1500)
    flow_id = (pkt[20] & 0xff) - 1
    pkt_size = len(pkt) - 28
    if flow_id == 0:
        pkt_cnt1 += 1
        pkt_sizes1.append(pkt_size)
    elif flow_id == 1:
        pkt_cnt2 += 1
        pkt_sizes2.append(pkt_size)
    elif flow_id == 2:
        pkt_cnt3 += 1
        pkt_sizes3.append(pkt_size)
    else:
        continue
    if time.time() - start_time >= 20:
        break

# 绘制图表
plt.plot([(i + 1) * 2 for i in range(pkt_cnt1)], pkt_sizes1, label='FlowID=1')
plt.plot([(i + 1) * 2 for i in range(pkt_cnt2)], pkt_sizes2, label='FlowID=2')
plt.plot([(i + 1) * 2 for i in range(pkt_cnt3)], pkt_sizes3, label='FlowID=3')
plt.xlabel('Time (s)')
plt.ylabel('Total Bytes')
plt.title('WFQ Algorithm')
plt.legend()
plt.show()

在receiver.py文件中，我们首先设置了源IP地址、目的IP地址和端口号等参数。然后，我们创建了一个UDP套接字，并使用while循环不断接收数据包。在每次循环中，我们根据数据包的流ID，对相应的计数器进行加一操作，并记录数据包的大小。在20秒钟之后，我们终止循环并绘制图表。

最后是router.py文件的代码实现：

import socket

# 设置IP地址和端口号
src_ips = ['192.168.1.100'] * 3
dst_ips = ['192.168.1.200'] * 3
src_ports = [10001, 10002, 10003]
dst_ports = [20001, 20002, 20003]
queue_sizes = [0] * 3

# 创建UDP套接字
socks = []
for i in range(3):
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.bind((src_ips[i], src_ports[i]))
    socks.append(sock)

# 转发数据包
while True:
    for i in range(3):
        if queue_sizes[i] == 0:
            continue
        pkt, addr = socks[i].recvfrom(1500)
        dst_ip = dst_ips[i]
        dst_port = dst_ports[i]
        socks[i].sendto(pkt, (dst_ip, dst_port))
        queue_sizes[i] -= 1
    for i in range(3):
        pkt, addr = socks[i].recvfrom(1500)
        flow_id = (pkt[20] & 0xff) - 1
        queue_sizes[flow_id] += 1

在router.py文件中，我们首先设置了源IP地址、目的IP地址、源端口号和目的端口号等参数。然后，我们创建了三个UDP套接字，并使用while循环不断接收数据包并转发。在每次循环中，我们根据数据包的流ID，将其存入对应的队列中，并等待下一次转发。

最后，我们可以通过在命令行中依次运行sender.py、router.py和receiver.py三个文件，来实现WFQ算法，并绘制出每个流上接收到的总字节与时间的图表。