老师，之前说python里边一切皆对象，那下边红色部分的se=Semaphore是等号左边的变量se是“信号量对象”，还是右边的`Semaphore是“信号量对象”呢？

老师，这一章UDP编程通讯协议步骤明白了，不过我好奇和其他电脑用网线通讯的话，是不是得要把这些程序做成文件形式，传给给另一台电脑，让另一台电脑打开才可以进行通讯。

然后我刚刚试了下，不知道要怎么导出程序，只能保存py格式，html导出会卡机，我想连到另一个电脑试下。

如果是传给手机需要怎么操作，把这个通讯传给手机

------------资料里的软件文件夹是空的？

#服务端
#coding=utf-8
from socket import *
#最简化的UDP服务端代码
s = socket(AF_INET,SOCK_DGRAM)  #创建UDP类型的套接字
s.bind(("127.0.0.1",8888))  #绑定端口,ip可以不写
print("等待接收数据！")
recv_data = s.recvfrom(1024)    #1024表示本次接收的最大字节数
print(f"收到远程信息:{recv_data[0].decode('gbk')},from {recv_data[1]}")
s.close()

#客户端
#coding=utf-8
from socket import *
#最简化的UDP客户端发送消息代码
s = socket(AF_INET,SOCK_DGRAM)  #创建UDP类型的套接字
addr = ("127.0.0.1",8888)
data = input("请输入：")
s.sendto(data.encode("gbk"),addr)
s.close()

没明白服务端和客户端这两个编码为什么要这样写：看下面

decode('gbk')和data.encode("gbk")

if __name__ == "__main__": print('主进程ID:{}'.format(current_process().pid)) with Manager() as mgr: m_list = mgr.list() m_dict = mgr.dict() m_list.append('Hello!!') p1 = Process(target=func,args=('p1',m_list,m_dict)) p1.start() p1.join() print(m_list) print(m_dict)老师为什么这里p1.start() p1.join() print(m_list) print(m_dict)这几句也要缩进到with 打开的Manager中

这里接收到的是元组吗？里面的信息是不是只会是两个，发送的内容和发送的地址吗？所才用recv[0]和recv[1]

为什安装有greenlet 但是无法调用咧

代码：

from threading import Thread
from time import sleep
class A(Thread):
    def __init__(self,name):
        Thread.__init__(self)
        self.name = name
    def run(self):
        print("name:"+self.name)
        sleep(3)
        print('end')
t_list = []
for i in range(10):
    t = A('t'+str(i))
    t_list.append(t)
for item in t_list:
    item.setDaemon(True) # setDaemon 必须在start之前用
    item.start()
for item in t_list:
    item.join()

运行结果：

请问为什么会出现endend并排，以及有空行的现象？

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一次会执行一次是吗？

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

# 创建普通方法
def func1(name):
    print(threading.currentThread())
    print("Threading:{name} start")
    sleep(3)
    print("Threading:{name} end")

if __name__=="__main__":
    print(threading.currentThread())
    # 开启时间
    start=time()
    '''
    # 创建线程
    t1=Thread(target=func1,args=("t1",))
    t2=Thread(target=func1,args=("t2",))

    # 开启时间
    start=time()
    # 开启线程
    t1.start()
    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)

请问老师，这个print(threading.currentThread())干吗的。起到什么作用

代码是：

from socket import *
import  struct
cmb_buf = struct.pack("!H5sb5sb",1,b"1.jpg",0,b"octet",0)
udpSock = socket(AF_APPLETALK,SOCK_DGRAM)
udpSock.sendto(cmb_buf,("10.2.100.167",69))
f = open("1.jpg","ab")

为什么会报错呀 老师

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))

    await  asyncio.sleep(1)


def end(n, m,t):
    # result = await compute(x,y)
    print(f'{n}+{m}={t.result}')


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

    loop.run_until_complete(print_sum(1, 2))

    loop.close()

老师能把这个程序的流程叙述一遍吗 我调试了一下感觉还是不太懂

老师，这个相当于全双工吗？能够两边同时收发？

#coding=utf-8
from socket import *
from threading import Thread

def recv_data():
    while True:
        recv_data = client_socket.recv(1024)  # 接收的最大字节数
        print(f"客户端的消息：{recv_data.decode('gbk')}")
        if recv_data == "end":
            break
def send_data():
    while True:
        msg = input("请输入消息：")
        client_socket.send(msg.encode('gbk'))

if __name__ == '__main__':
    server_socket = socket(AF_INET,SOCK_STREAM)#建立TCP套接字
    server_socket.bind(("127.0.0.1",8899))
    server_socket.listen(5)
    print("等待接收连接")
    client_socket,client_info = server_socket.accept()
    print('一个客户端建立连接成功')

    t1=Thread(target=recv_data())
    t2=Thread(target=send_data())

    t1.start()
    t2.start()

    t1.join()
    t2.join()

    client_socket.close()
    server_socket.close()

我的服务端只能接收 没法发送消息

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))        #python3.7以上写法
    # task绑定回调函数
    task.add_done_callback(functools.partial(end,x,y))  #python3.7以上写法
    # 释放下cpu的使用
    await asyncio.sleep(0)


def end(n,m,task):
    print(f'{n}+{m}={task.result()}')

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

    loop.run_until_complete(print_sum(1,2))

    loop.close()

老师 这里task创建了一个任务计算x+y,下面的绑定回调函数是什么意思，为什么要绑定，以及绑定了之后怎么还要睡眠一秒，如果是0秒的话显示Task was destroyed but it is pending!我听不懂视频里的老师的表达，麻烦这里老师文字详细解释下