from socket import *
import struct

filename = 'car.jpg'
server_ip = '127.0.0.1'
send_data = struct.pack('!H%dsb5sb'%len(filename),1,filename.encode(),0,b'octet',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) < 516:
        break
    ack_data = struct.pack('!HH',4,ack_num)
    s.sendto(ack_data,(server_ip,rand_port)) # 回复ACK确认包

老师我运行之后只有一行输出，这是为什么呢？

第一个代码：

from socket import *

s = socket(AF_INET,SOCK_DGRAM)
s.bind(('',8788))
s.sendto(b'hello',('172.26.131.120',8585))
redata = s.recvfrom(1024)
print(redata[0].decode())

第二个代码：

from socket import *

udpSocket = socket(AF_INET,SOCK_DGRAM)
udpSocket.bind(('',8585))
while True:
    recvData = udpSocket.recvfrom(1024)
    print(recvData[0].decode())
    data = input('请输入：')
    udpSocket.sendto(data.encode(),recvData[1])

udpSocket.close()

运行第一个代码后没有任何返回结果是为什么呢？

老师为什么我运行的是10个一起出结果，sleep 3秒后 程序结束

# ！/user/bin/env python3
# -*- coding: utf-8 -*-

from threading import Thread
from threading import BoundedSemaphore
from time import sleep

def an_jian(num):
    semaphore.acquire()
    print(f'第{num}个人通过安检')
    sleep(3)
    semaphore.release()

if __name__ == '__main__':
    semaphore=BoundedSemaphore(10)
    for i in range(10):
        t = Thread(target=an_jian,args=(f'{i+1}',))
        t.start()

from socket import *

s = socket(AF_INET,SOCK_DGRAM)
s.bind('',8788)
s.sendto(b'hello',('172.26.131.120',8080))
redata = s.recvfrom(1024)
print(redata[0].decode('gb2312'))

s.close()

老师这个报错是怎么回事：

Traceback (most recent call last):

  File "E:/pythonStation/IP/02_UDP绑定信息.py", line 4, in <module>

    s.bind('',8788)

TypeError: bind() takes exactly one argument (2 given)

老师执行fun1时，会调用fun2。是在fun1的基础上运行fun2函数吗？线程里边的程序是交替进行的是吗？不再单纯的自上而下

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))
    # 释放下cpu的使用
    await asyncio.sleep(0)
    for i in range(100000):
        if i%500 == 0:
            print(i)
            await asyncio.sleep(0.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()
  
刚才一段代码复制的有问题，以这个为准

asyncio
functools
(xy):
    (xy)
    asyncio.sleep()
    x+y

(xy):
    task = asyncio.create_task(compute(xy))
    task.add_done_callback(functools.partial(endxy))
    asyncio.sleep()
    i ():
        i%== :
            (i)
            asyncio.sleep()

(nmt):
    (nmt.result())

__name__ == :
    loop = asyncio.get_event_loop()
    loop.run_until_complete(print_sum())
    loop.close()

老师我运行之后报这个错误：

Traceback (most recent call last):

  File "E:/pythonStation/Thread/30_协程的基本使用-asyncio的task的用法.py", line 25, in <module>

    loop.run_until_complete(print_sum(1,2))

  File "D:\python\lib\asyncio\base_events.py", line 468, in run_until_complete

    return future.result()

  File "E:/pythonStation/Thread/30_协程的基本使用-asyncio的task的用法.py", line 10, in print_sum

    task = asyncio.create_task(compute(x,y))

AttributeError: module 'asyncio' has no attribute 'create_task'

 这是为什么呢？

#当作为发送方可以不绑定端口，但做为接收方一定要绑定端口
from socket import *
s=socket(AF_INET,SOCK_DGRAM)
s.bind('',8788)
s.sendto(b'asd','169.254.69.137',8083)
rdata=s.recvfrom(2048)
print(rdata[0].decode('gb2312'))

只接收一个参数是什么意思呀，这个该如何该呢

老师系统是先执行if语句还是自上而下执行呢

from threading import Thread
from threading import Lock
def func1(name):
    #获得锁
    #lock.acquire()
    #函数中使用全局变量
    global count
    for i in range(100000000):
        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)

老师这个子主线程究竟是按什么来划分的？

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)

from multiprocessing import Process
from time import sleep
class MyProcess(Process):
    def __init__(self,name):
        Process.__init__(self)
        self.name=name

    def fun(self):
        print(f'{self.name}开始')
        sleep(2)
        print(f'{self.name}结束')
if __name__ == '__main__':
    p1=MyProcess('p1')
    p1.start()
 #为什么开始后printf输出不了呢

Queue   怎么删除里面的数据呢？

比如：
q=Queue()
q.put(1)
q.put(2)
q.put(3)
如何删除3呢？

# Tftp简单传输文件协议，默认端口号69（该端口仅用于读写请求）

import struct   # 按一定格式组织数据
from socket import *

# 传输格式"1PICTURE.jpg0octet0"---"操作码+文件名+分割0+模式+结尾0"--(1,b"PICTURE.jpg",0,b"octet",0)
# 按格式组织数据
'''实现TFTP下载器：
    下载：从服务器上将一个文件复制到本机上
    下载的过程：
        ~在本机创建一个空文件(与要下载的文件同名)
        ~向里面写数据(接受到一点就向空文件里写一点)
        ~关闭(接受完所有数据关闭文件'''

filename="PICTURE.jpg"
sever_ip="192.168.10.107"
send_data=struct.pack("!H%dsb5sb"% len(filename),1,filename.encode(),0,"octet".encode(),0)  # !表示按网络传输数据要求组织数据；H对应1占用2字节；b代表0占用1字节
udpSocket=socket(AF_INET,SOCK_DGRAM)
udpSocket.sendto(send_data,(sever_ip,69))
f=open(filename,"ab")    # 创建空文件--文件名与需要下载的名称一致

while True:
    # udp的发送接收内容--元组--（消息内容,（ip,端口号））
    rec_data=udpSocket.recvfrom(1024)   # 数据接收,前两个字节为操作码，后两字节块编号，后512字节为写入内筒
    operation_code,ack_num=struct.unpack('!HH',rec_data[0][:4])  # 操作码operation_code，数据块编号ack_num，struct.unpack解析消息内容
    # rec_data[0][:4]--0代表元组第一个元素，:4代表元组前4个元素
    rand_port=rec_data[1][1]   # 获取服务器的随机端口
    if int(operation_code)==5:
        print("文件不存在")
        break
    print("操作码：%d,ACK：%d,服务器随机端口：%d,接收的数据长度：%d",operation_code,ack_num,rand_port,len(rec_data))
    f.write(rec_data[0][4:])  # 将消息内容（516字节），由于前4个字节为操作码和数据块编号，所以后514字节进行数据写入
    if len(rec_data[0])<516:  # 小于516，说明已经传输到最后一个数据包
        break
    ack_data=struct.pack("!HH",4,ack_num)   # 需要用于确定的ack数据包
    udpSocket.sendto(ack_data, (sever_ip, rand_port))  # 给对方服务器回复ack确认包

为什么这个一直保持运行状态，没有结果啊？

老师，我不明白这里视频里面recvdata【0】当中0还有1代表什么意思？算是位置么？

#创建echo服务器，建立聊天室，建立双线程，能够实现全双工聊天

from socket import *
from threading import Thread

def send_message():
    while True:
        recvData=udpSock.recvfrom(1024)
        s=input("请输入发送内容：")
        udpSock.sendto(s.encode("gb2312"),recvData[1])
    udpSock.close()

def receive_messege():
    while True:
        recvData=udpSock.recvfrom(1024)
        print(recvData[0].decode("gb2312"))
    udpSock.close()


if __name__=="__main__":
    udpSock = socket(AF_INET, SOCK_DGRAM)
    udpSock.bind(("", 8585))
    t1=Thread(target=receive_messege)
    t2 = Thread(target=send_message)
    t1.start()
    t2.start()

老师，请问这样算是实现了全双工聊天吗？有点不明白怎样算是实现全双工聊天？