from threading import Thread
from queue import Queue #导入队列，保证数据安全
from time import sleep

#生产者
def producer():
    num = 1
    while True:
        print(f'生产了{num}号加菲猫')
        mq.put("第{}号加菲猫".format(num))
        num += 1
        sleep(1)


#消费者
def cousmer():
    while True:
        print("购买了{}".format(mq.get()))
        sleep(2)

if __name__=="__main__":
    #创建一个共享容器
    mq = Queue()
    #创建线程
    t1 = Thread(target=producer)
    t2 = Thread(target=cousmer)
    #t3 = Thread(target=cousmer)
    #开启线程
    t1.start()
    t2.start()
    #t3.start()

老师，为什么我的生产1号和2号是生产就购买呢？从3号开始才是两个生产一个购买？

麻烦老师帮我看一下为什么会有下面这个结果？

老师，我这个将程序作为广播方，将网络调试助手作为接收方，为什么网络调试助手没收到消息啊

# udp广播
import socket
addr = ('<broadcast>', 8888)
s =socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST,1)
s.sendto(b'nihao', addr)

老师，请问，视频中老师说为了让print_sum中运行的时间久一点儿，等待return的结果，好让task有值，所以给print_sum添加了一个数据比较大的循环，我的疑问是，print_sum 中也有释放cpu，可以让这里的sleep(5)的时间多于compute(x,y)里面sleep(1)的时间是不是也可以，我试了

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 = asyncio.create_task(compute(x,y))
    task.add_done_callback(functools.partial(end,x,y))
    await asyncio.sleep(5)
    print("...............print_sum继续执行。。。。。。。。。。。")


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


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

代码:

from socket import *
s=socket(AF_INET,SOCK_DGRAM)
s.bind(("",8788))
s.sendto("abc".encode(),("192,168.1.8",8080))
data=s.recvfrom(1024)
print(data[0].decode("gb2312"))
s.close()

运行结果:

老师请问一下，这个错误是因为什么?

老师，这里面没有用到父类的属性，为什么还需要初始化父类方法

上面是老师的版本，下面是我修改的版本，

我想问的是：

1，在函数中调用其它函数，或者函数套嵌函数，那么这些函数就成为线程的私有数据了吗？

2，stu变量作为参数传递到下级函数中，也就是stu变量，不受线程影响了，在各自线程中独立存在？

3，stu=Student(name)是创建类对象，fun1(stu)是调用函数fun1,那么Student也被调用了吗？不明白这里是怎么回事啊？

from multiprocessing import Manager,Pool
import time
def write(q):
    for i in "welcome":
        print("开始写入",i)
        q.put(i)

def reader(q):
    time.sleep(3)
    for i in range(q.qsize):
        print("得到消息：",q.get())
if __name__ == "__main__":
    print("主进程启动")
    q = Manager().Queue()
    po = Pool()
    po.apply_async(write,(q,))
    po.apply_async(reader,(q,))
    po.close()
    po.join()

在使用for循环中，

t=Thread(target=func1, args=(f't{i+1},))

这里在args后加了f

但是在没有for循环时，

t1= Thread(target=func1, args=('t1',))

这里不加f，请问是为什么呢？

#coding=utf-8
from socket import*
from threading import Thread


def recv_data():
    while True:
        recv_data =s.recvfrom(1024)  # 1024表示本次接受的最大节数
        recv_content = recv_data[0].decode("gbk")
        print(f'收到远程信息：{recv_content},from{recv_data[1]}')
        if recv_content == "88":
            print("聊天结束")
            break


def send_data():
    addr = (('127.0.0.1', 8888))
    while True:
        data = input("请输入：")
        # 发送数据时，python3需要将字符串转成byte
        s.sendto(data.encode('gbk'), addr)  # 默认的网络助手使用的编码是gbk
        if data == "88":
            print("聊天结束")
            break




if __name__=="__main__":
    s = socket(AF_INET, SOCK_DGRAM)  # 创建套接字
    addr = (('127.0.0.1', 8989))  # 准备接受地址
    t1=Thread(target=recv_data)
    t2=Thread(target=send_data)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

问题：对协程理解不好，请老师多指导，咱们用的生产者-消费者是不是一个协程的运作，请老师指导！！！！！

老师，没搞懂线程和进程有什么区别，为什么进程要用main限制启动条件，没看到他哪里会循环呀。

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

import threading


#用方法包装
def fun1():
    print('f线程，start')
    for i in range(3):
        print('线程：{i}')
    print('f线程，end')

#创建线程，使用threading方法
t1 = threading.Thread(target=fun1,args=('t1',))
t2 = threading.Thread(target=fun1,args=('t2',))

if __name__ == '__main__':
    print('主线程，start')
    t1.start()
    t2.start()
    print('主线程，end')
 
 老师这个是什么原因报错的

老师，这里的pool.join（）中的join是什么意思？