一、代码

# 实现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))

二、运行结果

三、疑问

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

一、程序1

from socket import *

s = socket(AF_INET, SOCK_DGRAM)
s.bind(('', 8788))
s.sendto('abc'.encode(), ('192.168.1.6', 8585))
redata=s.recvfrom(1024)

print(redata[0])

程序2

from socket import *

udpsockt = socket(AF_INET, SOCK_DGRAM)
udpsockt.bind(('', 8585))
while True:
    redata=udpsockt.recvfrom(1024)
    # redata[0]是内容，redata[1]是地址
    udpsockt.sendto(redata[0], redata[1])
udpsockt.close

二、运行结果

老师请问，运行结果为啥是b‘abc’

我之前把'abc'.encode改写成b'abc',运行结果是b'abc',改回来之后还是b'abc'

老师，我和一个同学用的一个wifi，我查ip我们俩网络号也是一样的，但是我 ping它的ip为什么光显示请求超时呢？

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

老师，我编写完以后运行正常，但我不明白一个问题，为什么我把ip改成

192.168.1.7

（也就是本地局域网）之后就出了问题，程序先是没有反应，很长一段时间过后又在左侧文件加载出了图片，然后加载出的图片却是打不开的那种，是不是这个本地局域网ip并不一定就是这个服务器的ip？还是说有其他原因？

代码如下

from socket import *
import struct
filename="xinling.jpg"
server_ip="10.19.130.246"  # 第四行
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[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))

在第四行，如果我换成192.168.1.7之后程序就会卡咝~

一、程序

# 生产者与消费者模式
from queue import Queue
from threading import Thread
from time import sleep
from random import randint


def producer():
    num = 1
    while True:
        if queue.qsize() < 5:
            print(f'生产第{num}号加菲猫')
            queue.put(f'{num}号加菲猫')
            num += 1
            sleep(1)
        else:
            print('满仓')


def consumer():
    while True:
        print('获取{}号加菲猫'.format(queue.get()))
        sleep(randint(1, 3))


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

二、运行结果

三、疑问

老师请问，报错是qsize（）里边要加self吗，加上也出现错误

from multiprocessing import Pool
import os
from time import sleep

def func1(name):
    print("当前进程的ID：{0},名称{1}".format(os.getpid(),name))

if __name__ == '__main__':
    with Pool(5) as pool:
        pool.map(func1,('hangzhou','xihu','wulin','daguan','hemu','guashan','xintang',))

使用pycharm，执行结果所有进程是同一个ID，这个是什么原因？

一、程序

# 事件测试
from threading import Thread, Event
from time import sleep


def car():
    # global count
    num = 0
    while True:
        if event.is_set:
            print('车到站')
            sleep(1)
            # count += 1
            num += 1
            if num % 5 == 0:
                event.clear()
        else:
            print('车开走了')
            sleep(6)
            # count = 1
            event.set()


def person():
    # global count
    while True:
        if event.is_set():
            print('上车')
            sleep(1)
        else:
            print('等车')
            event.wait()


if __name__ == '__main__':
    # count = 1
    event = Event()
    t1 = Thread(target=car)
    #t2 = Thread(target=person)
    t1.start()
    # t2.start()

二、运行结果

三、疑问

老师请问，我这一开始运行结果为啥是‘车到站’，不应该是‘车开走了’了吗？谢谢老师解答

老师，我感觉这个进程池中的apply 同步运行这个‘同步’我还是不太懂，我感觉在用apply给进程池中的进程分任务的时候要等待这个进程执行完才能分配下一个任务，像是线程中的串联运行，但是这个‘同步’是指什么同步？

然后在用apply_async 变成了异步运行，实际上就是每个进程不等其他进程执行的怎么样了，只要进程池里还有进程就执行任务，这个‘异步’又是什么‘异步’呢？

老师，我有个小问题，我想试着用全局变量实现类似Manager在不同进程间通信的功能，但是即便我在另一个进程中global了一下，他还是不停报变量没有定义，所以我想问，是不是全局变量是不能在两个进程之间共享的？

一、程序

'''
验证线程运行速度
用循环增加多个线程
'''

# 调用创建线程的模块
from threading import Thread, Lock
from time import time, sleep
import threading

# 定义一种方法
def func1(name):
    print('threading:{},start'.format(name))
    global num
    lock.acquire()
    for i in range(50000):
        num+=1
    lock.release()
    print('Threading:{},end'.format(name))


if __name__=='__main__':
    lock=Lock()
    num=0
    t_list = []
    for i in range(5):
        t = Thread(target=func1, args=('t{}'.format(i + 1),))
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
        print(num)

二、运行结果

三、疑问

老师请问，我的运行结果为什么是100

老师，我想问一下我理解的对不对：就按视频里面讲的，如果在代码里开始四个线程，而且他们执行的是一个不能再线程规定执行时间执行完的任务，那么这四个线程拿着count=0的值，四个在同一优先级下抢夺全局锁，在一番抢夺全局锁和执行真实操作系统里面线程（即执行count+=1任务）之后，有一个线程率先执行完for循环内容，然后把值返回来，由于这个count是全局变量，四个线程值都同步了，然后其他三个线程前边执行的count+=1就全都没有积累下来，然后继续所以会导致最终执行结果比正确结果要小；

然后那个在视频中出现过一次执行结果正确的情况是因为可能当时cpu很快，在它们抢到锁以后，所有线程都在规定时间完成了任务，所以结果是对的，可以这么理解吗？

一、程序

'''
线程的创建与使用
线程的创建方法二：
类包装
用for循环创建多个线程
守护线程
'''
from threading import Thread
from time import time, sleep

# 调用线程模块
class Mythread(Thread):
    def __init__(self, name):
        Thread.__init__(self)
        self.name = name

    def run(self):
        print('threading{} start',format(self.name))
        sleep(3)
        print('threading{} end', format(self.name))
if __name__=='__main__':
    start=time()
    t_list = []
    for i in range(10):
        t = Mythread('t{}'.format(i))
        t.setDaemon(True)
        t.start()
        t_list.append(t)
    print('主线程结束了')
    end=time()
    t=end-start
    print(t)

二、结果

三、疑问

老师请问，我的t为什么都在花括号外边？‘主线程结束了’位置也有点乱，是pycharm的问题吗？

老师，您看下下面的代码：

from concurrent.futures import ThreadPoolExecutor

def foo(count):
    if count > 5:
        print('验证中')
        count = 0
    print('可以了')
    count += 1
alist = [i for i in range(20)]
count = 0
pool = ThreadPoolExecutor(max_workers=5)
pool.map(foo, alist)

执行结果：

可以了 可以了 可以了 可以了 可以了 可以了 验证中 验证中 验证中 验证中 可以了 验证中 可以了 可以了 可以了 验证中可以了 验证中 验证中 验证中 可以了 验证中 可以了 可以了 可以了 验证中 可以了

上面的代码开启了5个线程，当一个进程执行过‘验证中’后，count变为0了，可是后面的进程又重复执行了‘验证中’，改怎么告诉后面的进程count已经变为0，直接执行‘可以了’，麻烦老师了！

一、程序

'''
验证线程运行速度
'''

# 调用创建线程的模块
from threading import Thread
from time import time, sleep
import threading

# 定义一种方法
def func1(name):
    print(threading.current_thread())
    print('threading:{},start'.format(name))
    sleep(3)
    print('threading:{},end'.format(name))
    sleep(3)

# 创建线程
t1 = Thread(target=func1, args=('t1',))
t2 = Thread(target=func1, args=('t2',))


if __name__=='__main__':
    print(threading.current_thread())
    start = time()
    # 开始线程
    t1.start()
    t2.start()
    # 等待t1线程结束，再往下执行
    t1.join()
    # 等待t2线程结束，再往下执行
    t2.join()
    #func1('t1')
    #func1('t2')
    end = time()
    t=end-start
    print(t)

二、疑问

老师请问，这个程序的主线程是什么？具体在执行什么功能？