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

老师，为啥这个报错啊

#encoding=utf-8
from threading import Thread
from time import sleep
class Account:
    def __init__(self,money,name):
        self.money=money
        self.name=name
#模拟提款操作
class Drawing(Thread):
    def __init__(self,drawingNum,account):
        Thread.__init__(self)
        self.drawingNum=drawingNum
        self.account=account
        self.expenseTotal=0
    def run(self):
        lock.acquire()
        if self.account.money-self.drawingNum<0:
            return sleep(1)
        sleep.account.money-=self.drawingNum
        self.expenseTotal+=self.drawingNum
        lock.release()
        print(f"账户:{self.account.name},余额是:{self.account.money}")
        print(f"账户:{self.account.name},余额是:{self.expenseTotal}")
if __name__=="__main__":
    a1=Account("小高",100)
    lock=Lock()
    draw1=Drawing(80,a1)    #定义取钱线程对象
    draw2=Drawing(80,a1)
    draw1.start()           #你取钱
    draw2.start()           #另一个人取钱#

老师，我这个没有Lock（）报错是怎么回事呀，好多次都是太远了

#encoding=utf-8
from threading import Thread
from time import sleep
def func1(name):
    for i in range(4):
        print(f"线程：{name}:{i}")
        sleep(1)  #每打一个暂停一下
if __name__=="__main__":
    print("主线程，start")
    #创建线程
    t1=Thread(target=func1,args=("t1,"))
    t2=Thread(target=func1,args=("t2,"))
    #启动线程
    t1.start()
    t2.start()
    print("主线程，end")

老师，为什么我这个报错了呀，还有为啥第6行要加f啊？

为什么我的守护线程没有实现效果

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},start')
        for i in range(3):
            print(f'{self.name}线程：{i}')
            time.sleep(3)
        print(f'{self.name}线程，end')

if __name__ == '__main__':
    print('主线程start')

    t1 = MyThread('t1')
    t2 = MyThread('t2')
    t1.daemon =True

    t1.start()
    t2.start()
    #等t1,t2线程结束才会继续执行主线程



    print('主线程end')

我的主线程都已经结束了，为什么t1还是会继续执行？？？

前面这个‘f’什么作用？

import threading


#用方法包装
def fun1():
    print('f线程，start')
    for i in range(3):
        print('线程：{i}')
    print('f线程，end')

#创建线程，使用threading方法
t1 = threading.Thread(target=fun1,args=('t1',))
t2 = threading.Thread(target=fun1,args=('t2',))

if __name__ == '__main__':
    print('主线程，start')
    t1.start()
    t2.start()
    print('主线程，end')
 
 老师这个是什么原因报错的

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


def func1(name):
    print(f"线程{name},start")
    for i in range(3):
        print(f"线程:{name},{i}")
        sleep(5)
    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")

老师 这个是怎么回事呢

# 服务器端：一个线程专门发送消息，一个线程专门接收消息。
# 客户端：一个线程专门发送消息，一个线程专门接收消息。
# 结合多线程实现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的时候