本地IP地址感觉不对，但也不知道是什么，接受的内容是其他编码，这是为什么？

老师我这代码运行的样子怎么是这样的？然后每次的样子还不一样

from time import sleep
from threading import Thread
from threading import BoundedSemaphore
def an_jian(num):
    lock.acquire()
    print(f"第{num}个人完成安检!!!")
    sleep(2)
    lock.release()


if __name__=="__main__":
    lock=BoundedSemaphore(3)
    for i in range(10):
        t=Thread(target=an_jian,args=(f"{i+1}",))
        t.start()

老师您好，在学完进程通信章节后，我的第一感觉是这种操作类似于操作文件夹。即是说，Quene是一个存储消息的“文件夹”，通过put和get来对文件夹里的内容进行储存和取出。请问可以这样理解吗？如果对您能再给补充下吗？如果不对还请老师您批评指正，谢谢！

默认子进程不共享主进程中的全局变量，当进行进程通信的时候即Queue中的信息可以共享是吗？

#encoding=utf-8

#方法方式创建线程

from threading import Thread

from time import sleep

def func1(name):

  for i in range(3):

    print(f"thread:{name} :{i}")

    sleep(1)

if __name__ == '__main__':

  print("主线程，start")

  #创建线程

  t1 = Thread(target=func1,args=("t1",))

  t2 = Thread(target=func1,args=("t2",))

  #启动线程

  t1.start()

  t2.start()

  print("主线程，end")

'''

运行结果可能会出现换行问题，是因为多个线程抢夺控制台输出的IO流。

比如，如下的输出换行就没有按照预想的显示：

主线程，start

thread:t1 :0

thread:t2 :0

主线程，end

thread:t2 :1thread:t1 :1

thread:t2 :2

thread:t1 :2

'''

老师 还有我不太理解这个逻辑顺序

一、代码

#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 = 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(3):
                    msg = self.name + "消费了" + q.get()
                    print(msg)
            time.sleep(1)


if __name__ == "__main__":
    q = Queue()
    for i in range(500):
        q.put("初始产品"+str(i))
    for i in range(2):
        p = Pro()
        p.start()
    for i in range(5):
        c = Con()
        c.start()

二、问题

1、

上述产生数据的两个进程是同时运行的还是一个运行完再运行下一个？

如其同时运行，当第一个进程已经往池中写入“生成产品1”，第二个进程还可以往里面写入“生成产品1”吗？

Queue   怎么删除里面的数据呢？

比如：
q=Queue()
q.put(1)
q.put(2)
q.put(3)
如何删除3呢？

from threading import Thread
from time import sleep

# 类实现-多线程
class MyThread(Thread):
    def __init__(self,name):
        Thread.__init__(self)
        self.name = name

    def run(self):
        print(f"Threading:{self.name} start")
        sleep(3)
if __name__ == "__main__":
    
    # 创建线程
    t1 = MyThread('t1')
    t2 = MyThread('t2')

    # 启动线程
    t1.start()
    t2.start()

老师我看了好多类的继承这样的写法，在子类的构造方法里都会调用父类的构造方法，这是固定写法吗？

如果是的话换成用super()去调用这样写可以吗？

"!H5sb5sb" #这个是正则表达式吗？？？

老师你好，请问转换后发生乱码怎么处理呢？

import struct
from socket import *
filename = 'zzbds.azw3'
server_ip = '100.98.57.142'
send_data = struct.pack('!H%dsb5sb' % len(filename), 1, filename.encode(), 0, 'octet'.encode(), 0)
s = socket(AF_INET, SOCK_DGRAM)
s.sendto(send_data, (server_ip, 69))
f = open('f:\\1\\a.txt', 'ab')    # a代表以追加模式打开，b代表以二进制模式打开  'f:\1\a.png'

while True:
    recv_data = s.recvfrom(2048)    # 接受数据
    caozuoma, ack_num = struct.unpack('!HH', recv_data[0][:4])  # 获取数据模块
    rand_port = recv_data[1][1]     # 随机获取服务器端口
    if int(caozuoma) == 5:
        print('文件不存在...')
        break
    print("操作码: %d, ACK: %d, 服务器随机端口：%d,数据长度: %d" % (caozuoma, ack_num, rand_port, len(recv_data[0])))
    f.write(recv_data[0][4:])   # 将数据写入
    if len(recv_data[0]) < 516:
        break
    ack_data = struct.pack("!HH", 4, ack_num)
    s.sendto(ack_data, (server_ip, rand_port))  # 回复ACK确认包

老师我这个是因为什么啊？

NameError: name 'socket' is not defined

pw.join()和pr.join()如果都放在最后，根据老师所讲，由于sleep（1）的影响，程序是不是也能正常执行？结构是一样的？

老师这里创建了g1,g2对象，为什么上面不用g1.sleep(1)这样子？？？？？？？？？？？？？？

老师我想问一下视频里快速导入是怎么实现的？

map这个，能用类写吗？我去网上查过，实在没找到用类的写范例，不知道能不能用类写。