如下图，如果上边没有import的话；__name__== '__main__'这种形式就会引用其里边包含的内容，但是既然有了上边的import，为什么__name__== '__main__'里边的内容还在被用？

老师，您看下下面的代码：

from concurrent.futures import ThreadPoolExecutor

def foo(count):
    if count > 5:
        print('验证中')
        count = 0
    print('可以了')
    count += 1
alist = [i for i in range(20)]
count = 0
pool = ThreadPoolExecutor(max_workers=5)
pool.map(foo, alist)

执行结果：

可以了 可以了 可以了 可以了 可以了 可以了 验证中 验证中 验证中 验证中 可以了 验证中 可以了 可以了 可以了 验证中可以了 验证中 验证中 验证中 可以了 验证中 可以了 可以了 可以了 验证中 可以了

上面的代码开启了5个线程，当一个进程执行过‘验证中’后，count变为0了，可是后面的进程又重复执行了‘验证中’，改怎么告诉后面的进程count已经变为0，直接执行‘可以了’，麻烦老师了！

老师这个RLock是不是就是系统自动帮你调节，避免出现死锁的情况，也就是说当我只创建了一个锁的对象时，而这个锁恰好又被多个对象使用，导致锁不够用成了死结，而RLock就是调节当锁不够用的时候避免出现死结的方法，还可以让线程继续运行下去。

老师从哪里可以看最多可以一次进行多少个线程啊？如果系统一共能开8个线程我开了4个，他们和开一个的效率一样吗？

为什么到sxt4就不回调了

老师        在最前面打印#coding=utf-8  和#encoding=utf-8  有啥区别吗

老师，一个类继续另外一个类不应该是在初始化中显式调用吗？

老师我的代码运行了没报错，但是也没有打印东西出来，麻烦帮我看下

from socket import *
import struct
filename='timg.jpg'
server_ip='192.168.31.158'  # 搭载服务器的主机地址
send_data=struct.pack('H%dsb5sb'%len(filename),1,filename.encode(),0,b'octet',0)
s=socket(AF_INET,SOCK_DGRAM)  # 创建套接字对象
s.sendto(send_data,(server_ip,69)) # 69为默认端口
f=open(filename,'ab')
while True:
   recv_data=s.recvfrom(1024)
   caozuoma,ack_num=struct.unpack('!HH',recv_data[0][:-4]) # 获取数据块编号
   rand_port=recv_data[1][1] # 获取服务器的随机端口
   if int(caozuoma)==5:  # 若数据块编号为5，说明传输错误
       print('文件不存在....')
       break
   print('操作码：%d，ACK:%d，服务器随机端口：%d，数据长度：%d'%(caozuoma,ask_num,rand_port,len(recv_data)))
   f.write(recv_data[0][4:])
   if len(recv_data[0])<516:  # 若数据包长度小于516，说明数据下载完成
       break   
   ack_data=struct.unpack('!HH',4,ack_num) # 发送确认包
   s.sendto(ack_data,(server_ip,rand_port)) # 回复ACK确认包

老师

为什么这个 t1设为守护线程但是没用 

这个t1.daemon=True为啥一定要在t1.start()前面

# coding=utf-8
from threading import Thread
import time

def threading_test(name):
    i=500000000
    q=1
    for a in range(i):
        q = q+a
    #print(q)
    #print(f'任务{name}执行完')


t1= Thread(target=threading_test,args=('t1',))
t2= Thread(target=threading_test,args=('t2',))

s1=time.time()

t1.start()
t2.start()
t1.join()
t2.join()
s2=time.time()
print('多线程时间是',s2-s1)



s3=time.time()
t3 = threading_test('t3')
t4 = threading_test('t4')
s4= time.time()
print('普通时间是',s4-s3)

老师你好，这个代码为了测试多线程和串行的时间，运行结果如下：

一个81s,一个88s,感觉区别也不大嘛，是我代码设置的时间截取不对么还是什么什么问题？

谢谢老师

老师，为什么queue队列没有传入生产函数和消费函数中也能被函数修改？

from queue import Queue
from threading import Thread, Lock, Semaphore
from time import sleep


def producer():
    print("开始生产")
    n=1
    while True:
        if queue.qsize() < 5:
            queue.put(f"生产{n}号")
            print(f"生产{n}号")
            n+=1
        else:
            print("已满")
            sleep(5)
def cons():
    print("开始消费")
    while True:
        if queue.qsize() >= 0:
            print(f"获取{queue.get()}")
            sleep(1)

if __name__ == '__main__':
    queue = Queue()
    a = Thread(target=producer)
    b = Thread(target=cons)
    a.start()
    b.start()

没忍不住，键盘也太好了，声音好大    = =

老师好，我想每次都输入扩展名太麻烦了，就想不输入扩展名，我是这样写的，您看这个为啥会这样呢，麻烦了！

运行不出来是为啥

老师，现在啥情况，8888好像用不了了，有什么办法可以关掉它吗