老师我这个是怎么回事？在terminal上安装过gevent了

老师为什么主进程p1.join()不加就打印不出来列表和字典的内容,它有什么作用呢?

from multiprocessing import Process,Manager


def func(name,m_list,m_dict):
    print('获取了数据:{}'.format(m_list))
    print('获取了数据:{}'.format(m_dict))
if __name__ == '__main__':
    with Manager() as mgr:
        m_list = mgr.list()
        m_dict = mgr.dict()
        m_list.append('Hello!')
        p1 = Process(target=func,args=('p1',m_list,m_dict))
        p1.start()
        p1.join()

老师，请问为什么我i这里文件不存在啊，我的图片是放在桌面上的

# tftp下载器
from socket import *
import struct     # 帮助组织数据
filename = 'siyue.jpg'    # 存放要下载的文件名
server_ip = '10.174.149.195'  # 存放服务器所在的IP地址
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))  # 第一次发送，链接服务器69端口
f = open(filename, 'ab')   # 创建一个空文件，名字与我们要下载的文件同名，a:以追加模式打开（必要时可以创建）append；b：表示二进制
while True:
    recv_data = s.recvfrom(1024)  # 接收数据
    caozuoma, ask_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[0])))
    f.write(recv_data[0][4:])   # 将数据写入
    if len(recv_data[0]) < 516:
        break
    ack_data = struct.pack("!HH", 4, ack_num)
                          # 操作码和快编号分别占用两个空间
    s.sendto(ack_data, (server_ip, rand_port))   # 回复ACK确认包

老师，请问这是什么问题呀

# 测试echo服务器（接收到什么就原封发回）
from socket import *

udpSock = socket(AF_LINK, SOCK_DGRAM)
udpSock.bind(("", 8585))
while True:
    recvDate = udpSock.recvfrom(1024)
    udpSock.sendto(recvDate[0],recvDate[1])

udpSock.close()

老师，为什么这个列表获取完数据后，在最后打印了，而字典却没有呢

from multiprocessing import Process,current_process
import os
from multiprocessing import Manager

def func(name,m_list,m_dict):
    print('子进程ID：{}  获取了数据：{}'.format(os.getpid(),m_list))
    print('子进程ID：{}  获取了数据：{}'.format(os.getpid(),m_dict))


    m_list.append('你好')      # 列表
    m_dict['name'] = '尚学堂'  # 字典

if __name__ == '__main__':
    print('主进程ID：{}'.format(current_process().pid))
    with Manager() as mgr:
        m_list = mgr.list()
        m_dict = mgr.dict()
        m_list.append('Hello!')
        m_dict['name'] = 'zlp'

        p1 = Process(target=func,args=('p1',m_list,m_dict))
        p1.start()
        p1.join()
        print(m_list)
        print(m_dict)

老师，您看一下这个网络调试助手无法接收和发送怎么解决呀

from socket import *
tcpSock = socket(AF_INET, SOCK_STREAM)#逗号后是TCP协议的使用
tcpSock.bind(('', 7788))#将7788设置为服务器的端口号
tcpSock.listen(5)#将可与服务器连接的客户端数设为5,并进行监听
newSock, clientAddr = tcpSock.accept()#将接受的数据赋值给两个对象，使得原来的套接字空下来

#数据收发
data = newSock.recv(1024)#将接收的数据赋值给data,注意：TCP用recv，UDP用recvfrom
newSock.send(b'xiexie')#由于已经建立稳定连接，所以不用再加客户的端口号。 TCP用send UDP用sendto

#关闭服务（先关闭新创建的套接字，再关闭监听的套接字）
newSock.close()
tcpSock.close() #监听的服务器套接字关闭后，连接才算终止。

老师请问为什么我这个运行后打印的数据长度只有2的？
from socket import *
import struct

filename='cui.jpg'  # 创建一个存放要下载的文件的变量
server_ip='192.168.1.60'  # 创建一个存放IP地址的变量
# 创建读写请求
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:  #操作码是5的话 就是文件不存在 是一个错误包
        print('文件不存在。。')
        break
    print('操作码: %d,ACK: %d,服务器随机端口: %d,数据长度:%d'%(caozuoma,ack_num,rand_port,len(recv_data)))
    f.write(recv_data[0][4:])  # 将512个字节的数据写入
    if len(recv_data[0])<516:  # 如果收到的数据少于516个字节，说明发送完毕了
        break
    ack_data=struct.pack('!HH',4,ack_num) # 发送确认包 4+块编号
    s.sendto(ack_data,(server_ip,rand_port))

嘶，为什么会一直的报错啊，打开顺序没错的。

老师，我的代码使用VScode运行后，代码顺序自动发生了改变，而且运行结果也不对是怎么回事呀？

from gevent import monkey;  # 为了能识别time模块的io
monkey.patch_all()

from time import time, sleep
import gevent



def gf(name):
    print(f'{name}:我想要买个包包')
    sleep(2)
    print(f'{name}:我想要学编程')


def bf(name):
    print(f'{name}:买！！')
    sleep(2)
    print(f'{name}:学！！')


if __name__ == '__main__':
    start = time()
    g1 = gevent.spawn(gf, '貂蝉')
    g2 = gevent.spawn(bf, '吕布')
    g1.join()
    g2.join()
    end = time()
    print(end-start)

老师运行这个代码要不要打开网络调试助手的呢？

老师搞不懂为什么视频里面是两个代码同时运行，都可以返回发送或者接收的信息，为什么我的不行的

老师，请问为什么我在11行这里加了even.wait()，运行的时候为什么不是只打印一次呢

from time import sleep
from threading import Thread
from threading import Event
from random import randint

def door():
    global state
    while True:
        if even.is_set():
            print('门开着，可以通行......')
            even.wait()
            # sleep(1)
        else:
            state = 0
            print('门关了，请刷卡！！！')
            even.wait()
        sleep(1)
        state += 1
        if state > 3:
            print('超过3秒，门自动关闭！！')
            even.clear()

def person():
    global state
    num = 1
    while True:
        if even.is_set():
            print(f'门开着呢，{num}号人进入......')
        else:
            print(f'门关着，{num}号人刷卡进入......')
            even.set()
            state = 0
        num += 1
        sleep(randint(1,10))

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

老师，请问我这个是什么问题，把老师的复制过来就不报错，自己敲一遍就报错，下面的是我自己敲的

from threading import RLock

'''
Lock 锁 同步锁 互斥锁
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__ == '__main__':
    lock = RLock
    func3()

老师，额，可以问问这几个媒体已断开连接的，是什么啊？（后面要是有提到的话，您直接回复就好，我再自己看看）

老师，你好。有两个管道通信问题。

1. 管道通信内容只能使用一次吗？第6行也加入运行，程序卡在这里了。

2. 管道通信内容是否应该放在子进程开启（p1.start()）前定义？但课程中的是在子进程启动后定义的，按理子进程先启动，con2中还没内容应该报错的，但实际运行没报错。

from multiprocessing import Process,Pipe,current_process
import os

def func(name,con):
    print('当前进程{}，ID：{},内容是:{}'.format(name,current_process().pid,con.recv()))
    # print('当前进程{}，ID：{},内容是:{}'.format(name, os.getpid(), con.recv()))
    con.send('你好！')

if __name__=='__main__':
    print('主进程，ID：{}'.format(current_process().pid))
    print('主进程，ID：{}'.format(os.getpid()))
    con1,con2=Pipe()
    con1.send('Hello world!')
    p1.start()
    p1 = Process(target=func, args=('p1', con2))
    p1.join()
    print(con1.recv())