python实验三 实现UDP协议、TCP协议进行服务器端与客户端的交互

实验三

实验题目

1、请利用生成器构造一下求阶乘的函数Factorial()，定义一个函数m()，在m()中调用生成器Factorial()生成小于100的阶乘序列存入集合s中，输出s。

【代码】

def factorial():

  n=1

  f=1

  while 1:

​    f *= n

​    yield (f)

​    n+=1

 

def m():

  s=set()

  for f in factorial():

​    if f<100:

​      s.add(f)

​    else:

​      break

  print(s)

m()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

【实例】

2、利用UDP协议编写一个小型交互软件，要求如下：

（1）建立文件UDPT.py，在该文件中定义类UDPTalk,其析构函数传入ip地址和端口号，成为其私有属性；

（2）定义类UDPTalk的成员函数ServerU,建立一个服务器端应用，用于接收客户端的信息，并输出客户端发来的信息；

（3）定义类UDPTalk的成员函数ClientU,建立一个客户端应用，用于向服务器端发送信息

（4）建立文件SUT.py，在该文件中引入UDPTalk类，并定义一个ServerApp函数，在该函数中声明一个该类的对象，调用ServerU函数，创建接收信息服务器，运行这个函数，等待客户端发来信息。

（5）建立文件CUT.py，在该文件中引入UDPTalk类，并定义一个ClientApp函数，声明一个该类的对象，调用ClientU函数，向（4）中的服务器发信息

【代码】

UDPT.py

import socket

class UDPTalk:

  def __init__(self, ip, port):

​    self.ip = ip

​    self.port = port

​    self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

  def ServerU(self):

​    self.sock.bind((self.ip, self.port))

​    print(f"服务器已启动，正在监听 {self.ip}:{self.port}...")

​    while 1:

​      data, addr = self.sock.recvfrom(1024)

​      received_msg = data.decode()

​      print(f"客户端 [{addr[0]}:{addr[1]}] 发送的消息：{received_msg}")

  def ClientU(self):

​    server_addr = (self.ip, self.port)

​    print(f"连接到服务器 {self.ip}:{self.port}...")

​    while 1:

​      message = input("请输入要发送的消息（输入 'quit' 退出）：")

​      if message == 'quit':

​        print("已退出客户端应用。")

​        break

​      self.sock.sendto(message.encode(), server_addr)

​      print("消息已发送。")

  def __del__(self):

​    self.sock.close()

SUT.py

from UDPT import UDPTalk

def ServerApp():

  server = UDPTalk('localhost', 12345)

  server_alive = True

  try:

​    server.ServerU()

  except KeyboardInterrupt:

​    server_alive = False

​    print("客户端已退出。")

  finally:

​    if server_alive:

​      print("客户端已退出。")

if __name__ == '__main__':

ServerApp()

CUT.py

from UDPT import UDPTalk

def ClientApp():

  client = UDPTalk('localhost', 12345)

  client.ClientU()

if __name__ == '__main__':

ClientApp()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

【实例】

3、利用TCP协议编写一个小型交互软件，要求如下：

（1）建立文件TCPT.py，在该文件中定义类TCPTalk,其构造函数传入ip地址和端口号，成为其私有属性；

（2）定义类TCPTalk的成员函数ServerU,建立一个服务器端应用，用于接收客户端的信息，并输出客户端发来的信息；

（3）定义类TCPTalk的成员函数ClientU,建立一个客户端应用，用于向服务器端发送信息

（4）建立文件STT.py，在该文件中引入TCPTalk类，并定义一个ServerApp函数，在该函数中声明一个该类的对象，调用ServerU函数，创建接收信息服务器，运行这个函数，等待客户端发来信息。

（5）建立文件CTT.py，在该文件中引入TCPTalk类，并定义一个ClientApp函数，声明一个该类的对象，调用ClientU函数，向（4）中的服务器发信息。

【代码】

CTT.py

from TCPT import TCPTalk
def ClientApp():
  client = TCPTalk('localhost', 12345)
  client.ClientU()
if __name__ == '__main__':
  ClientApp()

STT.py

from TCPT import TCPTalk

def ServerApp():

  server = TCPTalk('localhost', 12345)

  server.ServerU()

if __name__ == '__main__':

  ServerApp()

TCPT.py

import socket

class TCPTalk:

  def __init__(self, ip, port):

​    self.ip = ip

​    self.port = port

​    self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

​    self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

  def ServerU(self):

​    self.sock.bind((self.ip, self.port))

​    self.sock.listen(1)

​    print(f"服务器已启动，正在监听 {self.ip}:{self.port}...")

​    while 1:

​      conn, addr = self.sock.accept()

​      print(f"客户端 [{addr[0]}:{addr[1]}] 已连接。")

​      while 1:

​        data = conn.recv(1024)

​        if not data:

​          break

​        received_msg = data.decode()

​        print(f"客户端 [{addr[0]}:{addr[1]}] 发送的消息：{received_msg}")

 

​      print(f"客户端 [{addr[0]}:{addr[1]}] 已断开连接。")

​      conn.close()

  def ClientU(self):

​    server_addr = (self.ip, self.port)

​    self.sock.connect(server_addr)

​    print(f"连接到服务器 {self.ip}:{self.port}...")

​    while 1:

​      message = input("请输入要发送的消息（输入 'quit' 退出）：")

​      if message == 'quit':

​        print("已退出客户端应用。")

​        break

​      self.sock.send(message.encode())

​      print("消息已发送。")

​    self.sock.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

【实例】

4、请修改题目3中的TCPTalk类，将题目1中求阶乘的函数Factorial()和m()变为TCPTalk类的成员函数，当客户端函数ClientU向服务器发送信息“1” （即ServerU函数接收到的数据为“1”）时，则ServerU调用m()。分别运行ServerU和ClientU程序，测试上述设计。

【代码】

改变后的TCPT.py

import socket
class TCPTalk:
  def __init__(self, ip, port):
    self.ip = ip
    self.port = port
    self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  def factorial(self):

​    self.n = 1

​    self.f = 1

​    while 1:

​      self.f *= self.n

​      yield (self.f)

​      self.n += 1

  def m(self):

​    self.s = set()

​    for self.f in self.factorial():

​      if self.f < 100:

​        self.s.add(self.f)

​      else:

​        break

​    print(self.s)

  def ServerU(self):
    self.sock.bind((self.ip, self.port))
    self.sock.listen(1)
    print(f"服务器已启动，正在监听 {self.ip}:{self.port}...")
    while 1:
      conn, addr = self.sock.accept()
      print(f"客户端 [{addr[0]}:{addr[1]}] 已连接。")
      while 1:
        data = conn.recv(1024)
        if not data:
          break
        received_msg = data.decode()
        print(f"客户端 [{addr[0]}:{addr[1]}] 发送的消息：{received_msg}")
        if received_msg == '1':
          result = self.m(5)  # 示例调用 m() 函数，参数为 5
          print(f"调用 m() 函数的结果：{result}")
      print(f"客户端 [{addr[0]}:{addr[1]}] 已断开连接。")
      conn.close()
  def ClientU(self):
    server_addr = (self.ip, self.port)
    self.sock.connect(server_addr)
    print(f"连接到服务器 {self.ip}:{self.port}...")
    while 1:
      message = input("请输入要发送的消息（输入 'quit' 退出）：")
      if message == 'quit':
        print("已退出客户端应用。")
        break
      self.sock.send(message.encode())
      print("消息已发送。")
    self.sock.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

【实例】