from socket import *
from threading import Thread


def recv():
    while True:
        re_data = tcp_client_socket.recv(1024)  # 最大接受字节
        a = re_data.decode('gbk')
        print(f"收到信息:{a}")
        if a == 'end':
            print('关闭服务端接收')
            break


def send():
    while True:
        msg = input('请输入：')
        tcp_client_socket.send(msg.encode('gbk'))
        if msg == 'end':
            print('结束')
            break


if __name__ == '__main__':
    tcp_server_socket = socket(AF_INET, SOCK_STREAM)  # 建立TCP套接字
    tcp_server_socket.bind(("", 8899))  # 绑定本机监听8899端口
    tcp_server_socket.listen()  # 最大监听数量
    print('等待建立连接')
    tcp_client_socket, host = tcp_server_socket.accept()
    print('连接成功')
    t1 = Thread(target=recv)
    t2 = Thread(target=send)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    tcp_server_socket.close()
    tcp_client_socket.close()
    
    
    
    
    
from socket import *
from threading import Thread


def recv():
    while True:
        re_data = tcp_client_socket.recv(1024)  # 最大接受字节
        a = re_data.decode('gbk')
        print(f"收到信息:{a}")
        if a == 'end':
            print('关闭客户端接收')
            break


def send():
    while True:
        msg = input('>>>')
        tcp_client_socket.send(msg.encode("gbk"))
        if msg == 'end':
            print('结束')
            break


if __name__ == '__main__':
    tcp_client_socket = socket(AF_INET, SOCK_STREAM)
    tcp_client_socket.connect(("127.0.0.1", 8899))

    t1 = Thread(target=recv)
    t2 = Thread(target=send)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    tcp_client_socket.close()

这个咋结束不了

发送方：

from socket import *
# #创建套接字Socket
s = socket(AF_INET,SOCK_DGRAM)
# 绑定一个端口
s.bind(('', 8788))   
# 发送数据
s.sendto(b"abc",('192.168.2.125',8585))      
# 等待接收数据
redata = s.recvfrom(2048)  
print(redata[0].decode("gb2312")) 
s.close()

接收方：

from socket import *
# 创建套接字Socket
udpSock = socket(AF_INET,SOCK_DGRAM)
# 绑定一个端口
udpSock.bind(('', 8585))   
while True:
    # 等待接收数据
    reData = udpSock.recvfrom(1024)
    print(reData[0].decode())
    data = input("请输入：")
    # 发送数据
    udpSock.sendto(data.encode(),reData[1])
udpSock.close()

先运行接收方，再运行发送方，为什么接收方没有运行结果？

发送方

接收方

这个地方为什么没有换行

老师这里一个是线程一个是进程，为什么在第一张图线程中，创建mq = Queue()然后，可以在前面子线程方法中直接用mq对象，而第二个进程中也同样mq=Queue（）创建对象，为啥就说不能在子线程中用mq对象？？？？？？

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

那里为什么可以不用加else

老师，运行后目录里面有文件了，但是不能加载图片，这是为什么呀？

from multiprocessing import Process,current_process,Queue
#from queue import Queue
import os
def func(name,mq):
    print("进程ID{0}，获取了数据：{1}".format(os.getpid(),mq.get()))
    mq.put("123")


if __name__=="__main__":
    print("进程ID：{0}".format(current_process().pid))
    mq=Queue()
    mq.put("sxt")
    p1=Process(target=func,args=("p1",mq))
    p1.start()
    p1.join()
print（mq.get()）

如果照函数的传参理论，这里的mq传递到函数的形参中去后，即使改变形参也不会影响实参，mq中就什么也没有

还是说子进程和父进程一样是对mq队列这个全局变量进行处理呢

老师，这个EVENT事件的作用，相比原来的 旗子 是不是主要就多了个event.wait()，我能不能理解为他的作用是当evnet.claer（）后，将event.wait所在进程阻断使用，停止了这个进程？直到event.is_set（）重新成立后才能再次执行这个进程？

老师你说的单线程内可以实现并发的效果，意思，协程也是假并发，那我是不是能理解为他和GIL锁下的多线程的主要区别，就是少了个IO操作，并把所有方法放在一个线程里。

还有老师我不太明白，这个缺点里说阻塞，这个IO操作为啥会阻塞，图片里，不是把IO后的操作剥离出来，放在最后面了吗，还是说协程最后也是不执行IO操作的？

import threading
from socket import *

def receivedate():         # 接受数据
    s = socket(AF_INET, SOCK_DGRAM)
    s.bind(("192.168.1.101", 8895))
    while True:
        date = s.recvfrom(1024)
        print(date[0].decode())
    b.close()
def senddate():   # 发送数据
    s = socket(AF_INET, SOCK_DGRAM)
    while True:
        date = input("请输入")
        print(date)
        s.sendto(date.encode(), (receivedate().date[1][0], receivedate().date[1][1]))
    s.close()
if __name__ == '__main__':
    t1 = threading.Thread(target=receivedate)
    t2 = threading.Thread(target=senddate)
    t1.start()
    t2.start()

python3.7 老师怎么设置接收别人的消息，感觉线程锁也不能用

# coding=utf-8
# 通过进程池创建进程
from multiprocessing import Pool
import random
import time

def test(num):
    print(random.random() * num)
    time.sleep(3)


if __name__ == '__main__':
    po = Pool(3)
    print("进程池创建...")
    for i in range(10):
        po.apply_async(test, (i,))  # 非阻塞方式
    po.close()
    po.join()

老师，我想问下为什么我把函数命名为test就会报错

但定义为work就能运行

为什么直接把函数体recv_data()和send_data()传入Thread里面,可以连接成功，但是为什么无法交互

#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也是一样的呀

老师，你好。我在进行两个网段的信息通信时，接受方的信件标志是红色，这是为什么呀？