from multiprocessing import Process

def loop(n):
    for i in range(n):
        print("子进程开始，第{0}次".format(i))

if __name__ == '__main__':
    p = Process( target = loop , args = (5,),name = '进程-1')
    for i in range(5):
        print('父进程开始')
        p.start()
    p.join()

运行结果显示：报错：不能调用一个进程两次

def loop(n):
    for i in range(n):
        print("子进程开始，第{0}次".format(i))
if __name__ == '__main__':
    for i in range(5):
        print('父进程开始')
        loop(5)
        
打印的结果正常

老师可否解释下第一段代码报错的原因

我在这一节不引用sleep发现就可以让两个厨师正常运作了，这是什么原因

from socket import *
import struct

filename='1.jpg'
server_ip='10.255.181.170'
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')  #a表示 没有这个文件创建一个新的filename文件  b 表示以二进制形式打开
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:    #int表示转化
        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])< 516:
        break
    ack_data =struct.pack('!HH', 4, ack_num)
    s.sendto(ack_data, (server_ip, rand_port))

老师我不知道哪边错了

myq = Queue(maxsize=4)
myq.put(1)
myq.put('a')
myq.put('b')
myq.put(4)
print(myq.get())
print(myq.get())
print(myq.get())
print(myq.get())

maxsize=3时候，一直在等待，maxsize=4就可以输出，是不是只要maxsize的长度小于输出的长度都会在等待，而不会将maxsize规定最大长度内的内容先输出？

为什么会报意外缩进的错误，是哪里错了呢？

请问老师，线程力queue不需要传mq而进程需要，是不是因为进程不共享堆，所以需要告诉mq的地址呀/

老师为什么下面那个方法里面不用再一次全局声明变量count也能用

一、代码

# 实现TFTP客户端
from socket import *
import struct
filename = 'ren.jpg'
server_ip = '192.168.1.6'
# 要将字符串转成字节流才能在网络发送接收
send_data = struct.pack('!H7sb5sb', 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
    f.write(recv_data[0][4:])
    if len(recv_data[0]) < 516:
        break
    ack_data = struct.pack('!HH', 4, ack_num)
    s.sendto(ack_data, (server_ip, rand_port))

二、运行结果

三、疑问

老师请问，我的代码有问题吗？或者图片存放路径有问题？谢谢老师

老师，如果把join（）方法放进去，好像守护线程就失效了，是不是写的代码有问题，请老师看看问题出在哪里？

import threading
from threading import Thread
from time import time,sleep



def fun(name):
    print(threading.currentThread())
    print(f"my name is {name}")
    sleep(3)


if __name__ == '__main__':
    threading_list = []
    starttime=time()
    print("start")
    print(threading.currentThread())
    for i in range(100):
        t=Thread(target=fun,args=(f"T{i}",))
        t.setDaemon(True)
        t.start()
        threading_list.append(t)
    for t in threading_list:
        t.join() 
    print(time()-starttime)
    print("end")

老师，报错没有传name之后，为什么加了args=p1之后就行了

老师，显示AttributeError: module 'asyncio' has no attribute 'create_task'，敲代码是也找不见这个方法

import asyncio
import functools    #函数工具栏

async def compute(x,y):
    print(f'compute:{x}+{y}...')
    await asyncio.sleep(1)
    return x+y

async def print_sum(x,y):
    #创建task
    task = asyncio.create_task(compute(x,y))
    #task绑定回调函数
    task.add_done_callback(functools.partial(end,x,y))
    #释放cpu的使用
    await asyncio.sleep(0.1)
    print('--------------print_num继续执行')
    for i in range(10000):
        if i % 500 == 0:
            print(i)
            await asyncio.sleep(0.1)

#定义回调函数
def end(n,m,t):
    print(f'{n}+{m}={t.result()}')

if __name__ == "__main__":
    loop = asyncio.get_event_loop()

    loop.run_until_complete(print_sum(1,2))
    loop.close()

from threading import Thread
from time import sleep,time
import threading
#方法包装

#创建普通方法

def func1(name):
    print(threading.currentThread())
    print (f"Threading:{name} start")
    sleep(3)
    print (f"Threading:{name} end")
print(threading.currentThread())
#创建线程
t1=Thread(target=func1,args=("t1",))
t2=Thread(target=func1,args=("t2",))

#开始时间
start=time()
#开始线程
t1.start()
t2.start()
#结束时间
end=time()-start
print(end)

老师 这里这个时间0.00096是在 Threading：t1 start 后边才打印的   视频中老师不是说过 这个时间是在子线程开始之后就打印了  并没有将子线程的方法算到这个时间里边  这不是矛盾了吗

为什么我写的值没有在print里面输出                                    

老师这个在pycharm.上向调试助手发送信息为什么总是处于一总被 动的状态?即使把发送数据的代码写在接受的前边还是一样的效果。一直都是只有调试助手发送过信息后pycharm上才能接受到，加上while True之后有时都发送不出去信息了，而来自调试助手到信息可以收到,助手上也不显示pycharm上发送到信息,这是属于一种数据泄露吗?

# ！/user/bin/env python3
# -*- coding: utf-8 -*-

from socket import *
tcpSock = socket(AF_INET, SOCK_STREAM)  # 等待连接，如果一直连接就不能收发数据
tcpSock.bind(('', 7352))
tcpSock.listen(5)
newSock, clientAddr = tcpSock.accept()  # 等待连接，返回两个对象 其中一个为套接字
while True:
    send_data = input('输入需要发送的内容:')
    data = newSock.recv(1024)
    newSock.send(send_data.encode('gb2312'))  # tcp不需要再写接受方的地址和端口号，3次握手已建立连接
    print('来信人:', data.decode('gb2312'))
newSock.close() # 新客户端一关闭意味着不再进行服务
tcpSock.close() # 一关闭意味着整个程序不再进行连接了