为什么我的程序从上到下运行到了print("主线程，end"),主线程结束了,守护线程t1还在运行。

九:

还有这个，我设置一个守护线程t1，普通线程t2，运行结果里面，他们并没有抢先=线运行

老师，请问为什么我在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()

如果有2个接收方怎么办？python3.7

from multiprocessing import Process,Queue
import time


def write(q):
    for value in ["a", "b", "c"]:
        print("开始写入", value)
        q.put(value)
        time.sleep(1)


def read(q):
    while True:
        if not q.empty():
            print("读取到的值是： ", q.get())
            time.sleep(1)
        else:
            break


if __name__ == '__main__':
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    pw.start()
    pw.join()
    pr.start()
    pr.join()
    print("OVER")

老师，Queue，中的消息，是有顺序的吗？还是无序的？

为什么我这个后面的udpSock.close()取消缩进就错，和while的内容一起缩进就没事

桌面上有这个文件，路径也是对的，设置的ip也是这个   但是找不到这个文件

这么多id到底什么意思，看不懂

from multiprocessing import Process,Queue
import time


def write(q):
    for value in ["a", "b", "c"]:
        print("开始写入", value)
        q.put(value)
        time.sleep(1)


def read1(q):
    for x in range(3):
        a = q.get()
        print("读取到的值是： ", a)
        q.put(a)
        time.sleep(1)

def read2(q):
    while True:
        if not q.empty():
            print("read2读取到是数字是： ", q.get())
            time.sleep(1)
        else:
            break


if __name__ == '__main__':
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr1 = Process(target=read1, args=(q,))
    pr2 = Process(target=read2, args=(q,))
    pw.start()
    pw.join()
    pr1.start()
    pr1.join()
    pr2.start()
    pr2.join()
    print("OVER")

如果有2个接收方怎么办？python3.7，这个还能优化吗？

老师，queue中的消息，是有序的吗？还是无序的？

def listen(self, __backlog: int = ...) -> None: ...

• backlog 可选参数代表套接字在拒绝新连接之前，操作系统可以挂起的最大连接数。backlog 参数一般设置为 5，若未设置，系统会为其自动设置一个合理的值。

• 
  

老师，我想了解listen有什么用，网上搜到了这段话，不懂

我以为listen是最大连接数，结果同时多个客户端向服务端发送请求建立连接时，前面的客户端发送一次数据就被强制断开连接，下一个客户端也只能发一次，直到最后一个客户端才可以正常收发

while True:
    client_socket, client_info = server_socket.accept()  # 阻塞，等待接收客户端信息
    # client_count += 1  # 当前连接的客户端数量+1
    # print(f'Server：new client，count：{client_count}')

    recv_data = client_socket.recv(1024)  # 最大接收1024
    print(f'client：{recv_data.decode("utf-8")}，来自{client_info[0]}, 端口号：{client_info[1]}')

    send_data = input("请输入需要TCP传送的信息体：").encode('utf-8')
    client_socket.send(send_data)  # 输入并编码后发送给客户端

    if recv_data == 'Bye' or send_data == 'Bye':
        break

我尝试将

client_socket, client_info = server_socket.accept()

移出循环体，只有第一个建立连接的客户端可以发，其它发了服务端收不到

from socket import *
s=socket(AF_INET,SOCK_DGRAM)
s.bind(("",8788))
s.sendto("nihao".encode("gb2312"),("192.168.1.3",8080))
redata=s.recvfrom(1024)
print(redata[0].decode("gb2312"))
s.close()


from socket import *
udpSocket=sonket(AF_INET,SOCK_DGRAM)
udpSocket.bind(("",8080))
while True:
    recvData=udpSocket.recvfrom(1024)
    print(recvData[0].decode())
    data=("请输入:")
    udpSocket.sendto(data.ecode(),receData[1])
udpSocket.close()

以上是29和30的代码，为啥我在29运行的时候没有输出值啊

#encoding=utf-8
#测试echo
#这个文件就是echo服务器
from socket import *

udpSock=socket(AF_INET,SOCK_DGRAM)
#绑定IP和端口号,IP是本机IP
udpSock.bind(("",8585))
#recvData接收到的数据是一个元组，元组第一个数据是一个字节流数据
#元组的后一个数据是保留了发送方的IP和端口号
#1024是所能接收的最大字节数
while True:
    recvData=udpSock.recvfrom(1024)
    #因为已经是字节流数据了，都不需要encode（）转码
    udpSock.sendto(recvData[0],recvData[1])
udpSock.close()

#encoding=utf-8
#与test01共用
from socket import *

s=socket(AF_INET,SOCK_DGRAM)
s.bind(("",8788))
s.sendto(b"asd",("192。168.1.17",8585))
redata=s.recvfrom(1024)
#decode()是解码的
print(redata[0].decode())

为什么我这个echo什么都没有返还

#coding=utf-8
from threading import Thread
from time import sleep

def func1(name):
    print(f"线程{name},start")  # f 就是format
    for i in range(3):
        print(f"线程：{name},{i}:")
        sleep(1)
    print(f"线程{name},end")

if __name__=='__main__':
    print("主线程，start")
    #创建线程
    t1 = Thread(target=func1,args=("t1",))
    t2 = Thread(target=func1,args=("t2",))
    #启动线程
    t1.start()
    t2.start()
    print("主线程,end")

主线程，start

线程t1,start

线程：t1,0:

线程t2,start

线程：t2,0:

主线程,end

线程：t1,1:

线程：t2,1:

线程：t1,2:

线程：t2,2:

线程t1,end

线程t2,end

老师，有点不太明白这个代码运行的步骤 能帮我解释一下吗

'''
建立一次通讯
'''
from socket import *

tcpServerSocket = socket(AF_INET,SOCK_STREAM)
host = ''
post = 8080
addr = (host,post)
tcpServerSocket.bind(addr)
print('----------等待会话开始------------')
while True:
    tcpServerSocket.listen()
    tcpClientSocket,addr = tcpServerSocket.accept()
    data = tcpClientSocket.recv(1024)
    print('对方发给你的话：',end=' ')
    print(data.decode(encoding='gb2312'))
    sendData = input('请输入发给对方的话：')
    tcpClientSocket.send(sendData.encode(encoding='gb2312'))

老师 我利用网络助手反复测试了这个代码，出现了一下问题：

        我能接受到网络助手发送的信息，而且我能给网络助手发信息。但是只能接受一次，再次发送就收不到了，为什么呢？？

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

#current_thread() 返回当前线程的实例，；老师，实例是什么意思？

怎么用threading，穿件线程？

老师，为啥我画横线那块不能像注释里那样写，提示不对

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


def producer():
    num = 1
    while True:
        print(f"生产了{num}号加菲猫")
        my.put(f"{num}号加菲猫")

def consumer():
    while True:
        print(f"购买了{mq.get()}")
        print("购买了{}".format(mq.get()))

if __name__ == "__main__":
    # 创建共享数据的容器
    mq = Queue()
    # 创建生产者线程
    t1 = Thread(target=producer)
    # 创建消费者线程
    t2 = Thread(target=consumer)
    # 开始工作
    t1.start()
    t2.start()