if __name__ == '__main__':
    # 创建进程列表
    t_list = []
    mq = Queue()
    mq.put('1')
    mq.put('2')
    mq.put('3')
    # 循环创建进程
    for i in range(3):
        t = MyProcess('p{}'.format(i), mq)
        t.start()
        t_list.append(t)
    # 等待进程结束
    for t in t_list:
        t.join()
    print(mq.get())
    print(mq.get())
    print(mq.get())

老师您好，请问，上面这段代码为什么要写两个for循环？不是很理解。第一个for循环运行了三个进程，然后第二个for循环依次等待三个进程？我不理解的是，第一个for循环是否会将三个进程都运行完，然后再执行第二个for循环，依次等待?如果是这样，第一个for循环运行后，三个进程都运行了，还要第二个for循环有什么意义？ 如果稍作修改代码，如下，会有何问题？

if __name__ == '__main__':
    # 创建进程列表
    t_list = []
    mq = Queue()
    mq.put('1')
    mq.put('2')
    mq.put('3')
    # 循环创建进程
    for i in range(3):
        t = MyProcess('p{}'.format(i), mq)
        t.start()
        t_list.append(t)
        t.join()
    print(mq.get())
    print(mq.get())
    print(mq.get())

老师为什么我再vscode上不能同时运行两个文件的？是软件的问题吗？

发送方：

from socket import *
s=socket(AF_INET,SOCK_DGRAM)
s.bind(('',7758))
date=input('请输入要发送的内容：')
s.sendto(date.encode('gb2312'),('192.168.31.158',8585))
redata=s.recvfrom(1024)  # 2048代表最大接受的字节
print(redata[0].decode('gb2312'))
s.close()

接收方：

from socket import *
udpSock=socket(AF_INET,SOCK_DGRAM)
udpSock.bind(('',8585))
while True:
    recvData=udpSock.recvfrom(1024)
    udpSock.sendto(recvData[0],recvData[1])

udpSock.close()

import multiprocessing
import time


def func1(conn1):
    sub_info="Hello!"
    print(f"进程1--{multiprocessing.current_process().pid} 发送参数{sub_info}")
    time.sleep(1)
    conn1.send(sub_info)
    print(f"来自线程2:{conn1.recv()}")
    time.sleep(1)

def func2(conn2):
    sub_info="你好！"
    print(f"进程2--{multiprocessing.current_process().pid} 发送参数{sub_info}")
    time.sleep(1)
    conn2.send(sub_info)
    print(f"来自线程1：{conn2.recv()}")
    time.sleep(1)



if __name__ == '__main__':
    #创建管道
    conn1,conn2=multiprocessing.Pipe()
    #创建子进程
    process1=multiprocessing.Process(target=func1,args=(conn1,))
    process2=multiprocessing.Process(target=func2,args=(func2,))
    #启动进程
    process1.start()
    process2.start()

D:\Anaconda\anaconda3\envs\python\python.exe D:/Pycharm/python学习/python系统化学习/网络与并发编程/13.Pipe实现进程间的通信.py

进程2--13740 发送参数你好！

进程1--68200 发送参数Hello!

Process Process-2:

Traceback (most recent call last):

  File "D:\Anaconda\anaconda3\envs\python\lib\multiprocessing\process.py", line 315, in _bootstrap

    self.run()

  File "D:\Anaconda\anaconda3\envs\python\lib\multiprocessing\process.py", line 108, in run

    self._target(*self._args, **self._kwargs)

  File "D:\Pycharm\python学习\python系统化学习\网络与并发编程\13.Pipe实现进程间的通信.py", line 17, in func2

    conn2.send(sub_info)

AttributeError: 'function' object has no attribute 'send'

这边哪里有问题？

怎么解决

老师我代码运行的时候一直显示文件不存在怎么回事

import struct
from socket import *
filename='dong.jpg'
server_ip='192.168.43.205'
send_data=struct.pack('!H%dsb5sb'% len(filename),1,filename.encode(),0,'octet'.encode(),0)
s=socket(AF_INET,SOCK_DGRAM)
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])  #获取数据块模号
    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)))
    f.write(recv_data[0][4:])  #将数据写入
    if len(recv_data[0])<156:
        break
    ack_data=struct.pack('#HH',4,ack_num)
    s.sendto(ack_data,(server_ip,rand_port))  #回复ACK确认包

老师，我跟着老师敲的代码为什么会出现这种情况了：

代码如下：

socket *
s = socket(AF_INET,SOCK_DGRAM)
s.bind((,))
s.sendto(,(,))
edata = s.recvfrom()
(edata[].decode)

from socket import *
a = socket(AF_INET,SOCK_DGRAM)
a.bind(("",8080))
while True:
    redata1 = a.recvfrom(1024)
    a.sendto(redata1[0],redata1[1])

a.close()

要怎么办才能连通呢

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

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

from threading import Thread
from time import sleep

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

    def run(self): #此处必须使用run方法
        print(f'Threading:{self.name}start')
        sleep(3)

if __name__ =='__main__':
    t1 = MyThread('t1')

    t1.start()

下面调用主函数的时候为什么报

    assert group is None, "group argument must be None for now"

AssertionError: group argument must be None for now

不传参数，就返回 Threading:-1start

def func(n):
    for i in range(n):
        yield 2*i

g = func(10)

for i in g:
    print(next(g))
    # print(i)

from queue import Queue
from threading import Thread
from time import sleep

def producter():
    num = 1
    while True:
        if queue.qsize()<5:
            print(f"生产{num}号，手机")
            queue.put(f"手机：{num}号，")
            num+=1
        else:
            print("库存满了，请消费")
        sleep(1)


def consumer():
    while True:
        print(f"获取手机：{queue.get()}")
        sleep(1)

if __name__ == '__main__':
    queue=Queue()
    p = Thread(target=producter())
    p.start()
    c = Thread(target=consumer())
    c.start()
    c2 = Thread(target=consumer())
    c2.start()

消费线程没有启动，好奇怪

老师我想问一下，服务器每次能能发512B的数据，那么我们平时下载东西，比如说用迅雷下载电影，网速好的话，每秒都能达到十几M，为什么丝毫没感到慢呢，而且下载速度和带宽也有关系，麻烦解释一下！

#incoding=UTF-8
#方法包装-启动多线程
from threading import Thread
from time import time,sleep


def func1(name):
    print("Threading:{}start".format(name))
    sleep(3)
    print("Threading:{}end".format(name))

if __name__ == '__main__':
    #开始时间
    start = time()
    #创建线程列表
    t_list = []
    #循环创建线程
    for i in range(10):
        t = Thread(target=func1,args=('t{}'.format(i),))
        t.start
        t_list.append(t)
    #等待线程结束
    for t in t_list:
        t.join()
    #计算使用时间
    end=time()-start
    print(end)

根据PDF敲的，这是什么情况呢？

#coding = 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 __del__(self,drawingNum,account):
        Thread.__init__(self)
        self.drawingNum = drawingNum
        self.account = account
        self.expenseTotal = 0

    def run(self):
        if self.account.money < self.drawingNum:
            return
        sleep(1)    #判断玩可以取钱，则阻塞，就是为了测试发生冲突问题
        self.account.money -= self.drawingNum
        self.expenseTotal += self.drawingNum
        print(f'账号{self.account.name},余额是{self.account.money}')
        print(f"账号{self.account.name},总共取了{self.expenseTotal}")

if __name__ == '__main__':
    a1 = Account(100,'gaoqi')
    draw1 = Drawing(80, a1)  #定义一个取钱线程
    draw2 = Drawing(80, a1)  #定义一个取钱线程
    draw1.start()
    draw2.start()

老师，这个哪里出错了？

t1 = Thread(target=func1, args=('t1',))
t2 = Thread(target=func1, args=('t2',))

老师这里args=（）这个括号里为什么要有个逗号

老师，你这里怎么实现群体缩进的？？

老师，你这里怎么实现群体缩进的？？