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 *  #导入socket模块

s = socket(AF_INET,SOCK_DGRAM) # 创建一个socket对象
addr = ("192.168.3.25",8083) # 创建接收方地址及端口
date = input("请输入需要发送的内容：") # 创建发送内容
s.sendto(date.encode("GB2312"),addr) # 用sendto发送信息，encode（）：endcode的作用是将字符串转换为字节流，括号中是接收方的解码形式，如不填写默认为utf-8
redata = s.recvfrom(2048) # 括号中的数字为接收信息的最大字节数
print(redata[0].decode("GB2312")) #接收到的数据为一个元组，元组中的第一个位置是接收到的信息字节流数据，第二位是发送方的IP地址和端口
                                  #decode（）decode的作用是将字节流转换为字符串，括号中是接收方的解码形式，如不填写默认为utf-8
s.close()

老师，为什么调试助手这里没反应

老师，请问代码哪里出了错，我的python不报错，也不运行，谢谢

test1

socket *
s=socket(AF_INET,SOCK_DGRAM)
s.bind((,))
s.sendto(.encode(),(,))
redata=s.recvfrom()
(redata[].decode())

s.close()

test2

socket *

udpSocket=socket(AF_INET,SOCK_DGRAM)
udpSocket.bind((,))
:
    recvdata=udpSocket.recvfrom()
    udpSocket.sendto(recvdata[],recvdata[])

udpSocket.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):        # python3.5以上
    # 创建task
    task = asyncio.create_task(compute(x, y))
    # task绑定回调函数
    task.add_done_callback(functools.partial(end, x, y))
    # 释放下cpu的使用
    await asyncio.sleep(1)


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


if __name__ == '__main__':
    # 创建事件循环
    loop = asyncio.get_event_loop()
    # 监听事件循环
    loop.run_until_complete(print_sum(1, 2))
    # 关闭事件循环
    loop.close()

老师，这边我还是不懂执行的过程，有几个问题问一下      1、这边开始运行之后先是执行print_sum函数，然后到了print_sum函数中的await时释放cpu去执行compute（）函数，然后到了compute（）函数中的await时又会回到print_sum函数中是吗？是这样的话那print_sum中的tast = asyncio.create_tast(compute())和tast.add_done_callback(functools.partial(end,x,y)不是已经运行过了吗，从compute（）函数返回时是再执行一边print_sum函数的内容吗？     2、这里end函数中的t为什么就是tast

老师，请问一下这个两个f分别是什么意思呢？我有点不太确定

第二个f是不是代表方法中的num用i+1来代？

还有画红线的地方不懂诶。意思我能理解，不过写法有点懵,  ("{ }",)，外面小括号是元组，里面中括号是什么意思？

1 def func1():
2     for i in range(11):
3         print(f'北京打印第{i}次数据')
4         yield
5 
6 
7 def func2():
8     g = func1()
9     next(g)
10    for i in range(10):
11        print(f'上海打印第{i}次数据')
12        next(g)
13
14
15if __name__ == '__main__':
16    func2()

老师，第一次运行时这里的第12行next（g）中的g是‘第0次’还是‘第1次’

老师，这里的pool.join（）中的join是什么意思？

struct
socket *
filename = server_ip = send_data = struct.pack(% (filename), , filename.encode(), , .encode(), )
s = socket(AF_INET, SOCK_DGRAM)
s.sendto(send_data, (server_ip, ))  f = (filename, )  :
    recv_data = s.recvfrom()  caozuoma, ack_num = struct.unpack(, recv_data[][:])  rand_port = recv_data[][]  (caozuoma) == :
        ()
        (%(caozuoma, ack_num, rand_port, (recv_data[])))
    f.write(recv_data[][:])(recv_data[]) < :
        ack_data = struct.pack(, , ack_num)
    s.sendto(ack_data, (server_ip, rand_port))

老师麻烦解答一下，谢谢！

代码如下：

struct
socket *
filename = server_ip = send_data = struct.pack(% (filename), , filename.encode(), , .encode(), )
s = socket(AF_INET, SOCK_DGRAM)
s.sendto(send_data, (server_ip, ))  f = (filename, )  :
    recv_data = s.recvfrom()  caozuoma, ack_num = struct.unpack(, recv_data[][:])  rand_port = recv_data[][]  (caozuoma) == :
        ()
        (%(caozuoma, ack_num, rand_port, (recv_data[])))
    f.write(recv_data[][:])(recv_data[]) < :
        ack_data = struct.pack(, , ack_num)
    s.sendto(ack_data, (server_ip, rand_port))

老师好，怎么我的代码执行结果是文件不存在呢？我的图片是按照相对路径来复制粘贴的呀！

代码如下：

struct
socket *
filename = server_ip = send_data = struct.pack(% (filename), , filename.encode(), , .encode(), )
s = socket(AF_INET, SOCK_DGRAM)
s.sendto(send_data, (server_ip, ))  f = (filename, )  :
    recv_data = s.recvfrom()  caozuoma, ack_num = struct.unpack(, recv_data[][:])  rand_port = recv_data[][]  (caozuoma) == :
        ()
        (%(caozuoma, ack_num, rand_port, (recv_data[])))
    f.write(recv_data[][:])(recv_data[]) < :
        ack_data = struct.pack(, , ack_num)
    s.sendto(ack_data, (server_ip, rand_port))

老师您好

from socket import *
import asyncio
# 给对方传递信息
s = socket(AF_INET, SOCK_DGRAM)  # ipv4协议 使用的是udp协议
s.bind(("", 5431))
addr = ("172.27.150.26", 8080)  # ip 地址和端口地址
async def fun1():
    while True:
        date = input("请输入要选择的内容")
        s.sendto(date.encode("gb2312"), addr)       # 将字符流转为字符串

async def fun2():
    while True:
        task = asyncio.create_task(fun1())
        task.add_done_callback()
        redate = s.recvfrom(10)
        print(redate[0].decode("gb2312"))
if __name__ == '__main__':
    f1 = fun1()
    f2 = fun2()
    loop = asyncio.get_event_loop()
    loop.run_until_complete(f2)
    loop.close()

我想用进程的方法实现它可以同时接受信息，请问要怎么做才行啊？

老师，下面的callback回调函数的作用是什么？写与不写的区别在哪里？好像不影响进程的效率

p.apply_async(func=func1, args=(f"p{i+1}", ), callback=func2)

老师这个回调函数有具体介绍吗？不清楚。。