粘包3

 1 from socket import *
 2 import subprocess
 3 
 4 tcp_server = socket(AF_INET, SOCK_STREAM)
 5 tcp_server.bind((‘127.0.0.1‘, 8080))
 6 tcp_server.listen(128)
 7 while True:
 8     print(‘等待新用户连接‘)
 9     coon, addr = tcp_server.accept()
10     print(‘新的客户端连接：‘, addr)
11     while True:
12         try:
13             cmd = coon.recv(1024)
14             print(‘执行的命令为‘, cmd.decode())
15             res = subprocess.Popen(cmd.decode(), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
16                                    stdin=subprocess.PIPE)
17             err = res.stderr.read()
18             if err:
19                 cmd_res = err
20             else:
21                 cmd_res = res.stdout.read()
22             if not cmd_res:
23                 cmd_res = ‘执行成功‘.encode(‘GBK‘)
24             length = len(cmd_res)  # 计算字节的长度，长度为整型
25             coon.send(str(length).encode())  # 将字节的长度发送给客户端，注意需将整型变为字符串后在转化为字节发送。
26             begin_start = coon.recv(1024)
27             if begin_start.decode() == ‘开始接收‘:
28                 coon.send(cmd_res)
29 
30         except Exception as f:
31             break
32 
33     coon.close()

 1 from socket import *
 2 
 3 tcp_client = socket(AF_INET, SOCK_STREAM)
 4 tcp_client.connect((‘127.0.0.1‘, 8080))
 5 while True:
 6     cmd = input(‘请输入指令：‘).strip()
 7     if not cmd: continue
 8     if cmd == ‘quit‘: break
 9     tcp_client.send(cmd.encode())
10     num = tcp_client.recv(1024)  # 收到的服务端发来的字节长度，注意此时为字节
11     tcp_client.send(‘开始接收‘.encode())
12     num = int(num.decode())  # 将字节变为字符串（此字符串为整型字符串），然后变为整型
13     recv_size = 0
14     data = b‘‘
15     while recv_size < num:  # 比较收到字节长度和本来长度进行比较
16         data += tcp_client.recv(102)  # 收到的字节进行拼接
17         recv_size = len(data)  # 计算收到字节的长度
18     print(data.decode(‘gbk‘))  # 最后将收到的字节进行解码打印。

 1 from socket import *
 2 import subprocess
 3 import struct
 4 tcp_server = socket(AF_INET, SOCK_STREAM)
 5 tcp_server.bind((‘127.0.0.1‘, 8080))
 6 tcp_server.listen(128)
 7 while True:
 8     print(‘等待新用户连接‘)
 9     coon, addr = tcp_server.accept()
10     print(‘新的客户端连接：‘, addr)
11     while True:
12         try:
13             cmd = coon.recv(1024)
14             print(‘执行的命令为‘, cmd.decode())
15             res = subprocess.Popen(cmd.decode(), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
16                                    stdin=subprocess.PIPE)
17             err = res.stderr.read()
18             if err:
19                 cmd_res = err
20             else:
21                 cmd_res = res.stdout.read()
22             if not cmd_res:
23                 cmd_res = ‘执行成功‘.encode(‘GBK‘)
24             length = len(cmd_res)  # 计算字节的长度，长度为整型
25             # coon.send(str(length).encode())  # 将字节的长度发送给客户端，注意需将整型变为字符串后在转化为字节发送。
26             # coon.send(struct.pack(‘i‘,length))
27             length = struct.pack(‘i‘,length)
28             coon.send(length)
29             begin_start = coon.recv(1024)
30             if begin_start.decode() == ‘开始接收‘:
31                 coon.send(cmd_res)
32 
33         except Exception as f:
34             break
35 
36     coon.close()

 1 from socket import *
 2 import struct
 3 tcp_client = socket(AF_INET, SOCK_STREAM)
 4 tcp_client.connect((‘127.0.0.1‘, 8080))
 5 while True:
 6     cmd = input(‘请输入指令：‘).strip()
 7     if not cmd: continue
 8     if cmd == ‘quit‘: break
 9     tcp_client.send(cmd.encode())
10     num = tcp_client.recv(1024)  # 收到的服务端发来的字节长度，注意此时为字节
11     tcp_client.send(‘开始接收‘.encode())
12     # num = int(num.decode())  # 将字节变为字符串（此字符串为整型字符串），然后变为整型
13     num = struct.unpack(‘i‘,num)[0]
14     recv_size = 0
15     data = b‘‘
16     while recv_size < num:  # 比较收到字节长度和本来长度进行比较
17         data += tcp_client.recv(102)  # 收到的字节进行拼接
18         recv_size = len(data)  # 计算收到字节的长度
19     print(data.decode(‘gbk‘))  # 最后将收到的字节进行解码打印。

 1 from functools import partial  # 偏函数
 2 
 3 
 4 def add(x, y):
 5     return x + y
 6 
 7 
 8 func = partial(add, 1)  # 偏函数可以固定一个函数的第一个值
 9 print(func(1))
10 print(func(5))
11 l = [1, 2, 3, 4, 5, 6]
12 
13 
14 def test():
15     return l.pop()
16 
17 
18 f = iter(test, 4)
19 print(f.__next__())
20 print(f.__next__())
21 print(f.__next__())