为什么这句话还没打完，就插进来了？

正常的是这种

import threading
from threading import Thread
from time import sleep


class MyThread(Thread):
    def __init__(self, name):
        Thread.__init__(self)
        self.name = name

    def run(self):
        self.printf()

    def printf(self):
        print(f"线程{self.name}-start", threading.current_thread())

        for i in range(0, 5):
            print(i)
            sleep(3)

        print(f'线程{self.name}-end')


if __name__ == '__main__':
    print('主线程-start', threading.current_thread())

    t1 = MyThread('t1')
    t2 = MyThread('t2')

    t1.daemon = True
    t2.daemon = True

    t1.start()
    t2.start()

    print('主线程-end')

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

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

老师，

TCP和UDP里面的最大接收数
client_socket.recv(1024)

这个最大接收数和接收缓冲区的最大容量有关系吗

# 服务端接收代码

from socket import *
from time import time


s = socket(AF_INET, SOCK_DGRAM)  # 创建UDP套接字

s.bind(('127.0.0.1', 1660))
while True:
    print('准备接收数据，接收中...')
    recv_data = s.recvfrom(1024)
    content = recv_data[0].decode("utf-8")
    print(f'消息接收成功，消息：{content}, 发送方IP：{recv_data[1][0]}， 发送方端口号：{recv_data[1][1]}')

    if content == 'Bye!':
        s.close()  # 关闭UDP套接字连接
        break
print("\n\n数据接收完毕！")

# 客户端发送代码

from socket import *
from random import randint
from time import sleep

content = ['Hello World!', '人生苦短，我用Python', 'PEP-8', 'UDP', 'TCP/IP', 'Bye!']

s = socket(AF_INET, SOCK_DGRAM)  # 创建UDP套接字

for data in content:
    # data = input("请输入需要发送的内容：")
    time = randint(2, 5)
    print(f'{time}s后开始发送消息...')
    sleep(time)
    s.sendto(data.encode('utf-8'), ('127.0.0.1', 1660))
    print(f'消息长度：{len(data)}, 消息已发送！')
else:
    print("\n\n数据发送完毕！")

是所有定义的类，里面定义的方法都得是run吗？感觉有点限制啊

from multiprocessing import Manager, Process


def fun(name,mg_list,mg_dic):
    mg_dic[name] = '尚学堂'
    mg_list.append('你好')

if __name__ == '__main__':
    #创建进程管理器
    with Manager() as mg:
        mg_list = mg.list()
        mg_dic = mg.dict()
        print(mg_list)
        print(mg_dic)
        p1 = Process(target=fun,args=('p1',mg_list,mg_dic))
        p1.start()
        # p1.join()#等p1进程结束后，主进程继续执行
        print('执行进程启动后~~')
        print(mg_list)
        print(mg_dic)

老师，为什么不写p1.join()会报系统找不到文件的错误呢

老师，我输入了一个正确的电脑ip，但是为什么显示地址无效，两个电脑是不同wifi下的，这个连接不上得原因是什么？可能是因为对方开了防火墙嘛?

import time
from threading import Thread


class myThread(Thread):
    def __init__(self,name):
        Thread.__init__(self)
        self.name = name

    def run(self):
        print(f'线程{self.name}启动')
        for i in range(5):
            time.sleep(1.0)
            print(f'线程{self.name}:{i}')
        print(f'线程{self.name}结束')
if __name__ == '__main__':
    print('主线程启动了！')
    #创建线程
    t1 = myThread('t1')
    t2 = myThread('t2')
    t1.daemon = True
    t1.start()
    t2.start()

    print('主线程结束了！')

老师，为啥我创建t1和t2两个子线程，其中t1设置为守护线程，主线程结束后t1没有立马结束啊

#coding=utf-8
from socket import *
from threading import Thread
def recv_data():
    while True:
        #读取客户端的消息
        redata=tcp_client_socket.recv(1024).decode("gbk")
        #将消息输出到控制台
        print(f"服务端说：{redata}")
        if redata=="end":
            break
def send_data():
    while True:
        #获取控制台信息
        msg=input(">")
        #向服务器发数据
        tcp_client_socket.send(msg.encode("gbk"))

if __name__=="__main__":
    #创建Socket
    tcp_server_socket=socket(AF_INET,SOCK_STREAM)
    tcp_server_socket.bind(("",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_server_socket.close()
    tcp_client_socket.close()

老师，又是这个报错，是为啥呀，为啥老师那样写就是对的

#coding=utf-8
from socket import *
s=socket(AF_INET,SOCK_STREAM)
s.bind(("127.0.0.1",8899))  #本机监听8899端口
s.listen(5)
print("等待接收连接！")
client_socket,client_info=s.accept()
#client_socket表示新的客户端,client_socket表示新的客户端的ip及port
print("一个客户端建立连接成功！")
while True:
    #读取客户端消息
    redata = client_socket.recv(1024)
    recontent=redata.decode('gbk')
    print(f"客户端说：{recontent}")
    if redata=="end":
        break
        #获取控制台信息
        msg=input(">")
client_socket.send(msg.encode("gbk"))
client_socket.close()
s.close()

老师，为什么我这个从服务端给客户端发消息但是客户端那边没有显示

#coding=utf-8
from socket import *
s=socket(AF_INET,SOCK_STREAM)
s.connect(("127.0.0.1",8899))   #连接服务器端
while True:
    msg=input(">")       #向服务器发送数据
    s.send(msg.encode("gbk"))
    if msg=="end":
        break
    #接收服务器端数据
    redata=s.recv(1024)
    print("服务器端说：",redata.decode("gbk"))
s.close()

#coding=utf-8
from socket import *
from threading import Thread
s=socket(AF_INET,SOCK_DGRAM)
s.bind(("127.0.0.1",6666))
#不停接收
def recv_data():
    while True:
        redata = s.recvfrom(1024)  # 1024表示本次接收的最大字节数
        print(redata)
        print(f"收到远程信息：{redata[0].decode('gbk')},from{redata[1]}")
        if redata == "88":
            print("结束聊天！")
            break
def send_data():
    while True:
        data = input("请输入:")
        addr = ("127.0.0.1", 8080)
        s.sendto(data.encode("gbk"),addr)
if __name__=="__main__":
    #创建两个线程
    t1=Thread(target=send_data)#创建线程时的函数名不用加班括号
    t2=Thread(target=recv_data)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

老师，我这个报错了，但是我对照了一下老师的两个文件id也是一样的呀

老师，有个问题奥，为什么当循环结束了之后程序还在一直运行中啊？

#coding=utf-8
from socket import *
s=socket(AF_INET,SOCK_DGRAM)    #创建套接字
#绑定接收信息端口
s.bind(("127.0.0.1",6666))  #ip地址和端口号，端口大于1024
print("等待接收数据！")
redata=s.recvfrom(1024)#1024表示本次接收的最大字节数
print(redata)
print(f"收到远程信息：{redata[0]},from{redata[1]}")
s.close()

老师，我想知道第9行为什么是这样写呀，

f"收到远程信息：{redata[0]},from{redata[1]}")

这个表示啥意思呀，为什么就是收到来自redata【1】的redata【0】信息呢？是约定俗成吗？是不是每次写代码都要这样写呀

#coding=utf-8
import threading
import time
def chihuoguo(name):
    print(f"{name}已经启动")
    print(f"小伙伴{name}已经进入就餐状态")
    time.sleep(1)
    event.wait()
    print(f"{name}收到通知了")
    print(f"小伙伴{name}开吃咯")
if __name__=="__main__":
    event=threading.Event
    #创建新线程
    thread1=threading.Thread(target=chihuoguo,args=("tom",))
    thread2=threading.Thread(target=chihuoguo,args=("cindy",))
    thread1.start()
    thread2.start()
    time.sleep(10)
    print("通知来了，开吃！")
    event.set()

老师，为啥这个报错啊