老师，您好。

用cmd看本电脑的IP时，出现了好几个格式相同的IP，想问一下，依据什么来判断那个才是电脑的IP？

老师，下边这个是错在哪里了？红色和黄色报警都没了，还是错。

from socket import *
from threading import Thread

def recv_data():
    while True:
        recv_data = client_socket.recv(1024)  # 最大接收1024字
        print(f"客户端说:{recv_data.decode('gbk')},来自：{client_info}")
        if recv_data == "end":
            break

def send_data():
    while True:
        msg = input(">")
        client_socket.send(msg.encode("gbk"))


if __name__ =='__main__':
    server_socket = socket(AF_INET, SOCK_STREAM)  # 建立TCP套接字
    server_socket.bind(("127.0.0.1", 8899))  # 本机监听8899端口
    server_socket.listen(5)
    print("等待接收连接！")
    client_socket, client_info = server_socket.accept()
    print("一个客户端建立连接成功！")

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

    client_socket.close()
    server_socket.close()

from threading import Thread
import time

def fun1():
    print('运行主程序')
    time.sleep(1)
    print('子程序运行结束')

thread_add=[]
for i in range(10):
    t=Thread(target=fun1)
    t.start()
    thread_add.append(t)
for thread in thread_add:
    thread.join()

老师，请问主线程和子线程是以什么来区分的？这个程序跑起来是先把所有的主程序都打印完，在打印所有的子程序，再运行的sleep（）方法，按说不应该是先执行一个主程序，再执行一个子程序吗？

为什么在线程，进程中一定要用到    if __name__ == "__main__":

?????????????????

#老师，请问为什么下面这个代码怎么没有跑起来呢？

老师，想问下多线程模式和协程模式的实现效果有什么区别呢，假设现在有三个任务，多线程模式：因为同一时间只有一个线程使用cpu嘛，一个线程执行任务时阻塞了，另外不是立马会有另一个线程执行其他任务吗，而协程模式下：单线程执行任务，一个任务阻塞了也是立马去执行其他任务。对这两种模式的执行效果的区别不太清楚。

是不是可以这样理解,协程是有线程控制的               

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)
        print(f"Threading:{self.name} end")


if __name__ == "__main__":

    # 创建线程
    for i in range(10):
        t = MyThread(f"t{i + 1}")
        # 设置当前进程为  守护线程
        t.setDaemon(True)
        t.start()
    print("主进程结束！")

问题1.这里边运行出来只有Threading:t1 start。。。，但是end没运行，我可不可以理解为主进程中只有run（）中的第一行代码:

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

是主进程，第二行以下都是子进程，所以守护线程意思就是只运行run（）中的第一行代码？

请老师解答，谢谢

# 协程实现生产者和消费者

def consumer():
    while True:
        n = yield
        print(f"生产了第{n}个产品")
def producter():
    g = consumer()
    # print(next(g))
    # next(g)
    for i in range(5):
        g.send(i)
        print(f"消费了第{i}产品")
        # func1()
if __name__ == "__main__":
   producter()

老师您好，这段代码为什么没有next（g）的时候会报错，或者说next（g）在这里的作用是什么？

老师，请问如果事件1执行碰到了io然后用协程，让事件1挂起并释放cpu。然后再执行事件2。有没有可能事件2也碰到了io事件1和事件2都挂起。那么这个时候在执行事件3吗？

老师，read2那个函数里，我注掉的那三行和和运行的那四行没区别啊，为什么运行我注掉的那三行程序就无法停止了呢

from multiprocessing import Queue, Process
import time
def write(q):
    for i in range(3):
        q.put(i)
        time.sleep(1)
    print(q.qsize())
def read1(q):
    for i in range(3):
        # print('第一次read', q.get())
        # q.put(q.get())
        # time.sleep(1)   
        a = q.get()
        print('第一次read', a)
        time.sleep(1)
        q.put(a)
              

def read2(q):
    while True:
        if not q.empty():
            print('第二次读取', q.get())
            time.sleep(1)
        else:
            break
if __name__ == '__main__':
    q = Queue(3)
    p = Process(target=write, args=(q,))
    p1 = Process(target=read1, args=(q,))
    p2 = Process(target=read2, args=(q,))
    p.start()
    p.join()
    p1.start()
    p1.join()
    p2.start()
    p2.join()

老师，这里的协程是在碰到io阻塞的时候就会执行其他的任务，那么他继续回来执行之前任务的条件是什么，是碰到执行的下一个任务阻塞后，在回来执行之前的任务，如果说下一个任务没有io，是执行完下一个任务之后，在回来执行之前的任务么，还有协程之间执行任务是不是也互相抢？

创建进程的args有什么用

from threading import Thread
from time import sleep
def func1(name):
    print(f"线程{name}，start")

    for i in range(3):
        print(f"thread:{name}:{i}")
        sleep(3)
    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")

老师，你能给我讲一下代码执行的过程吗？ 线程之间会抢占输出吗？感觉还是有点懵。

老师这个右下角什么意思，为什么运行不了。