老师请问car方法里边else最后不是换成True了吗？程序自上而下执行，那么在person里边不是该执行if后边的语句了吗？

from threading import Thread
from threading import Event


def car():
    num = 0
    while True:
        if event.is_set():
            print('车到站！上车')
            sleep(1)  # 上一个人加一秒
            num += 1
            if num % 5 == 0:
                event.clear()
        else:
            print('车已经开走')
            sleep(6)
            event.set()
def person():
    while True:
        if event.is_set():
            print('车来了，上车')
            sleep(1)
        else:
            print('等待车!!!')
            event.wait()

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

这个是咋回事呢                                                                                                                       

这模拟器如何变成中文呀                                                                       

from threading import Thread
from queue import Queue
from time import sleep
def find_g():
    num = 1
    while True:
        print(f"制造了了{num}号女朋友")
        mq.put(f"{num}号女朋友")
        num +=1
        sleep(1)

def fetch_g():
    while True:
        print("找到了{}".format(mq.get()))
        sleep(1)


if __name__ == '__main__':
    mq = Queue()
    t1 = Thread(target=find_g)
    t2 = Thread(target=fetch_g)
    t1.start()
    t2.start()

老师这个with我在其他地方用会报错，也就是说只能在Manger管理器里使用对吗

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输出不了呢