老师，我跟着老师一样命名的gevent模块,为啥会报错？

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)
        print(f'Threading：{self.name} end')


if __name__ == '__main__':
    for i in range(20):
        t = MyThread(f't{i+1}')
        t.setDaemon(True)     # 设置当前线程为守护线程，值默认为 False
        t.start()

    print('主线程结束了！！！')

老师，我还是不太理解这个程序中语句的执行顺序。

我在 if __name__ == '__main__'  这条语句前打断点，发现该程序语句执行顺序如下：

1、执行  for i in range(20)                #  i = 0
2、执行  t = MyThread(f't{i+1}')       #  t = t1

3、执行 def __init__(self, name)

4、执行 Thread.__init__(self)
5、执行 slef.name = name

6、执行  for i in range(20)                #  i = 1

......

7、循环结束，执行 print('主线程结束了！！！')

问题：

1、程序是从上往下执行的，所以首先应该是创建类对象，这个类对象代表的是类 MyThrad 的结构，里面包含实例方法 run 。然后进入程序入口，执行 for 循环里的语句，执行  t = MyThread(f't{i+1}') 语句时，会先调用 __new__() 方法创建一个实例对象，再用 __init__() 方法初始化这个实例对象，其中实例对象里也有实例属性和 run 方法。我这样理解是对的吗？

2、按照我打断点后语句的执行顺序，并没有发现执行 run 方法。请问老师，这个 run 方法是怎么调用的？什么时候调用的？

老师，这节课里老师说的以及里面的注释一会儿进程，一会儿线程的，我看下面同学的您的回答也是，有些是线程，有些就变成了进程。请问这节课到底讲的是进程还是线程？

from threading import Thread
import threading
from time import time,sleep


def func(name):
    print(threading.currentThread())     # 查看当前进线程
    print(f'Threading:{name} start')
    sleep(3)
    print(f'Threading:{name} end')


if __name__ == '__main__':
    print(threading.currentThread())  # 查看当前进线程
    startTime = time()
    threadList = []
    for i in range(10):
        t = Thread(target=func, args=(f't{i+1}',))
        t.start()
        threadList.append(t)

    for t in threadList:
        t.join()     

    endTime = time()
    print(f'运行时间为：{endTime-startTime}')

问题：

在上一节课里老师讲到，t.join() 方法不能直接放在 t.start() 后面。但是在这节课里面，通过两个循环。第一个循环先生成了线程 t1-t10，生成了线程列表（threadList）后，通过第二个循环遍历线程列表，这个遍历不是在每个线程后加 t.join() 么，这样不就矛盾了吗？虽然结果没有问题，但迷糊了，麻烦老师解释一下。谢谢~

from threading import Thread
from time import sleep
import time


# 创建普通方法
def func(name):
    print(f'Threading:{name} start')
    sleep(3)     # 执行完上一语句后睡眠 3s


# 创建线程
# target 属性是告诉线程要调用哪个方法，args 属性把参数传进去。即 args 是目标调用的参数元组，默认为空元组 ()
t1 = Thread(target=func, args=('t1',))
t2 = Thread(target=func, args=('t2',))

# 开启线程，通过 start() 方法
time01 = time.time()
t1.start()
t2.start()
time02 = time.time()
print(f'通过start()开启线程的时间是：{time02-time01}')


# 正常通过函数调用执行
time03 = time.time()
func('t1')
func('t2')
time04 = time.time()
print(f'通过函数调用执行的时间是：{time04-time03}')

运行结果：

问题：

1、多线程方式执行是 t1 和 t2 同时执行，也调用了函数 func，执行了里面的语句。那么多线程执行的时间不应该是 3 秒多一点吗？

2、正常调用函数执行时是 func('t1')，传参数时为什么要给 t1 和 t2 加引号？

老师，我的问题都写在图片中了，视频老师只是在任务中添加了一个协程compute（x,y），如果放入多个协程该怎么弄？麻烦解答一下

#  coding=utf-8
# 死锁

from threading import Lock

def func1():
    lock.acquire()
    print('func1拿到锁')
    func2()
    lock.release
    print('func1释放锁')

def func2():
    lock.acquire
    print('func2拿到锁')
    lock.release
    print('func2释放锁')

def func3():
    func1()
    func2()

if __name__=='__main__':
    lock = Lock()
    func3()

老师，我在测试锁死的情况时，并未出现锁死现象，func1和func2都拿到了锁，这是为什么？

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

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确认包

您好，老师，这个为啥报错？内容和老师讲的一样敲的。

老师为什么我再vscode上不能同时运行两个文件的？是软件的问题吗？

发送方：

from socket import *
s=socket(AF_INET,SOCK_DGRAM)
s.bind(('',7758))
date=input('请输入要发送的内容：')
s.sendto(date.encode('gb2312'),('192.168.31.158',8585))
redata=s.recvfrom(1024)  # 2048代表最大接受的字节
print(redata[0].decode('gb2312'))
s.close()

接收方：

from socket import *
udpSock=socket(AF_INET,SOCK_DGRAM)
udpSock.bind(('',8585))
while True:
    recvData=udpSock.recvfrom(1024)
    udpSock.sendto(recvData[0],recvData[1])

udpSock.close()

老师你看下为什么会报错？结果是正确的，当把f.send(3)注释掉，程序就正常，但是一旦传参进去就报错了，结果还是正确的

def func1():
    print("starting.......")
    n=yield 2
    print(n)


if __name__ == '__main__':
    f=func1()
    #next(f)
    print(next(f))
    f.send(3)    #当把f.send(3)注释掉，程序就正常，但是一旦传参进去就报错了，结果还是正确的
    #print(f)

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

老师，我的电脑配置是8核16线程的，我把进程池设置为17个，每个进程sleep（2），视频老师说进程池里的数量不能随便写，最多就是自己电脑的cpu数，我这明显超过电脑cpu了，但是感觉17个进程是同时完成的。

from multiprocessing import Pool, Process
from time import sleep


def func1(name):
    a=0
    print(f"进程{name}的工作")
    for i in range(1000000):
        a+=i
    print(a)
    sleep(2)


if __name__ == '__main__':
    pool = Pool(17)
    pool.apply_async(func=func1, args=("xue1",))
    pool.apply_async(func=func1, args=("xue2",))
    pool.apply_async(func=func1, args=("xue3",))
    pool.apply_async(func=func1, args=("xue4",))
    pool.apply_async(func=func1, args=("xue5",))
    pool.apply_async(func=func1, args=("xue6",))
    pool.apply_async(func=func1, args=("xue7",))
    pool.apply_async(func=func1, args=("xue8",))
    pool.apply_async(func=func1, args=("xue9",))
    pool.apply_async(func=func1, args=("xue10",))
    pool.apply_async(func=func1, args=("xue11",))
    pool.apply_async(func=func1, args=("xue12",))
    pool.apply_async(func=func1, args=("xue13",))
    pool.apply_async(func=func1, args=("xue14",))
    pool.apply_async(func=func1, args=("xue15",))
    pool.apply_async(func=func1, args=("xue16",))
    pool.apply_async(func=func1, args=("xue17",))
    pool.close()
    pool.join()

老师你好，为什么要调用Thread的初始化方法啊？作用是什么?

它和super()的作用有什么区别吗？

请问老师，在PriorityQueue中，数字间、字符串间、元组间、列表间均可以进行优先级比较，为什么字典不行，把字典的“键”均设成数字也不能进行优先级比较，是因为字典是无序的原因吗？