老师，那个，我想知道，用send或者next返回到yiled时，怎么确定返回的是哪一个yiled呢？当出现多个yiled时？

为啥我这个报错呀

from threading import Thread

#线程的实线
#方法包装
#创建普通方法
def func1(name):
    print(f"Threading:{name} start")
    
#创建线程
t1=Thread(target=func1,args=('t1',))
t2=Thread(target=func1,args=('t2',))
#开始线程
t1.start()
t2.start()
#func1('t1')
#func1('t2')

老师，你好。请教一个本节中全局变量使用问题。以下两段代码均使用全局变量,为什么第一段的count在person()函数中不需要重新声明全局变量就可以直接使用。第二段代码state需要在两个函数中都重新声明全局变量

代码一：

from time import sleep
from threading import Thread

def car():
    global count
    while True:
        if count % 5 !=0:
            print('车已到站，请上车')
            sleep(1)
        else:
            print('车已驶离，请耐心等待')
            sleep(6)
        count += 1


def person():
    while True:
        if count % 5 !=0:
            print('上车！！！')
            sleep(1)
        else:
            print('等待车')
            sleep(1)

if __name__=='__main__':
    count=1
    t1=Thread(target=car)
    t2=Thread(target=person)
    t1.start()
    t2.start()

代码二：

from time import sleep
from threading import Thread,Event
from random import randint
def door():
    global state
    while True:
        if event.is_set():
            print('门已开，可通行。。。。')
            sleep(1)
        else:
            state=0
            print('门已关，请刷卡！！！！')
            event.wait()
        sleep(1)
        state +=1
        if state>3:
            print('超过3秒，门自动关闭！！！！')
            event.clear()
def person():
    global state
    num=1
    while True:
        if event.is_set():
            print(f'门已开，{num}号进入')
        else:
            print(f'门已关，{num}号人刷卡进入')
            event.set()
        state=0
        num +=1
        sleep(randint(1,10))

if __name__=='__main__':
    state=0
    event=Event()
    t1=Thread(target=door)
    t2=Thread(target=person)
    t1.start()
    t2.start()

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))        #python3.7以上写法
    # task绑定回调函数
    task.add_done_callback(functools.partial(end,x,y))  #python3.7以上写法
    # 释放下cpu的使用
    await asyncio.sleep(0)


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

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

    loop.run_until_complete(print_sum(1,2))

    loop.close()

老师 这里task创建了一个任务计算x+y,下面的绑定回调函数是什么意思，为什么要绑定，以及绑定了之后怎么还要睡眠一秒，如果是0秒的话显示Task was destroyed but it is pending!我听不懂视频里的老师的表达，麻烦这里老师文字详细解释下

 #获得锁
 lock.acquire()
 #函数中使用全局变量
 global count
 for i in range(100000000):
     count+=1
 #释放锁
 lock.release()

老师讲的说这样获得锁释放锁能让他一个一个进行，不会出错，那这样，这就不是多线程了啊，多线程不是同时进行的吗？

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

老师我不理解f't{i+1}',   里的f与，  这里为什么要有f和逗号？

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

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

if __name__ == "__main__":

    print(threading.currentThread())
    # 开始时间
    start = time()
    '''
    # 创建线程
    t1 = Thread(target=func1,args=('t1',))
    t2 = Thread(target=func1,args=('t2',))  

    # 开始线程
    t1.start()
    t2.start()
    # 等待t1线程执行完再往下执行
    t1.join()
    # 等待t2线程执行完再往下执行
    t2.join()
    # func1('t1')
    # func1('t2')
    '''
    thread_list = []
    for i in range(100):
        t = Thread(target=func1,args=(f't{i+1}',))
        t.start()
        thread_list.append(t)
    for t in thread_list:
        t.join()
    # 结束时间
    end = time()-start
    print(end)

老师这里第二个for循环遍历列表里的线程，每遍历一个线程都join()，那不就是等这个线程结束才会遍历下一个线程，然后又join()又要等下一个线程结束才能接着遍历后面的，这就串行运行了啊，但是打印显示还是3秒多，麻烦老师解释一下我错在哪了

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)
if __name__ == "__main__":
    
    # 创建线程
    t1 = MyThread('t1')
    t2 = MyThread('t2')

    # 启动线程
    t1.start()
    t2.start()

老师我看了好多类的继承这样的写法，在子类的构造方法里都会调用父类的构造方法，这是固定写法吗？

如果是的话换成用super()去调用这样写可以吗？

from time import sleep
from threading import Thread
#类实现多线程
class MyThread(Thread):
def __init__(self,name):
Thread.__init__(self)
self.name=name

def run(self):
print(f"Threading:{self.name} start")
sleep(3)

#创建线程
t1=MyThread('t1')
t2=MyThread('t2')

#启动线程
t1.start
t2.start

我这里运行代码没有反应是怎么回事呢？

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

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()的作用是什么呢