这个为什么用targe和targs？

run方法中为什么不是lock.

而是lock1,这个不是实例对象吗？

老师你好，我的问题有两个：

1、我的运行结果和视频中演示的不一样（数据长度那块），为什么最后依然实现了相同的效果（我和老师用的是不同的文件，是否和文件有关？）

2.

if len(recv_data[0]) < 516:
    break

关于这行代码执行的时候，我第截图中显示“数据长度：2”远小于代码中的516，不应该直接执行“break”语句退出吗为什么还能继续往下执行？

# coding=utf-8
from socket import *
import struct
filename = "1.png"
server_ip = "192.168.198.1"  # 服务器
send_data = struct.pack(f"!H{len(filename)}sb5sb",
                        1, filename.encode(), 0, "octet".encode(), 0)
s = socket(AF_INET, SOCK_DGRAM)  # 创建套接字对象
s.sendto(send_data, (server_ip, 69))  # 将数据包发送给服务器69端口
f = open("1.png", "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(f"操作码：{caozuoma},ACK:{ack_num},"
          f"服务器随机端口：{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))  # 回复确认包

我的截图：

视屏中：

我使用的文件：

老师，您好！
  我的电脑是mac版的，我下载了VSCode之后，为什么找不到运行按钮呢？

老师，请问，视频中老师一直提到IO操作，讲义中也提到IO操作可以进行阻塞，IO操作是什么呢，之前好像是学文件的时候提到过，但是没有细说

老师，下边边这个接收信息，没看懂两个红线是什么意思？怎么接收了recv_data索引[0],又from来自于recv_data索引[1]呢？为什么要安排索引[0],[1]呢？

好像出问题了

from threading import Thread
import threading
def func1(name):
    #函数中使用全局变量
    global count
    for i in range(100):
        count+=1
if __name__=="__main__":
    count=0
    t_list=[]
    for i in range(10):
        t=Thread(target=func1,args=(f"t{i+1},"))
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print(count)

搞不懂这个哪里错了，没看明白

老师，①为什么要加'f'？（加f的作用是什么？）

          ②要在什么时候加‘f’?

代码区：

#join() 的目的是让主线程照顾到子线程
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')

if __name__ == '__main__':
   
    print(threading.currentThread())
    #开始时间
    start = time()
   
    '''
    #打印显示线程
    print(threading.currentThread())
    #创建线程
    t1 = Thread(target=func1, args=('t1',))
    t2 = Thread(target=func1, args=('t2',))
    #开始时间
    start = time()
    #启动线程
    t1.start()#注意：不要再启动线程后就立即jion(),否则就串行了，失去了并发的意义
    t2.start()
    #等待t1线程执行完再往下执行
    t1.join()
    #等待t2线程执行完再往下执行
    t2.join()
    # func1('t1')#对比可以看出而这效率的差别
    # func1('t2')
    '''
    
    thread_list = []
    for i in range(100):
        t = Thread(target=func1, args=(f't{i+1}',))
        t.start()
        thread_list.append(t)
    
    for t in thread_list:
        t.join()
    #结束时间
    end = time()-start
    print(end)

from socket import *
import struct
filename = "dijia.jpg"
sever_ip = "192.168.1.4"
send_date = struct.pack("!H%dsb5sb" % len(filename),1,filename.encode(),0,"octet".encode(),0)
s = socket(AF_INET,SOCK_DGRAM)
s.sendto(send_date,(sever_ip,69))
f = open(filename,"ab")
#while True:
recv_date = s.recvfrom(1024)
print(recv_date)
    #caozuoma,acknum = struct.unpack()

老师，打印加载不出来，麻烦您帮我看看，还有老师我想请问一下就是从客户端发送下载请求到服务器，客户端是计算机嘛还是这个tftp呢？这个有点混；还有就是老师"!H%dsb5sb"这个里面为什么不写9s呢？因为后面不是还有一个1嘛？应该再写一个H啊，麻烦老师了

send_date = struct.pack("!H%dsb5sb" % len(filename),1,filename.encode(),0,"octet".encode(),0)

没有理解为什么要重写run，是有什么特殊的含义吗

请问老师，多线程是在一个CPU上执行，还是在多个cpu切换执行

import struct
from socket import *

filename = "catdog.jpg"
server_ip = "192.168.1.101"
cmb_buf = struct.pack("!H%dsb5sb"%len(filename), 1, filename.encode(), 0, b"octet", 0)
udpsock = socket(AF_INET, SOCK_DGRAM)
udpsock.sendto(cmb_buf, (server_ip, 69))
f = open(filename, "ab")
while True:
    recvdate = udpsock.recvfrom(1024)
    caozuoma, ACK = struct.unpack("!HH",recvdate[0][:4])
    rand_port = recvdate[1][1]
    if caozuoma == 5:
        print("文件不存在")
    print("操作码是：%d，块编号是：%d，服务器随机端口是：%d，字节长度为：%d"
          %(caozuoma, ACK, rand_port, len(recvdate[0][4:])))
    if len(recvdate[0][4:])<516:
        break
    ack_date = struct.pack("1HH", 4, ACK)
    udpsock.sendto(ack_date, (server_ip, rand_port))

老师，我没有下载那个文件下载器，没办法运行

# # Python中的进程池相当于一个容器，里面存放指定数量的进程，当池中有空闲进程时，就可以拿来使用
# # 若没有空闲进程，则需要等待
import os
from multiprocessing import Pool
from time import sleep

def func1(name):
    print(f"进程id:{os.getpid()}-{name}")
    sleep(2)
    return name

def func2(args):
    print(args)

if __name__ == '__main__':
    # 创建进程池对象
    pool = Pool(5)
    # callback=func2 -> 执行完func1后将返回值传给func2
    pool.apply_async(func=func1, args=("sxt1",), callback=func2)
    pool.apply_async(func=func1, args=("sxt2",), callback=func2)
    pool.apply_async(func=func1, args=("sxt3",), callback=func2)
    pool.apply_async(func=func1, args=("sxt4",))
    pool.apply_async(func=func1, args=("sxt5",))
    pool.apply_async(func=func1, args=("sxt6",))
    pool.apply_async(func=func1, args=("sxt7",))
    pool.apply_async(func=func1, args=("sxt8",))

    # 使用完进程池关上
    pool.close()
    # 等待所有子进程执行完
    pool.join()
#

老师，程序运行结果如下，想问下，进程池中sxt1还没有执行func2打印sxt1，说明sxt1还在使用（不处于空闲状态），但是该进程为什么却被sxt6再次使用了呢

#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】信息呢？是约定俗成吗？是不是每次写代码都要这样写呀