老师 对于协程是怎么工作的 还是有些不理解 例如这里有个单线程 它里边创建了3个协程  但是现在这里有5个任务  那这三个协程是怎么工作的   

老师，我检查过代码，和视频里是一样的，但是我的person不显示print运行，只有car的运行，这是为什么？

from time import sleep
from threading import Thread
from threading import Event

def car():
    # global count
    num = 0
    while True:
        if even.is_set():  # if count % 5 != 0:
            print("车已到站，可以上车")
            sleep(1)
            num += 1  # count += 1
            if num % 5 == 0:
                even.clear()
        else:
            print("车开走了，请等待")
            sleep(6)
            # count = 1
            even.set()

def person():
    while True:
        if even.is_set():  # if count % 5 != 0:
            print("上车！")
            sleep(1)
        else:
            print("等待车！！！")
            even.wait()
            # sleep(1)

if __name__ == "__main__":
    even = Event()  # count = 1
    t1 = Thread(target = car)
    t2 = Thread(target = person)
    t1.start()
    t2.start()

老师，你说queue中的消息是无序的，那我第一次取出来的消息我再put进去你怎么保证我二次执行for循环的时候取出来的不是同样的消息呢？

# 服务器端：一个线程专门发送消息，一个线程专门接收消息。
# 客户端：一个线程专门发送消息，一个线程专门接收消息。
# 结合多线程实现TCP双向传送(自由聊天)
# 【示例】TCP服务端结合多线程实现自由收发信息



from socket import *
from threading import Thread
def recv_data():
    while True:
        # 读取客户端的消息
        re_data = tcp_client_socket.recv(1024)
        re_content =re_data.decode('gbk')
        # 将消息输出到控制台
        print(f"客户端说:{re_content},from:{host}")
        if re_content == '88':
            break
        # 获取控制台信息
def send_data():
    while True:
        msg = input(">")
        tcp_client_socket.send(msg.encode("gbk"))

if __name__ == '__main__':
    tcp_server_socket = socket(AF_INET, SOCK_STREAM)
    tcp_server_socket.bind(('127.0.0.1', 8888))
    tcp_server_socket.listen()
    print("服务端已经启动，等待客户端连接！")
    tcp_client_socket, host = tcp_server_socket.accept()
    print("一个客户端建立连接成功！")

    t1 = Thread(target=recv_data())
    t2 = Thread(target=send_data())
    t1.start()
    t2.start()
    t1.join()
    t2.join()


tcp_client_socket.close()
tcp_server_socket.close()

from socket import *
from threading import Thread

def recv_data():
    while True:
        redata=tcp_client_socket.recv(1024)
        recv_data=redata.decode('gbk')
        print(f"服务器端说:{recv_data}")
def send_data():
    while True:
        msg=input(">")
        tcp_client_socket.send(msg.encode("gbk"))
        if msg == '88':
            break
if __name__ == '__main__':

    tcp_client_socket=socket(AF_INET,SOCK_STREAM)
    tcp_client_socket.connect(('127.0.0.1',8888))
    print("连接建立成功")
    t1=Thread(target=recv_data())
    t2=Thread(target=send_data())
    t1.start()
    t2.start()
    t1.join()
    t2.join()
tcp_client_socket.close()

这个持续通信中的发送消息接收信息判断为什么不生效，当输入88的时候

老师，当多个线程进入可运行状态后，能否像多个进程那行多个线程同时运行，还是像上述 PPT里讲的那样，只能一个一个线程单独运行？

想问一下，多线程并发在底层是怎么实现的，内存机制是什么

import threading
num = 0
def test1():
    global num
    if mutex.acquire():
        for i in range(100000):
            num += 1
    print(num)
    mutex.release()
def test2():
    global num
    if mutex.acquire():
        for i in range(100000):
            num += 1
    print(num)
    mutex.release()

mutex = threading.Lock()
p1 = threading.Thread(target=test1)
p1.start()
p2 = threading.Thread(target=test2)
p2.start()
print(num)

用了互斥锁也还是会出错

运行不了怎么弄

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()

老师这样的报错一般是为啥啊？？？？？？？？？？

import struct  #数据转化
from socket import *

#存放要下载的文件
filename = input("请输入要下载的文件：")
#存放服务器的IP
server_ip = input("请输入服务器的IP地址：")
#按正确的格式转化要下载的文件
send_data = struct.pack("!H%dsb5sb"%len(filename),1,filename.encode(),0,"octet".encode(),0)
#创建socket对象
s = socket(AF_INET,SOCK_DGRAM)
#第一次发送到服务器，连接69端口
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])   #解析字节流，H可将转化为2字节,索引获取数据块编号
    #获取服务器随机端口号
    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文件中去
    f.write(recv_data[0][4:])
    if len(recv_data[0]) < 516:
        break
    #获取返回的ACK确认包
    ack_data = struct.pack("!HH",4,ack_num)
    #回复ACK确认包
    s.sendto(ack_data,(server_ip,rand_port))

老师  就是我这个event对象会不会被其他线程的event.set启动  而且这个主线程是相当个进程吗

dest = ("<broadcast>",8080)

老师，我想请问一下你后面说的在局域网里面只要开放了8080端口都可以接收到数据，那这个不是一台计算机只能有一个端口嘛？这个怎么理解呢？

想问一下老师，为什么不是先执行完for循环后再打印最后一句“主线程结束了”

from threading import Thread
#测试线程的同时进行，导入sleep模块
from time import sleep
#创建方法
class MyThread(Thread):#继承Thread类
    def __init__(self,name):
        Thread.__init__(self) #因为重写了方法，所以手动调父类的构造函数
        self.name=name
    def run(self): #一定要用run（）方法
        print("threading:{} satrt".format(self.name))
        sleep(3)
        print("threading:{} end".format(self.name))

if __name__ == '__main__':
    threadlist=[]
    for i in range(10):
        t=MyThread(f"t{i+1}")
        t.start()
    print("主线程结束了！！")

老师，我想请问为什么文件名为中文名就会报错。

老师，当一个程序的主进程启动一个 主线程，主线程再去启动其他主线程，主线程和其他子线程都是在一个CPU里面进行的吗?

老师，

        我看到一些网站上说Python的基本数据类型是数字类型（int + float +[bool]（我目前基本没用，所以中括号））和字符串类型（我自己也是这样觉得的），但是有些资料上说序列也是Python的基本数据类型。

        如果说序列也是Python的基本数据类型，那么有序序列（元组和列表） + 无序序列（集合，字典）都是Python的基本数据类型了？

    另数据结构大概学到什么时候可以去看。我感觉自己写的都是拼凑型的小程序，看到大佬的才是666的。