这里为什么要用循环啊，不太

明白

老师必须用vs吗

老师好 pycharm里面没有greenlet模块怎么操作呢

老师你好！我想知道向服务器发送确认的这部分代码为什么是放在判断是否最后一次数据传送的后面呢？如果这样，break停止整个循环，最后小于516字节的那一部分就不需要发送ACK确认信息了吗？那这样服务器怎么判定数据包是否丢失呢？

老师print（m_list）放在with manager里和外得出的结论是不一样的

放在with manager外的话代表的是什么，区别是什么

async def compute(x, y):
    print(f'compute:{x}+{y}....')
    await asyncio.sleep(1)
    return x+y


async def print_sum(x, y):
    # 创建task
    task = asyncio.create_task(compute(x, y))        # python3.7以上写法
    # task绑定回调函数
    task.add_done_callback(functools.partial(end, x, y))  # python3.7以上写法
    # 释放下cpu的使用
    await asyncio.sleep(0)
    print('--------------------print_num继续执行---------------------------')
    for i in range(1000000):
        if i % 5000 == 0:
            print(i)
            await asyncio.sleep(0.1)


def end(n, m, t):
    print(f'{n}+{m}={t.result()}')

老师，这个t是什么，是谁传给它的

from multiprocessing import Pool,current_process
import time
def fun1(name):
    print(f"id1为{current_process().pid},接受的数据为{name}")
    time.sleep(3)
    return name
def fun2(args):
    print(args)


if __name__ == '__main__':
    pllo=Pool(3)
    pllo.apply_async(fun1,args=('1',),callback=fun2,)
    pllo.apply_async(fun1,args=('2',))
    pllo.apply_async(fun1,args=('3',))
    pllo.apply_async(fun1,args=('4',))
    pllo.apply_async(fun1,args=('5',))
    pllo.apply_async(fun1,args=('6',))
    pllo.apply_async(fun1,args=('7',))
    pllo.apply_async(fun1,args=('8',))
    pllo.apply_async(fun1,args=('9',))

    pllo.close()

    pllo.join()
    #老师好 这里有时候打印不出数据是怎末回事呢 是一个空行 如下：
    #id1为7628,接受的数据为1id1为7628,接受的数据为1
id1为16176,接受的数据为2
id1为7092,接受的数据为3
1id1为7628,接受的数据为4

id1为16176,接受的数据为5
id1为7092,接受的数据为6
id1为7628,接受的数据为7
id1为16176,接受的数据为8
id1为7092,接受的数据为9

进程已结束，退出代码为 0

from multiprocessing import Process,current_process
from multiprocessing import Manager

def fun1(name,m_dict,m_list):
    print(f'子进程为{current_process().pid}接受的数据为{m_list}')
    print(f'子进程为{current_process().pid}接受的数据为{m_dict}')

    m_list.append('你好')
    m_dict['age']='18'

if __name__ == '__main__':
    print(f'主进程为{current_process().pid}')

    with Manager() as mul:
        m_list=mul.list()
        m_dict=mul.dict()
        m_dict['name']='俞兴志'
        m_list.append("hello12345")
        p1=Process(target=fun1,args=("p1",m_list,m_dict))
        p1.start()

        p1.join()
        print(m_list)
        print(m_dict)

#老师好 我有三个问题

#1为什么我这里是主线程结束 然后是先打印出来的是字典 再是列表

#2我在子线程添加了新的数据 控制台报错 原因是'DictProxy' object has no attribute 'append'（'DictProxy' 对象没有属性 'append'）

##3 p1=Process(target=fun1,args=("p1",m_list,m_dict)#后面args传参他的作用是什么

from multiprocessing import Process,Pipe
import os

def fun1(name,con):
    print(f"当前进程号为{os.getpid()}接受的数据为{con.recv()}")
    con.send("nihao")
if __name__ == '__main__':

    print(f"著京城{os.getpid()}")
    con1, con2 = Pipe()
    p1=Process(target=fun1,args=("p1",con1))
    con2.send("hello")

    p1.join()
    print(con2.recv())
    
    #老师 这是哪部分出了问题

print(f"第{number}个人在安检")

这个f是什么意思

"""协程的基本使用-asyncio的task的使用"""
import functools
import asyncio
async def compute(x,y):
    print(f"compute:{x}+{y}....")
    await asyncio.sleep(1)
    return x+y

async def print_sum(x,y):
    #创建task
    task = asyncio.create_task(compute(x,y))
    #task绑定回调函数
    task.add_done_callback(functools.partial(end,x,y))
    #释放一下cpu的使用
    await asyncio.sleep(1)

def end(n,m,t):
    print(f"{n}+{m}={t.result}")

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(print_sum(2,3))
    loop.close()

这个是什么情况啊老师？？

求解

#协程的使用——gevent
import gevent
def gf(name):
    print(f'{name}:我想买包包！！！')
    gevent.sleep(1)
    print(f'{name}:我想学编程！！！')
    g2.switch()
def bf(name):
    print(f'{name}:买！买！买！！')
    gevent.sleep(1)
    print(f"{name}:一点更要去上学堂！")
if __name__ == '__main__':
    g1=gevent.spawn(gf,'貂蝉')
    g2=gevent.spawn(bf,'吕布')
    g1.join()
    g2.join()

老师我这是什么情况呀？

from threading import Thread,BoundedSemaphore

from time import sleep
def an_JIan(number):
    renshu.acquire()
    print(f"第{number}个人在安检")
    sleep(3)
    renshu.release()

if __name__ == '__main__':
    renshu=BoundedSemaphore(3)
    for x in range(10):
        t1=Thread(target=an_JIan,args=(f'{x+1}',))
        t1.start()

#老师我的运行结果每次不一样是怎么回事呢

'''

第1个人在安检

第2个人在安检

第3个人在安检

第4个人在安检

第6个人在安检

第5个人在安检

第8个人在安检

第7个人在安检

第9个人在安检

第10个人在安检

进程已结束，退出代码为 0

第二种如下：

第1个人在安检

第2个人在安检

第3个人在安检

第5个人在安检

第4个人在安检

第6个人在安检

第8个人在安检

第7个人在安检

第9个人在安检

第10个人在安检

进程已结束，退出代码为 0

'''

import asyncio
import functools


async def compute(x, y):
    print(f'compute:{x}+{y}...')
    await  asyncio.sleep(1)
    return x + y


async def print_sum(x, y):
    # 创建task
    task = asyncio.create_task(compute(x, y))  # 底层
    # task绑定事件函数
    task.add_done_callback(functools.partial(end, x, y))

    await  asyncio.sleep(1)


def end(n, m,t):
    # result = await compute(x,y)
    print(f'{n}+{m}={t.result}')


if __name__ == '__main__':
    loop = asyncio.get_event_loop()

    loop.run_until_complete(print_sum(1, 2))

    loop.close()

老师能把这个程序的流程叙述一遍吗 我调试了一下感觉还是不太懂