老师，您好，就是这章节的哪两个软件怎么下载啊？那个网络通信的和那个Tftpd 32 by phJounin.

我去百度下载Tftpd 32 by phJounin后直接是流氓软件。。。

然后现在就是看完视频敲完代码也是懵逼状态，代码没有运行成老师讲解的那样子。

老师，下面的callback回调函数的作用是什么？写与不写的区别在哪里？好像不影响进程的效率

p.apply_async(func=func1, args=(f"p{i+1}", ), callback=func2)

老师。你这里是怎么实现选择全部输入#号的？具体的操作步骤是什么??

from multiprocessing import Process
num = 1
def run1():
    global num
    num += 15
    print("子进程1的数字是：%d"%num)
def run2():
    global num
    num += 100
    print("子进程2的数字是：%d"%num)

if __name__ == '__main__':
    print("父进程启动")
    p = Process(target=run1, name="one1")
    p1 = Process(target=run2, name="two2")
    print("开始执行子程序")
    p.start()
    p1.start()
    p.join()
    p1.join()
    print(num)
    print("进程结束")

老师，我运算的结果，为什么是这样的？

#coding=utf-8
from threading import Thread
from time import sleep,time
#创建方法
def func1(name):
    print(f"threading:{name}start")
    sleep(3)
    print(f"threading:{name}end")
if __name__ == '__main__':
    #启动时间
    start = time()

    t_list = []
    for i in range(10):
        t = Thread(target=func1, args=(f"t{i+1}",))
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    end = time()-start
    print(end)
    
#coding=utf-8
from threading import Thread
from time import sleep,time
import threading
class MyThread(Thread):
    def __init__(self,name):
        Thread.__init__(self)
        self.name = name

    def run(self):
        print()
        print(f"threading:{self.name}start")
        sleep(3)
        print(f"threading:{self.name}end")
if __name__ == '__main__':

    start = time()
    t_list = []
    for i in range(10):
        t = MyThread(f"t{i+1}")
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    end = time()-start
    print(end)

哪些是主进程哪些是子进程,哪些是主线程哪些是子线程.

有点搞不清楚有点乱

请问下 print（f‘（门开着。。。{}号人进入））里的f是什么意思

老师比如这里不给飞秋发内容，给微信，QQ发要怎么整？？？？？？协议又不一样了是吧？？？？？？？？？？？？？

老师，这些进程，都是做什么用的？学这些，的目的是什么？

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 方法是怎么调用的？什么时候调用的？

老师，请问，因为IP类型不同，IP地址的所在的范围也不同，所以我们通过判断IP地址的范围就可以确认它是那种类型的IP，进而能判断哪几个字节是网络号，哪几个是主机号。那为什么还要设立子网掩码来区分网络号和主机号呢？或者说这种‘区分’在计算机里的操作是什么样的呢？

老师 还有视频中说协程自身带有上下文和栈 这个怎么理解？ 

from socket import *
s = socket(AF_INET, SOCK_DGRAM) #创建套接字
addr = ('192.168.1.17', 8080) #准备接收方地址
data = input("请输入：")
s.sendto(data.encode(),addr)
#发送数据时，python3需要将字符串转成byte
#encode(‘utf-8’)# 用utf-8对数据进行编码，获得bytes类型对象
#decode（）反过来
s.close()

C:\Users\pcl\venv\Scripts\python.exe "C:/Users/pcl/.1aPython all exercise/网络通信/UDP发送.py"

Traceback (most recent call last):

  File "C:\Users\pcl\.1aPython all exercise\网络通信\UDP发送.py", line 1, in <module>

    from socket import *

  File "C:\Users\pcl\.1aPython all exercise\网络通信\socket.py", line 3, in <module>

    s=socket(socket.AF_INET,socket.SOCK_STREAM)

AttributeError: partially initialized module 'socket' has no attribute 'AF_INET' (most likely due to a circular import)

Process finished with exit code 1

老师 这个为什么会报错啊

#进程间通信---Queue
#通过Queue（队列Q）可以实现进程间的数据传递
#Q本身是一个消息队列

from multiprocessing import Process
from multiprocessing import Pool
from multiprocessing import Queue

def run1(q):
    q.put("消息")
    q.put("消息")

def run2(q):
    print(q.qsize())
    print(q.get())
    print(q.qsize())

if __name__ == "__main__":
    q = Queue(3)
    p1 = Process(target=run1,args=(q,))
    p2 = Process(target=run2,args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

请问老师，我按照课程写的，这个锁为啥实现不了？

#进程池创建进程
#进程池是用来创建成百上千的多个进程

from multiprocessing import Pool
import random,time

def work(num):
    print(random.random()*num)
    time.sleep(3)

if __name__ == "__main__":
    po = Pool(3)    #定义一个进程池，最大进程数为3，默认大小为CPU核数
    for i in range(10):
        po.apply_async(work,(i,))   #apply_async选择要调用，每次循环会用空出来的子进程去调用目标
    po.close()    #进程池关闭之后不再接收新的请求，但是之前已经接收的请求会执行完
    po.join()     #等待po中所有子进程结束，必须放在close后面

#在多进程中：主进程一般用来等待，真正的任务都在子进程中执行

为什么按着代码敲完，运行的时候没有结果，程序也一直在运行中