老师你好，请问转换后发生乱码怎么处理呢？

import struct
from socket import *
filename = 'zzbds.azw3'
server_ip = '100.98.57.142'
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('f:\\1\\a.txt', 'ab')    # a代表以追加模式打开，b代表以二进制模式打开  'f:\1\a.png'

while True:
    recv_data = s.recvfrom(2048)    # 接受数据
    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[0])))
    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))  # 回复ACK确认包

老师，请问，我们之前学的位置参数和命名参数，x,y传给m,n按照位置，这里的t为什么刚好是传入的task呢

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

老师，请问并发编程里，这种循环结构是怎么执行呢，还是像之前一样，i=0把循环体执行完，再i=1,循环体中的语句从上往下执行完？

老师，请问，前面讲到，进程内部多个子任务称作线程，那主线程又是什么定义呢

老师，请问，没有明白生成器是什么意思，为什么调用这个函数返回的是一个生成器呢

老师，Mac 版本的网络助手怎么用呢？需要填目标IP和目标端口吗？

老师，这个0.001s的时间是代码运行到哪里的时间呢

老师，请问，这里的f是什么意思，必须要加上的吗

from threading import  Thread
from time import sleep

#创建类
class Threading1(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        print(f'threading:{self.name}start')
        sleep(1.5)
        print(f'threading:{self.name}end')
if __name__=='__main__':
    #创建线程
    for i in range(20000):

       t=Threading1(f't{i+1}')
       #设置当前进程为守护线程
       t.setDaemon(True)
       t.start()
    print('主进程结束了！！！！！！')

问题1：如果这样的话守护线程不是没有意义了吗？

问题2：如果守护线程的作用到底是什么？

请老师解答 谢谢

老师本章资料好像提取码给错了，提前不了。麻烦把提取码再发一下

'''
验证运行速度，用循环增加多个线程
'''
#调用创建线程模块
from threading import Thread
from time import sleep
from threading import Lock
#定义方法
def f1(self):
    print(f'threading:{self}start',)
    sleep(3)
    #获取锁
    lock.acquire()
    global count
    for i in range(1000000):
        count+=1
    sleep(10)
    lock.release()
    print(f'threading:{self}end',)
#创建线程
if __name__=='__main__':
    lock=Lock()
    count=0
    t_list=[]
    for i in range(3):
        t=Thread(target=f1,args=(f't{i+1}',))
        t.setDaemon(True)
        t_list.append(t)
        t.start()

    for t in t_list:
        t.join()
    print(count)

为什么这个代码end可以输出来，我不是先守护线程，怎么还要运行join()呢

from threading import Thread
from time import sleep


# 类实现-多线程
class MyThread(Thread):
    def __init__(self, name):
        Thread.__init__(self)
        self.name = name

    def run(self):
        print(f"Threading:{self.name} start")
        sleep(3)
        print(f"Threading:{self.name} end")


if __name__ == "__main__":

    # 创建线程
    for i in range(10):
        t = MyThread(f"t{i + 1}")
        # 设置当前进程为  守护线程
        t.setDaemon(True)
        t.start()
    print("主进程结束！")

问题1.这里边运行出来只有Threading:t1 start。。。，但是end没运行，我可不可以理解为主进程中只有run（）中的第一行代码:

print(f"Threading:{self.name} start")

是主进程，第二行以下都是子进程，所以守护线程意思就是只运行run（）中的第一行代码？

请老师解答，谢谢

lt = [1, 3, 5, 6]
a = len(lt)
print("a = ", a)
print("len(lt) = ", len(lt))
print("id(a) = ", id(a))
print("id(len) = ", id(len(lt)))
lt.pop()
print('*'*50)
print("a = ", a)
print('len(lt) = ', len(lt))
print("id(a) = ", id(a))
print("id(len) = ", id(len(lt)))

老师，想问一下我的理解是否是正确的，我的理解如下：

创建了对象1：第一次计算出的列表lt的长度

a1（第一次打印a的值）：引用了len1

            然后我删除了lt中的一个元素

创建了对象2：第二次计算出列表lt的长度

a2（第二次打印a的值）：依然引用len1

len2没有被其他变量引用，所以等print调用len2结束后，len2被Python的垃圾回收机制回收，但是len1由于a的引用，依然在内存中占据一块空间。

由于len1计算出来的值为数值类型，数值类型为不可变对象，所以a依然指向原来的len1，len2为后面创建的新对象，不同的对象具有不同的id，所以len1和len2的id不同

一、程序

 程序1：

# 创建聊天室
from threading import Thread
from socket import *
import struct
s = socket(AF_INET, SOCK_DGRAM)
s.bind(('', 8788))


def func1():  # 发送消息
    send_data = input('我：')
    s.sendto(send_data.encode(), ('192.168.1.6', 8585))


def func2():  # 接收消息
    redata = s.recvfrom(1024)
    print('李四：', redata[0].decode())


if __name__ == '__main__':
    while True:
        t1 = Thread(target=func1())
        t2 = Thread(target=func2())
        t1.start()
        t2.start()
    s.close()

 程序2：

# 创建聊天室
from threading import Thread
from socket import *
import struct
s = socket(AF_INET, SOCK_DGRAM)
s.bind(('', 8585))


def func1():  # 发送消息
    send_data = input('我：')
    s.sendto(send_data.encode(), ('192.168.1.6', 8788))


def func2():  # 接收消息
    redata = s.recvfrom(1024)
    print('张三：', redata[0].decode())


if __name__ == '__main__':
    while True:
        t1 = Thread(target=func1())
        t2 = Thread(target=func2())
        t2.start()
        t1.start()
    s.close()

二、运行结果

三、疑问

老师请问，我的my05发送消息给my06时，my06接收到消息但是不输出，只有my06给my05回消息时，my06之前接收到的消息才输出，是哪里出错了？