老师我代码运行的时候一直显示文件不存在怎么回事

import struct
from socket import *
filename='dong.jpg'
server_ip='192.168.43.205'
send_data=struct.pack('!H%dsb5sb'% len(filename),1,filename.encode(),0,'octet'.encode(),0)
s=socket(AF_INET,SOCK_DGRAM)
s.sendto(send_data,(server_ip,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:
        print('文件不存在')
        break
    print('操作码:%d,ACK:%d,服务器随机端口:%d,数据长度：%d'%(caozuoma,ack_num,rand_port,len(recv_data)))
    f.write(recv_data[0][4:])  #将数据写入
    if len(recv_data[0])<156:
        break
    ack_data=struct.pack('#HH',4,ack_num)
    s.sendto(ack_data,(server_ip,rand_port))  #回复ACK确认包

老师这个软件怎么操作，跟视频中老师整的一样呀】

老师echo的作用就是写什么，就给返回什么吗？下面俩张图，ucp有数据，echo没有数据

这是echo

#测试echo的作用：发送什么，就返回什么
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()

这是usp接受数据

from socket import *

s=socket(AF_INET,SOCK_DGRAM)
s.bind(('',8788))
s.sendto(b'asd',('192.168.43.205',8585))
redata=s.recvfrom(1024)
print(redata[0].decode())

老师我想获取对面的IP地址和端口号，怎么修改，直接把元组0改成1不行吗？

from socket import *

s=socket(AF_INET,SOCK_DGRAM)
addr=('192.168.43.205',8083)
date=input('请输入发送的内容：')
s.sendto(date.encode('gb2312'),addr)
redata=s.recvfrom(2048)
print(redata[1].decode('gb2312'))
s.close()

老师那个飞秋软件也是在本章资料里面下载吗

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))  
    # 释放下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(1, 2))

    loop.close()

老师我想问下，这里的t.result()的作用是什么呢

老师能不能举一些具体实际的例子，感觉这什么菜刀红烧肉的东西很苍白无力

那个地方出错了

from threading import Thread
from queue import Queue
from time import sleep

def producer():
    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=producer)
    #创建消费者线程
    t2=Thread(target=consumer)
    # 创建消费者线程
    t3 = Thread(target=consumer)
    #开始工作
    t1.start()
    t2.start()
    t3.start()

from threading import Thread
from time import sleep

class Text(Thread):
    def __init__(self,name):
        Thread.__init__(self)
        self.name = name

    def run(self):
        print(f"Thread:{self.name} start")
        sleep(2)
        print(f"Thread:{self.name} end")

if __name__ == '__main__':
    t1 = Text("t1")
    t2 = Text("t2")
    t1.setDaemon(True)
    t1.start()
    t2.start()
    print("主线程结束")

为什么执行了t2的end，我只把t1改成了守护线程

from threading import Thread
from time import sleep
# 线程的实现
# 方法包装

# 创建普通方法
def func1(name):
    print(f"Threading:{name} start")
    sleep(3)


if __name__ == "__main__":
    
    # 创建线程
    t1 = Thread(target=func1,args=('t1',))
    t2 = Thread(target=func1,args=('t2',))

    # 开始线程
    t1.start()
    t2.start()
    # func1('t1')
    # func1('t2')

这个是并行还是并发

老师我这代码运行的样子怎么是这样的？然后每次的样子还不一样

from time import sleep
from threading import Thread
from threading import BoundedSemaphore
def an_jian(num):
    lock.acquire()
    print(f"第{num}个人完成安检!!!")
    sleep(2)
    lock.release()


if __name__=="__main__":
    lock=BoundedSemaphore(3)
    for i in range(10):
        t=Thread(target=an_jian,args=(f"{i+1}",))
        t.start()

老师我这个运行的时候没有任何的结果，直接显示程序结束了

from threading import RLock


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__=="__mian__":
    lock=RLock()
    func3()

老师，想问一下 这一部分并发编程的内容要掌握到什么程度呀 

老师有几个问题请教一下

from threading import Thread
from time import sleep

这两句话是什么意思，直接写成 import itme sleep 不行吗

print(f"Threading:{name} start")

这个代码中f起到了什么作用

用锁是不是就和单线程一样，感觉都没有并行