from socket import *
import struct
 
if __name__ == '__main__':
    ftp_socket = socket(AF_INET, SOCK_DGRAM)
    send_data = struct.pack('!H8sb5sb', 1, b'123.jpeg', 0, b'octet', 0)
    ftp_ip = '192.168.1.7'
    ftp_socket.sendto(send_data, (ftp_ip,69))
    with open('/Users/zhangjiabing/Desktop/111/123.jpeg', "wb") as f:
        while True:
            receive_data = ftp_socket.recvfrom(1024)
            print(receive_data)
            operation_code,ack_num=struct.unpack('!HH',receive_data[0][:4])
            rand_port=receive_data[1][1]
            print(operation_code,ack_num)
            if operation_code==5:
                print('文件不存在')
                break
            else:
                f.write(receive_data[0][4:])
                print(receive_data[0],len(receive_data[0]))
                if len(receive_data[0])<516:
                    print('文件传输完成')
                    break
                ack_data=struct.pack('!HH',4,ack_num)
                ftp_socket.sendto(ack_data,(ftp_ip,rand_port))

老师，您好：

        这个作业，老师的点评是：

老师点评:

不要把代码都写在程序入口下面，失去了if __name__ == '__main__':存在的意义，注意规划代码结构

请教下老师，这个代码，如何规划才更合理。哪些应该放在

if __name__ == '__main__':

之外？谢谢

老师我这个设置了maxsize=10.为什么还往下生产呢

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

#生产者
def producer():
    num = 1
    while True:
        # if mq.qsize()<10:
        print("生产{}号皮卡丘".format(num))
        mq.put(f"{num}号皮卡丘")
        num +=1
        sleep(1)

#消费者
def consumer():
    while True:
        print("购买{}".format(mq.get()))
        sleep(1)


if __name__ == '__main__':

    mq = Queue(maxsize=10)
    t1 = Thread(target=producer)
    t2 = Thread(target=consumer)

    t1.start()
    t2.start()

麻烦老师帮我看一下为什么会有下面这个结果？

老师我这个代码里的 i变量出问题说没被定义

from threading import Thread
from threading import Lock
   

def func1(name):
    # #锁
    # lock.acquire()
    #with 使用锁
    with lock:
        #全局变量
        global count
        
        for i in range(100000):
            count += 1
    # lock.release()



if __name__ == '__main__':
    count = 0
    t_list = []
    lock=Lock()
    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)

def producer():
    while True:
        n=yield  #  利用send返回
        print(f"第{n}个产品生产完毕")



def consumer():
    g=producer()   # g 是一个生成器获得producer的地址，在此处并没有对producer进行执行
    for i in range(10):
        next(g)  #  执行g获得地址对应的对象
        g.send(i)
        print(f"第{i}个产品被消费了")



if __name__ == '__main__':
    consumer()

老师，和老师上课的代码相比我把next(g)代码放到了for循环中，打印出现了如下结果，请问是next会调用一次生成器但是这个时候yield没有返回值，所以打印的是none，然后send以后有返回值了，又被执行一次嘛？send一次会执行一次是吗？

老师，我想请问一下是需要下载虚拟机是吗？输入查看不了Vmvare得ip

老师，这个安装greenlet模块路径出错了怎么解决呀

请问老师：

from multiprocessing import Process,Pool
from time import sleep

def f1(name):
    print(f'开始执行{name}')
    sleep(2)
    print(f'{name}执行结束')


if __name__ == '__main__':
    with Pool(3) as pool:
        pool.map(f1,('进程1','进程2','进程3','进程4','进程5'))

    sleep(5)
    print('主进程执行结束')

用with 语句，上面可以执行，为何下面执行不了

from multiprocessing import Process,Pool
from time import sleep

def f1(name):
    print(f'开始执行{name}')
    sleep(2)
    print(f'{name}执行结束')


if __name__ == '__main__':
    with Pool(3) as pool:
        pool.apply_async(func=f1,args=('进程1',))
        pool.apply_async(func=f1, args=('进程2',))
        pool.apply_async(func=f1, args=('进程3',))
        pool.apply_async(func=f1, args=('进程4',))
        pool.apply_async(func=f1, args=('进程5',))
        pool.apply_async(func=f1, args=('进程6',))
        pool.apply_async(func=f1, args=('进程7',))

    sleep(5)
    print('主进程执行结束')

老师，这节课的两个进程一个是开始执行就有的进程，还有一个是Process产生的进程么？

老师，我想请问一下callbac是什么意思呢？不太懂；还有就是您后面说的是写了args的效率要比不写是要高一点是吗？

老师，请问with的用法是什么意思呢？在这儿写起什么作用呀？下面的两行是什么意思呢？

老师，我想问一下逻辑锁和没有锁和互斥锁有什么区别呢

老师，有没有可能当第十个线程刚启动，但是第一个线程已经执行完毕了呢，循环不也是有先后的么。线程的启动并不是同时开始的啊

from threading import Thread
from time import sleep

class myshread(Thread):                  #不再是普通的类，要继承类
        def __init__(self,name):
                Thread.__init__(self)
                self.name=name

        def run(self):#  注意必须使用run方法，一个字母错了都不行
                print(f"threading{self.name}start")
                sleep(3)

#创建线程
t1=myshread("t1")
t2=myshread("t2")

#调用类方法
t1.run()
t2.run()

老师，为什么在我的电脑上是等待了一会才出现的第二句而不是同时出现的呢

# coding=utf-8

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


def producer():
    num = 1
    while True:
        print(f'生产：{num}号产品')
        mq.put(f'生产：{num}号产品')
        num += 1
        sleep(1)


def consumer():
    while True:
        print('购买了{}'.format(mq.get()))
        sleep(2)


if __name__ == '__main__':
    # 共享数据的容器
    mq = Queue(maxsize=10)
    # 创建生产者线程
    t1 = Thread(target=producer)
    # 创建消费者线程
    t2 = Thread(target=consumer)
    # 开始工作
    t1.start()
    t2.start()

老师为什么给mq = Queue(maxsize=10) 传进去最大容量为10的时候，会生产12个产品而不是10个