老师，什么原因

聊天室1

#tcp服务器
from threading import Thread
from socket import*

#  创建sock对象
udpSock = socket(AF_INET, SOCK_DGRAM)
#绑定ip地址端口
addr = (("",8080))
#发送数据
def fasong():
    while True:
        date = input("输入：")
        udpSock.sendto(date.encode('gb2312'),fasong[1])
#接收数据
def jieshou():
    while True:
        jieshus = udpSock.recvfrom(1024)
        print(jieshus[0].decode())

#创建线程
t1 = Thread(target = fasong())
t2 = Thread(target = jieshou())
#启动线程
t1.start()
t2.start()
udpSock.close()

聊天室2

from threading import Thread
from socket import*
#创建sock对象
udpSock = socket(AF_INET,SOCK_DGRAM)
#绑定ip 地址端口
udpSock.bind(("",8080))
#接收数据
def jieshou():
    while True:
        jieshou = udpSock.recvfrom(1024)
        print(jieshou[0].decode('gb2312'))
#发送数据
def fasong():
    while True:
        date =  input("输入：")
        udpSock.sendto(date.encode('gb2312'),fasong[1])
#创建线程

t1 = Thread(target= fasong())
t2 = Thread(target= jieshou())
    #启动线程
t1.start()
t2.start()

老师，如果两个子进程都去修改manger传递的list的值，那主进程获取到的list值会不会出现脏数据呢

from socket import*
import struct
fine = "mei.jpg"
cmb_buf = struct.pack('!H%dsb5sb' % len(fine), 1, fine.encode(), 0, "octet".encode(), 0)
udpSock = socket(AF_INET,SOCK_DGRAM)
udpSock.sendto(cmb_buf,("127.0.0.1",69))
f = open(fine,"ab")   #以追加模式打开，没有了创建文件夹
while True:
    recv_date = udpSock.recvfrom(1024)   #接收数据
    caozuoma, ack_num = struct.unpack("!HH",recv_date[0][:4])  #获取数据编号
    rand_port = recv_date[1][1]    #获取服务器随机端口
    if int(caozuoma) == 5:
        print("文件不存在")
        break
    print("操作码：%d,ACK: %d,服务器随机端口：%d,数据长度：%d"%(caozuoma, ack_num, rand_port, len(recv_date[0])))
    f.write(recv_date[0][4:])  #将数据写入
    if len(recv_date[0]) < 516:
        break
    ack_date = struct.pack("!HH", 4, ack_num)
    udpSock.sendto(ack_date, (cmb_buf, rand_port))

老师，什么错误

from threading import Thread

from time import sleep ,time

import threading

#类实现-多线程

def func1(name):

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

    sleep(3)

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

if __name__ == "__main__":

    print(threading.currentThread())

# 创建线程

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

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

# 开始时间

start = time()

# 开始线程

t1.start()

t2.start()

#func1 ('t1')

#func1 ('t2')

#结束时间

end = time()-start

print (end)

if even.is_set():

这行代码怎么理解

#coding=utf-8
from threading import Thread
from time import sleep,time
#创建方法
def func1(name):
    print(f"threading:{name}start")
    sleep(3)
    print(f"threading:{name}end")
if __name__ == '__main__':
    #启动时间
    start = time()

    t_list = []
    for i in range(10):
        t = Thread(target=func1, args=(f"t{i+1}",))
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    end = time()-start
    print(end)
    
#coding=utf-8
from threading import Thread
from time import sleep,time
import threading
class MyThread(Thread):
    def __init__(self,name):
        Thread.__init__(self)
        self.name = name

    def run(self):
        print()
        print(f"threading:{self.name}start")
        sleep(3)
        print(f"threading:{self.name}end")
if __name__ == '__main__':

    start = time()
    t_list = []
    for i in range(10):
        t = MyThread(f"t{i+1}")
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    end = time()-start
    print(end)

哪些是主进程哪些是子进程,哪些是主线程哪些是子线程.

有点搞不清楚有点乱

老师，为什么多线程并发编程中，Lock锁必须让变量引用以后才能使用？   

main(): lock = Lock()

function():lock.acquire() # 获得锁        lock.release() # 释放锁


而不能写成
function():Lock().acquire() # 获得锁      Lock().release() # 释放锁

下面那种写法，我的IDLE报错，我所使用的开发环境是PyCharm专业版

老师，请问，这是哪里出错了呢，我检查了也没发现

老师，请问，我在百度搜索中查询到的本机IP地址，与飞秋的IP不是同一串数字，是为什么呢，

但是飞秋和网络助手是同一个IP

发送方1：

from socket import *

s=socket(AF_INET,SOCK_DGRAM)
s.bind(('',8888))


s.sendto(b'sxt',('192.168.101.2',8090))

redata = s.recvfrom(1024)
print(redata[0].decode())

接受方：

from socket import *

udpSock=socket(AF_INET,SOCK_DGRAM)
udpSock.bind(('',8090))
while True:
    redata = udpSock.recvfrom(1024)
    udpSock.sendto(redata[0],redata[1])
udpSock.close()

vscode运行：

请问用vscode怎么才能运行，求解？

老师，请问，视频中老师说为了让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()

老师，请问，一般来说，用在函数中的局部变量，在函数运行结束后，这个局部变量是会被释放吗

老师，请问，下载gevent的时候出错了

老师，请问，资料上讲，这段代码有IO，是单纯的切换，没有提高效率，疑问是：这段代码的IO体现在哪里呢

老师，下载greenlet的时候，出现这个，之前下载pygame也还没下载到