发送方1：

from socket import *

s=socket(AF_INET,SOCK_DGRAM)
s.bind(('',8888))


s.sendto(b'sxt',('192.168.101.2',8090))

redata = s.recvfrom(1024)
print(redata[0].decode())

接受方：

from socket import *

udpSock=socket(AF_INET,SOCK_DGRAM)
udpSock.bind(('',8090))
while True:
    redata = udpSock.recvfrom(1024)
    udpSock.sendto(redata[0],redata[1])
udpSock.close()

vscode运行：

请问用vscode怎么才能运行，求解？

from socket import *
from threading import Thread


def recv_data():
    while True:
        recv_data = client_socket.recv(1024)  # 最大接受1024字节
        print(f'客户端说:{recv_data.decode("gbk")},来自:{client_info}')
        if recv_data == 'end':
            break
def send_data():
    while True:
        msg = input('>')
        client_socket.send(msg.encode('gbk'))

if __name__=='__main__':
    server_socket = socket(AF_INET, SOCK_STREAM)  # 创建TCP套接字
    server_socket.bind(('127.0.0.1', 9999))  # 本机监听8899端口
    server_socket.listen(5)
    print('等待接受连接')
    client_socket, client_info = server_socket.accept()
    print('一个客户端建立连接成功')
    t1 = Thread(target=recv_data())
    t2 = Thread(target=send_data())
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    client_socket.close()
    server_socket.close()
    
    
    
    
    
from socket import *
from threading import Thread


def recv_data():
    while True:
        # 接收服务端数据
        recv_data = client_socket.recv(1024)  # 最大接收1024字节
        print(f'服务器端说:{recv_data.decode("gbk")}')
def send_data():
    while True:
        # 给服务端发消息
        msg = input('>')
        client_socket.send(msg.encode("gbk"))
        if msg == 'end':
            break
if __name__=='__main__':
    client_socket = socket(AF_INET, SOCK_STREAM)
    client_socket.connect(('127.0.0.1', 9999))
    t1 = Thread(target=recv_data())
    t2 = Thread(target=send_data())
    t1.start()
    t2.start()
    t1.join()
    t2.join()


    client_socket.close()

发不了也接不了消息

主进程创建子进程，那子进程可以创建子进程吗，还是子进程下吗没有了，就只有多个线程了呢？

怎么我的线程数是奇数，不是连续的数字吗，，，，，，

老师，我想请问为什么同样的结构，文件名为英文名就可以成功，文件名为中文名就会报错：

代码：

from socket import *
import struct

fileName = '焰灵姬.jpg'
adrr = '192.168.0.107'
cmb_buf = struct.pack('!H%dsb5sb'%len(fileName),1,fileName.encode('gbk'),0,'octet'.encode('gbk'),0)
s = socket(AF_INET,SOCK_DGRAM)
s.sendto(cmb_buf,(adrr,69))
f = open(fileName,'ab')
while True:
    recvdata = s.recvfrom(1024)
    caozuoma,ack_number = struct.unpack('!HH',recvdata[0][:4])
    rand_port = recvdata[1][1]
    if int(caozuoma) == 5:
        print('文件出错')
        break
    f.write(recvdata[0][4:])
    if len(recvdata[0]) < 516:
        print('文件传输完毕')
        break
    ack_data = struct.pack('!HH',4,ack_number)
    s.sendto(ack_data,(adrr,rand_port))

老师，请问with的用法是什么意思呢？在这儿写起什么作用呀？下面的两行是什么意思呢？

multiprocessing.current_process().pid

和os.getpid的作用是一样的吧

为什么我的跟老师的不一样，我的没有老师说的那个问题

老师我怎么感觉我的VScode怪怪的要全选才可以把代码运行，直接运行就报错

老师，前面视频里讲过，一个进程中的线程共享相同的内存单元，也就意味着上图中三个num都是同一个地址，为什么还会存在运算了num+1，但没有赋值，就切换到下一个线程的情况呢，运算和赋值不就是在一个地址上加1，不存在变量引用的情况，为什么还不是同时进行的？

老师，为什么会有这么多的警告的100个警告

from socket import*
import struct
fine = "mei.jpg"
cmb_buf = struct.pack('!H%dsb5sb' % len(fine), 1, fine.encode(), 0, "octet".encode(), 0)
udpSock = socket(AF_INET,SOCK_DGRAM)
udpSock.sendto(cmb_buf,("127.0.0.1",69))
f = open(fine,"ab")   #以追加模式打开，没有了创建文件夹
while True:
    recv_date = udpSock.recvfrom(1024)   #接收数据
    caozuoma, ack_num = struct.unpack("!HH",recv_date[0][:4])  #获取数据编号
    rand_port = recv_date[1][1]    #获取服务器随机端口
    if int(caozuoma) == 5:
        print("文件不存在")
        break
    print("操作码：%d,ACK: %d,服务器随机端口：%d,数据长度：%d"%(caozuoma, ack_num, rand_port, len(recv_date[0])))
    f.write(recv_date[0][4:])  #将数据写入
    if len(recv_date[0]) < 516:
        break
    ack_date = struct.pack("!HH", 4, ack_num)
    udpSock.sendto(ack_date, (cmb_buf, rand_port))

老师，什么错误

# coding=utf-8

import threading
import time
from queue import Queue

class Pro(threading.Thread):
    def run(self):
        global q
        count = 0
        while True:
            if q.qsize()<1000:
                for i in range(100):
                    count += 1
                    msg = "生产"+str(count)
                    q.put(msg) # 往队列中添加新产品
                    print(msg)
            time.sleep(1)


class Con(threading.Thread):
    def run(self):
        global q
        while True:
            if q.qsize() > 100:
                for i in range(150):
                    msg = self.name+"消费"+q.get()
                    print(msg)
            time.sleep(1)


if __name__ == '__main__':
    q = Queue() # 创建队列，线程中能使用
    for i in range(500): # 放500个初始产品
        q.put("初始产品"+str(i))
    for i in range(2): # 两个生产者
        p = Pro()
        p.start()
    for i in range(5):  # 五个消费者
        c = Con()
        c.start()

老师，我给生产者设置的遍历区间是range(100)，给消费者设置的是range(150)，为什么消费者不能消耗完队列里面的产品，程序一会在执行。还有就是为什么要放入初始500个产品。

from queue import Queue
from time import sleep
from threading import Thread

def producer():
    num = 1
    while True:
        if queue.qsize() < 5:
            print(f'生产{num}号，大馒头')
            queue.put(f'大馒头：{num}号')
            num += 1
        else:
            print('馒头框满了，等待来人消费')
        sleep(1)

def consumer():
    while True:
        print(f'获取馒头：{queue.get()}')
        sleep(1)

if __name__ == '__main__':
    queue = Queue()
    t1 = Thread(target=producer)
    t2 = Thread(target=consumer)
    t1.start()
    t2.start()

老师，那个qsize函数是什么意思，为什么我的程序超过五个了还在运行

是不是主进程关闭前，进程池内的进程只需要创建一次，后面新进程调用的是相同的方法，则会调用之前的进程；

问一个问题，进程池内只能容纳5个进程，超出5个的进程调用的方法与之前的不一致，是不是会删除已在池内，但是当前状态未被调用的进程，然后再新建一个