老师 执行第7行之后 就跳到func1这个函数里开始执行  执行到第4行的时候 卡住了 

然后跳到第8行 第8行接收了第3行的北京打印第0次数据   存储起来

接着开始执行第9行 第10行 

第11行 接着上次存储的 继续开始打印 北京打印第1次数据 

然后回到第9行 在开始新的一轮循环 

这个是这样理解吗 老师

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

老师 对于协程是怎么工作的 还是有些不理解 例如这里有个单线程 它里边创建了3个协程  但是现在这里有5个任务  那这三个协程是怎么工作的   

请问协程不是在IO的时候会切换到另一任务吗，为什么缺点里却又会阻塞整个程序？ 老师 这样把这个问题解释详细一点吗 

老师 关于这个协程  视频中老师讲的遇到IO就会停止运行 或者切换到下一个任务 这个IO是指什么

import os
from multiprocessing import Pool
from time import sleep

def func1(name):
    print(f"当前的进程ID:{os.getpid()},{name}")
    sleep(3)
if __name__ =="__main__":
    pool=Pool(5)
    pool.apply_async(func=func1,args=("jhy1",))
    pool.apply_async(func=func1,args=("jhy2",))
    pool.apply_async(func=func1,args=("jhy3",))
    pool.apply_async(func=func1,args=("jhy4",))
    pool.apply_async(func=func1,args=("jhy5",))
    pool.apply_async(func=func1,args=("jhy6",))
    pool.apply_async(func=func1,args=("jhy7",))
    pool.apply_async(func=func1,args=("jhy8",))

    pool.close()
    pool.join()

老师 关于这个进程池就是 池子里一共有5个进程 然后来了8个任务 每个任务都是去调用func1这个函数   先是5个去执行 然后是剩下的3个去执行  这些进程之间是异步执行  同时在进行  不用回收 不用开辟空间 这样节省效率  这样理解对吗

from multiprocessing import Process,current_process 
import os
from multiprocessing import Manager

def func1(name,m_dict,m_list):
    print("子进程ID{}获取了数据：{}".format(os.getpid(),m_list))
    print("子进程ID{}获取了数据：{}".format(os.getpid(),m_dict))
    m_list.append("姬昊余") #这里可以从子进程中往主进程里写
    m_dict["你好"]="吕倩倩"
if __name__=="__main__":
    print("主进程ID：{}".format(current_process().pid))
    #print("进程ID：{}".format(os.getpid()))
    with Manager() as mgr: #开启一个网络的端
        m_list=mgr.list() #创建一个列表
        m_dict=mgr.dict() #创建一个字典
        m_list.append("hello") #列表中添加数据
        p1=Process(target=func1,args=("p1",m_dict,m_list)) #也需要将容器传给子进程  
        p1.start()
        p1.join()
        print(m_dict)
        print(m_list)

老师 关于这个with 这里为什么要使用with 有点不理解 为什么不能之间创建共享数据对象

from threading import Thread
from queue import Queue
from time import sleep
def produce():
    num=1
    while True:
        if mq.qsize()<10:  #控制数量
            print(f"生产了{num}号加菲猫")
            mq.put(f"{num}号加菲猫")
            num +=1 
        sleep(1)
def consumer():
    while True:
        print("购买了{}".format(mq.get()))
        sleep(2)
if __name__=="__main__":
#共享数据的容器
    mq = Queue()
#创建生产者线程
t1=Thread(target=produce)
#创建消费者线程
t2=Thread(target=consumer)
#开始工作
t1.start()
t2.start()

老师 关于生产者和消费者模式 我想问一下   两个线程 一个往队列里存放数据 另一个从队列里取数据 这个模式的意义就是在这两个线程中增加了一个队列 用来控制线程之间的平衡 可以这样理解吗

Python中的多线程是假线程，那为什么还有多线程这个概念，还有为什么有时候Python多线程就是比非多线程编程快?

from threading import Thread
from time import sleep, time


def func():
    global count
    for i in range(10000):
        count += 1


count = 0
start = time()
# for i in range(10):
#     t = Thread(target=func)
#     t.start()
# print(f"count = {count}")
for i in range(10):
    func()
print(f"count = {count}")
end = time() - start
print(end)

老师，注释内容和后续循环都能正确打印出结果，但是我发现打印出来的时间反而是多线程耗时更多一点，多次运行后发现要么是多线程运行耗时多，要么二者速度差不多。这样的话Python的多线程还有什么意义呢，没感觉到效率的提升啊。

from socket import *
s = socket(AF_INET, SOCK_DGRAM)
s.sendto("钟呢呢".encode("gb2312"), ("192.168.145.1", 8080))

请问同步执行和异步执行是什么？有什么区别？

请问协程不是在IO的时候会切换到另一任务吗，为什么缺点里却又会阻塞整个程序？

老师我这吧下载的网络助手显示乱码，是我电脑设置的问题吗

from socket import *

tcpsock=socket(AF_INET,SOCK_STREAM)
tcpsock.bind(("",8899))  #  默认本机ip
tcpsock.listen(5)   #  最多有5个人可以排队
newsock,clientaddr = tcpsock.accept()   #  返回一个新的套接字对象(空出用于接收连接请求的端口)，连接方地址
data = newsock.recv(1024)  # 注意在tcp里不是recvfrom，是recv
print(data)

newsock.send("xiexie")   # 方法是send，在做三次握手的时候已经建立了稳定的连接

newsock.close()

tcpsock.close()  #  关闭作为监听的套接字

from socket import *
clientsock=socket(AF_INET,SOCK_STREAM)
clientsock.connect(("192.168.1.1",8899))  #  客户端同样要用7788端口,连接服务器
clientsock.send("nihao")
data = clientsock.recv(1024)
print(data)
clientsock.close()

先运行服务器，再运行客户端没有反应，或者提示通常每个套接字地址(协议/网络地址/端口)只允许使用一次。