提示：记录一些vim编辑环境下常用命令以及pyhon3高级编程
目录
一.python3网络编程
1.udp
1.udp实现从linux发送数据到windows
windows编码是("gbk")
linux('utf-8')
import socket
def main():
udp_socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
while True:
sent_data = input("请输入您需要发送的信息")
if sent_data == 'exit':break
udp_socket.sendto(sent_data.encode('utf-8'),("172.21.126.225",8080))
udp_socket.close()
if __name__ =='__main__':
main()
解码用decode
编码用encode
发信息基本步骤：1.创建套接字
2.输入需要发送的信息
3.发送信息
4.关闭套接字
2.接收数据到ubuntu
收信息基本步骤：1.创建套接字
2.绑定端口号
3.调用函数recvfrom() 第一个返回值是信息，第二个是对方的地址
4.关闭套接字
import socket
def main():
# 创建套接字
udp_socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
# 绑定端口号
local_addr = ("",4657)
udp_socket.bind(local_addr)
recv_data = udp_socket.recvfrom(1024)
recv_msg = recv_data[0] # 接受的信息
recv_addr = recv_data[1] # 发送者的地址信息
print(f"{recv_addr}:{recv_msg}")
# udp_socket.sendto(b"haha",("172.21.126.225",8080))
udp_socket.close()
if __name__ =='__main__':
main()
3.使用同一个套接字完成收发信息
import socket
def main():
# 创建套接字
udp_socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
# 获取对方的ip/port
dest_ip = input("请输入对方的ip:")
dest_port = int(input("请输入对方的port:"))
# 从键盘获取数据
send_data = input("请输入要发送的数据:")
# 可以使用套接字收发数据
udp_socket.sendto(send_data.encode("utf-8"),(dest_ip,dest_port))
# 绑定端口号
# local_addr = ("",4657)
# udp_socket.bind(local_addr)
# 接手数据
recv_data = udp_socket.recvfrom(1024)
recv_msg = recv_data[0] # 接受的信息
recv_addr = recv_data[1] # 发送者的地址信息
print(f"{recv_addr}:{recv_msg}")
# udp_socket.sendto(b"haha",("192.168.220.1",8080))
udp_socket.close()
if __name__ =='__main__':
main()
4.一个udp聊天器案例
import socket
def send_msg(udp_socket):
"""发送消息"""
dest_ip = input("请输入对方的ip:")
dest_port = int(input("请输入对方的port:"))
send_data = input("请输入要发送的数据:")
# 可以使用套接字收发数据
udp_socket.sendto(send_data.encode("utf-8"),(dest_ip,dest_port))
def recv_msg(udp_socket):
"""接收数据"""
recv_data = udp_socket.recvfrom(1024)
recv_msg = recv_data[0].decode("gbk") # 接受的信息
recv_addr = recv_data[1] # 发送者的地址信息
print(f"{recv_addr}:{recv_msg}")
def main():
# 创建套接字
udp_socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
#绑定信息
udp_socket.bind(("",7788))
# 获取对方的ip/port
# dest_ip = input("请输入对方的ip:")
# dest_port = int(input("请输入对方的port:"))
# 从键盘获取数据
while True:
print("-----dup聊天器-----")
print("1:发送消息")
print("2:接收消息")
print("0:退出聊天器")
op = input("请输入功能:")
if op == "1":
#发送消息
send_msg(udp_socket)
elif op == "2":
# 接收数据并显示
recv_msg(udp_socket)
elif op == '0':break
else:
print("输入有误")
# 绑定端口号
# local_addr = ("",4657)
# udp_socket.bind(local_addr)
# 接收数据
# udp_socket.sendto(b"haha",("192.168.220.1",8080))
udp_socket.close()
if __name__ =='__main__':
main() 21,1 Top
2.tcp实现
tcp分为客户端和服务器
1.tcp-client发送信息青春版
（1）先创建一个tcp套接字
tcp_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
不同于udp，socket()函数的第二个参数里更改为SOCK_STREAM
（2）然后调用connect函数调用服务器，将服务器的ip地址个port端口以元组形式传进connect里
（3）接着进行收发信息操作：发信息用send函数
（4）最后关闭套接字
import socket
def main():
# 1创建tcp套接字
tcp_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 2链接服务器
server_ip = input("请输入需要连接的服务器的ip:")
server_port = int(input("请输入此服务器的port:"))
server_addr = (server_ip,server_port)
tcp_socket.connect(server_addr)
# 3发送/接收数据
send_data = input("请输入要发送的信息:")
tcp_socket.send(send_data.encode("utf-8"))
# 4关闭套接字
tcp_socket.close()
if __name__ == '__main__':
main()
2.tcp-server青春版
（1）创建套接字
（2）绑定本地port，因为是服务器所以要帮定
（3）调用listen(128)函数，是服务器处于被动状态，128可以理解为最多有128个客户端链接
（4）等待客户端的链接，调用accept()函数，会有两个返回值，第一个表示客户端的套接字，第二个是客户端的地址信息
（5）调用recv(1024)接受信息1024是最大字节数
（6）调用send()回信息，告诉客户端链接成功
（7）关闭套接字，先关闭客户端的套接字，然后是服务器的套接字
import socket
def main():
# 1 买个手机 （创建套接字）
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 2 插个手机卡 (绑定本地信息 bind)
tcp_server_socket.bind(("",7890))
# 3 将手机设置为响铃模式(让默认的套接字由主动变为被动listen)
tcp_server_socket.listen(128)
# 4 等待别人打电话 （等待客户端的链接accept）
print("-----1-----")
new_client_socket,client_addr = tcp_server_socket.accept()
print("-----2-----")
print(client_addr)
# 接受客户短发送过来的请求
recv_data = new_client_socket.recv(1024)
print(recv_data)
# 回送一部分数据给客户端
new_client_socket.send("hhhhhh-----ok------".encode('utf-8'))
# 关闭套接字
new_client_socket.close()
tcp_server_socket.close()
if __name__ == "__main__":
main()
3.循环为多个客户端服务的服务器青春版
（1）创建套接字
（2）绑定ip和port ip一般用空字符串表示
（3）调用listen
（4）进入循环，accept循环接受客户端的链接，客户端的套接字关闭也要在循环里
（5）关闭服务器的套接字
import socket
def main():
# 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 绑定ip 和 port
tcp_server_socket.bind(("",4111))
# 被动接受数据
tcp_server_socket.listen(128)
while True:
print("-----1-----\n等待一个客户端到来")
# 接收数据
new_client_socket,client_addr = tcp_server_socket.accept()
print("-----2-----\n客户端来喽")
print(f"地址为：{client_addr}")
# 读取信息
recv_data = new_client_socket.recv(1024)
# 回送信息给客户端
print(f"信息是:{recv_data}")
new_client_socket.send("----给我成功----".encode('utf-8'))
# 关闭套接字
new_client_socket.close()
print("服务结束")
tcp_server_socket.close()
if __name__ == "__main__":
main()
~ 4.升级版的循环服务的服务器
大体步骤和3类似，循环体内又加了一个循环，recv_data = new_cilent_socket.recv(1024)
为空时，表示客户端断开链接,升级版可以一直接收一个客户端的信息。
import socket
def main():
# 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 绑定ip 和 port
tcp_server_socket.bind(("",4111))
# 被动接受数据
tcp_server_socket.listen(128)
while True:
print("-----1-----\n等待一个客户端到来")
# 接收数据
new_client_socket,client_addr = tcp_server_socket.accept()
print("-----2-----\n客户端来喽")
print(f"地址为：{client_addr}")
while True:
# 读取信息
recv_data = new_client_socket.recv(1024)
# 回送信息给客户端
print(f"客户端的请求是:{recv_data}")
if recv_data:
new_client_socket.send("----给我成功----".encode('utf-8'))
else:break
# 关闭套接字
new_client_socket.close()
print("服务结束")
tcp_server_socket.close()
if __name__ == "__main__":
main()
5.案例-文件下载器
先是客户端
（1）创建套接字。。。。。。。。到第四步
（4）获取文件的名字
（5）将文件的名字发送到服务器里
（6）等待服务器响应
（7）移步服务器
import socket
def main():
# 1.创建套接字
tcp_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 2.获取服务器ip port
dest_ip = input("请输入下载服务器的ip:")
dest_port = int(input("请输入下载服务器的port:"))
# 3.链接服务器
tcp_socket.connect((dest_ip,dest_port))
# 4.获取下载的文件名称
download_file_name = input("请输入要下载的文件名字:")
# 5.将文件名字发送到服务器
tcp_socket.send(download_file_name.encode("utf-8"))
# 6.接收文件中的数据
recv_data = tcp_socket.recv(1024) # 1024 * 1024 = 1M
if recv_data:
# 7.保存接收到的数据到一个文件中
with open("[新]" + download_file_name,'wb') as f:
f.write(recv_data)
else:print("没有要下载的文件:")
# 8.关闭套接字
tcp_socket.close()
if __name__ == "__main__":
main()
~
~ 服务器：
循环体内等待客户端链接，接收到一个客户端，send_file_2_client里接收服务器名字，先把文件内容定义为空，try内，打开文件，如果没有要下载的文件就打印结果，最后if 内，如果有文件就将内容发送给客户端，客户端接收到内容，就创建一个文件并将内容写入，否则print("没有要下载的文件")，最后关闭套接字
import socket
def send_file_2_client(new_client_socket,client_addr):
# 读取信息
# 1.接受客户端需要的文件名
file_name = new_client_socket.recv(1024).decode('utf-8')
file_content = None
# 2.打开这个文件，读取数据
try:
f = open(file_name,'rb')
file_content = f.read()
f.close()
except Exception as ret:
print("没有要下载的文件(%s)" % file_name)
# 3.发送文件的数据给客户端
if file_content:
print(f"客户端{client_addr}需要下载的文件是:{file_name}")
new_client_socket.send(file_content)
def main():
# 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 绑定ip 和 port
tcp_server_socket.bind(("",4111))
# 被动接受数据
tcp_server_socket.listen(124)
while True:
# 接收数据
new_client_socket,client_addr = tcp_server_socket.accept()
print(f"地址为：{client_addr}")
# 调用函数完成服务
send_file_2_client(new_client_socket,client_addr)
# 关闭套接字
new_client_socket.close()
tcp_server_socket.close()
if __name__ == "__main__":
main()
~ 二.多任务
1.多任务（线程实现）
1.多任务-线程
定义两个函数sing和dance
通过导入模块threading
里面有个类Thread（）有两个参数，第一个表示目标函数，第二个表示函数的参数，用元组表示
创建对象后调用start来实现两个函数并发执行
import time
import threading
def sing():
'''正在唱歌'''
for i in range(5):
print("-----正在唱歌-----")
time.sleep(1)
def dance():
'''正在跳舞'''
for i in range(10):
print('-----正在跳舞-----')
time.sleep(1)
def main():
t1 = threading.Thread(target = sing)
t2 = threading.Thread(target = dance)
t1.start()
t2.start()
while True:
# 查看线程数
print(threading.enumerate())
if len(threading.enumerate()) == 1:break
time.sleep(1)
if __name__ == "__main__":
main()
~
~ 2.继承Thread类完成多任务
import threading
import time
class Mythread(threading.Thread):
def run(self):
self.login()
self.register()
for i in range(3):
time.sleep(1)
msg = "I'm" + self.name + ' @ ' +str(i)
print(msg)
def login(self):
for i in range(5):
print("正在等录" + str(i))
time.sleep(1)
def register(self):
for i in range(10):
print("正在注册" + str(i))
time.sleep(1)
if __name__ == "__main__":
t = Mythread()
t.start()
~ 3.函数里修改全局变量
调用threading的方法，多线程之间共享全局变量
import threading
import time
nums = [11,22,33]
def test1(temp):
temp.append(44)
print(f"{temp}")
def test2(temp):
temp.append(44)
print(temp)
if __name__ == "__main__":
t1 = threading.Thread(target = test1,args = (nums,))
t2 = threading.Thread(target = test2,args = (nums,))
t2.start()
t1.start()
4.互斥锁解决资源竞争问题
使用多线程对全局变量进行修改时，如果调用次数很多，会产生资源竞争问题，
可以定义一个互斥锁mutex = threading.Lock()
acquire表示上锁，release表示解锁
上锁到解锁之间只允许一个线程运行
import time
import threading
g_num = 0
mutex = threading.Lock()
def test1(num):
global g_num
mutex.acquire()
for i in range(num):
g_num += 1
mutex.release()
print("----------in test1 g_num = %d----------" % g_num)
def test2(num):
global g_num
mutex.acquire()
for i in range(num):
g_num += 1
mutex.release()
print("----------in test2 g_num = %d----------" % g_num)
def main():
t1 = threading.Thread(target = test1,args = (1000000,))
t2 = threading.Thread(target = test2,args = (1000000,))
t1.start()
t2.start()
time.sleep(5)
print("----------in main g_num = %d----------" % g_num)
if __name__ == "__main__":
main()
5.多任务实现udp聊天器
定义两个函数，一个接收信息，一个发送信息，之前的聊天器很死板，只能发一次收一次，有了多任务，就可以实现收发一起执行，不一样的是，最后不能关闭套接字，因为不知到什么时候聊天结束。
import socket
import threading
def recv_meassage(udp_socket):
'''接收信息并显示'''
while True:
recv_data = udp_socket.recvfrom(1024)
recv_msg = recv_data[0].decode('utf-8')
recv_addr = recv_data[1]
print(f"\n{recv_addr}发来了信息:{recv_msg}")
def send_msg(udp_socket ,dest_ip, dest_port):
'''发送信息'''
while True:
send_data = input("请输入您要发送的信息:")
udp_socket.sendto(send_data.encode('utf-8'), (dest_ip, dest_port))
def main():
# 创建套接字
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 绑定端口
udp_socket.bind(('',3555))
dest_ip = input("请输入对方的ip地址：")
dest_port = int(input("请输入对方ip地址的端口port："))
t_send = threading.Thread(target = send_msg, args = (udp_socket, dest_ip, dest_port))
t_recv = threading.Thread(target = recv_meassage, args = (udp_socket,))
t_send.start()
t_recv.start()
# 关闭套接字
# udp_socket.close()
if __name__ == "__main__":
main()
————————————————
版权声明：本文为CSDN博主「小白来巡山^_^」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_58613430/article/details/1241600971.多任务(进程实现)
1.使用进程完成多任务
与线程类似，进程实现多任务需要导入模块 multiprocessing
不过，进程之间不共享全局变量，Process这个类和Thread一样，大致流程与线程实现多任务类似。
import time
import multiprocessing
num = 0
def test1(n):
global num
for i in range(n):
num += 1
print(f"1------{i}------")
def test2(n):
global num
for i in range(n):
num += 1
print(f"2-----{i}-----")
def main():
p1 = multiprocessing.Process(target = test1, args = (100,))
p2 = multiprocessing.Process(target = test2, args = (200,))
p1.start()
p2.start()
time.sleep(10)
print(num)
if __name__ == "__main__":
main() 2.利用队列完成多任务进程之间的通信
需要创建一个实例对象q = multiprocessing.Queue()
并把q当作参数传进需要完成通信的子进程中去，队列是先进先出，向队列传数据用put，取数据用get，可以用p.empty()判断队列是否为空，p.full()判断队列是否满
import multiprocessing
def download_from_web(q):
'''下载数据'''
data = [11,22,33,44]
#相队列中写入数据
for temp in data:
q.put(temp)
print(f'{data}-----下载器已经下载完了数据并存入到队列中-----')
def analysis_data(q):
'''数据处理'''
# 从队列中获取数据病并模拟处理
waitting_analysis_data = list()
while True:
data = q.get()
waitting_analysis_data.append(data)
if q.empty():break
print(waitting_analysis_data)
def main():
# 1.创建一个队列
q = multiprocessing.Queue()
p1 = multiprocessing.Process(target = download_from_web, args = (q,))
p2 = multiprocessing.Process(target = analysis_data ,args = (q,))
p1.start()
p2.start()
if __name__ =="__main__":
main()
3.案例-复制文件jia里所有文件青春版
用到了os模块里的mkdir创建文件夹，参数为文件夹的名字
os.listdir()获取名称为参数名称的文件夹里的所有文件名称，返回值是一个列表
引入新东西，进程池
po = multiprocessing.Pool(5)
参数表示一个进程池里最多可yi容纳五个进程
调用方法po.apply_async(copy_file ,args = (''''''''))向进程池里传入进程
close()关闭
join()让进程池里的进程执行完
函数里面 显示读取文件里的内容，再把内容写进新文件夹里文件里，完成拷贝
import os
import multiprocessing
def copy_file(file_name, new_folder_name, old_folder_name):
print(file_name)
f1 = open(old_folder_name + '/' + file_name, 'rb')
f_content = f1.read()
f1.close()
f2 = open(new_folder_name + '/' + file_name,'wb')
f2.write(f_content)
f2.close()
def main():
# 获取要下载的文件夹的名字
old_folder_name = input("请输入要复制的文件夹的名字:")
# 创建一个新的文件夹
new_folder_name = old_folder_name + "[复件]"
try:
os.mkdir(new_folder_name)
except:pass
# 获取文件夹里所有文件的名字
file_names = os.listdir(old_folder_name)
# 创建进程池
po = multiprocessing.Pool(5)
# 向进程chi里添加copy文件的任务
for file_name in file_names:
po.apply_async(copy_file, args = (file_name, new_folder_name, old_folder_name))
po.close()
po.join()
# 复制原文件夹的文件，到新文件夹里去
if __name__ == "__main__":
main()
4.案例-带进度条的文件夹拷贝器
要想实现进度条，实现主进程和子进程之间的通信，要用到队列，multiprocessing.Manager().Queue()，将队列以参数形式传入函数里，没下载好一个文件就put以下，主进程里，每get一下就输出一个进度，进度值为下载好的文件数除以总的文件数，不用调用join()因为循环一定能保证子进程执行完毕，最后break
mport os
import multiprocessing
def copy_file(q, file_name, new_folder_name, old_folder_name):
# print(file_name)
f1 = open(old_folder_name + '/' + file_name, 'rb')
f_content = f1.read()
f1.close()
f2 = open(new_folder_name + '/' + file_name, 'wb')
f2.write(f_content)
f2.close()
# 如果拷贝完了队列就像队列中写入消息
q.put(file_name)
def main():
# 获取要下载的文件夹的名字
old_folder_name = input("请输入要复制的文件夹的名字:")
# 创建一个新的文件夹
new_folder_name = old_folder_name + "[复件]"
try:
os.mkdir(new_folder_name)
except:pass
# 获取文件夹里所有文件的名字
file_names = os.listdir(old_folder_name)
# 创建进程池
po = multiprocessing.Pool(5)
# 创建队列
q = multiprocessing.Manager().Queue()
# 向进程chi里添加copy文件的任务
for file_name in file_names:
po.apply_async(copy_file, args = (q, file_name, new_folder_name, old_folder_name))
po.close()
# po.join()
all_file_num = len(file_names)
now_file_num = 0
while True:
q.get()
now_file_num += 1
print('拷贝进度：%.2f%%' % (now_file_num * 100 / all_file_num))
if now_file_num >= all_file_num:break
# 复制原文件夹的文件，到新文件夹里去
if __name__ == "__main__":
main()
3.多任务（协程实现）
1.迭代器-自己定义的类进行迭代青春版
from collections import Iterable,Iterator
import time
class Classmate(object):
def __init__(self):
self.names = list()
def add(self,name):
self.names.append(name)
def __iter__(self):
return ClassIterator(self)
class ClassIterator():
def __init__(self,obj):
self.obj = obj
def __iter__(self):
pass
def __next__(self):
return self.obj.names[0]
classmate = Classmate()
classmate.add('张三')
classmate.add('李四')
classmate.add('王五')
# print("判断classmate是否是可以迭代的对象：", isinstance(classmate, Iterable))
# classmate_iterator = iter(classmate)
# print("判断classmate_iterator是否是迭代器：", isinstance(classmate_iterator, Iterator))
# print(next(classmate_iterator))
for temp in classmate:
print(temp)
time.sleep(1)
~ 2.迭代器-自己的类进行迭代
将Classmate类里添加 __iter__ 和 __next__类 完成迭代器
from collections.abc import Iterable,Iterator
import time
class Classmate(object):
def __init__(self):
self.names = list()
self.current_num = 0
def add(self,name):
self.names.append(name)
def __iter__(self):
return self
def __next__(self):
if self.current_num < len(self.names):
ret = self.names[self.current_num]
self.current_num += 1
return ret
else:
raise StopIteration
classmate = Classmate()
classmate.add('张三')
classmate.add('李四')
classmate.add('王五')
# print("判断classmate是否是可以迭代的对象：", isinstance(classmate, Iterable))
# classmate_iterator = iter(classmate)
# print("判断classmate_iterator是否是迭代器：", isinstance(classmate_iterator, Iterator))
# print(next(classmate_iterator))
for temp in classmate:
print(temp)
time.sleep(1)
~
~ 3.迭代器实现多任务（Fibonacci为例子）
迭代器的优点：相对于list()创建列表，迭代器占用的内存非常小
class Fibonacci():
def __init__(self,all_num):
self.all_num = all_num
self.a = 0
self.b = 1
self.current_num = 0
def __iter__(self):
return self
def __next__(self):
if self.all_num > self.current_num:
ret = self.a
self.a ,self.b = self.b, self.a + self.b
self.current_num += 1
return ret
else:raise StopIteration
f = Fibonacci(10)
for num in f:
print(num)
4.生成器-实现斐波那契数列
在函数里只要有yield就不是函数了，是生成器，创建对象obj，调用next(obj)调取a的值
def create_num(all_num):
print('------1------')
a, b = 0, 1
current_num = 0
while current_num < all_num:
print('------2------')
yield a
# print(a)
print('------3------')
a, b = b, a + b
current_num += 1
# 如果函数有一个yield语句，这个函数就不是函数了，成为了一个生成器的模板，调用create_num时，生成器是一种特殊的迭代器，创建了一个生成器的对象
obj = create_num(10)
ret = next(obj)
print(ret)
ret = next(obj)
print(ret)
# for i in obj:
# print(i)
~
~ 5.生成器的一些知识
循环读取数据，当读不出来是，抛出一场 e.value为生成器的返回值
def create_num(all_num):
print('------1------')
a, b = 0, 1
current_num = 0
while current_num < all_num:
print('------2------')
yield a
# print(a)
print('------3------')
a, b = b, a + b
current_num += 1
return 'ok------ok'
# 如果函数有一个yield语句，这个函数就不是函数了，成为了一个生成器的模板，调用create_num时，生成器是一种特殊的迭代器，创建了一个生成器的对象
obj = create_num(10)
while True:
try:
ret = next(obj)
print(ret)
except Exception as e:
print(e.value)
break
# for i in obj:
# print(i)
6.生成器send()实现多任务
send和next差不多，但是 通过向send传参数， ret = yield a可以收到参数值
def create_num(all_num):
print('------1------')
a, b = 0, 1
current_num = 0
while current_num < all_num:
print('------2------')
ret = yield a
print("ret：",ret)
# print(a)
print('------3------')
a, b = b, a + b
current_num += 1
return 'ok------ok'
# 如果函数有一个yield语句，这个函数就不是函数了，成为了一个生成器的模板，调用create_num时，生成器是一种特殊的迭代器，创建了一个生成器的对象
obj = create_num(10)
ret = next(obj)
print(ret)
ret = obj.send('wocaowocaowocao')
print(ret)
# for i in obj:
# print(i)
~
~ 7.通过yield完成多任务
看看就能懂
import time
def test1():
while True:
print("-----1-----")
time.sleep(0.1)
yield
def test2():
while True:
print("-----2-----")
time.sleep(0.1)
yield
def main():
t1 = test1()
t2 = test2()
while True:
next(t1)
next(t2)
if __name__ == "__main__":
main()
~
~ 8.greenlet多任务
调用实例对象后，在两个函数里switch()完成多任务，并发执行
from greenlet import greenlet
import time
def test1():
while True:
print("-----1-----")
gr2.switch()
time.sleep(0.5)
def test2():
while True:
print("-----2-----")
gr1.switch()
time.sleep(0.5)
gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()
9.gevent完成多任务
这个不常用
import gevent
import time
def f(n):
for i in range(n):
print(gevent.getcurrent(),i)
# time.sleep(0.5)
gevent.sleep(0.5)
# （ 函数名，参数）
g1 = gevent.spawn(f,5)
g2 = gevent.spawn(f,5)
g3 = gevent.spawn(f,5)
# join遇到了延时，等待g1运行完，延时时还能执行其他的
g1.join()
g2.join()
g3.join()
10.gevent多任务-2
这个常用
import gevent
import time
from gevent import monkey
# 打补丁:把当前代码所有耗时的代码换成gevent
monkey.patch_all()
def f(n):
for i in range(n):
print(gevent.getcurrent(),i)
time.sleep(0.5)
# gevent.sleep(0.5)
# （ 函数名，参数）
# g1 = gevent.spawn(f,5)
# g2 = gevent.spawn(f,5)
# g3 = gevent.spawn(f,5)
# join遇到了延时，等待g1运行完，延时时还能执行其他的
# g1.join()
# g2.join()
# g3.join()
# joinall更常用
gevent.joinall([gevent.spawn(f,5),gevent.spawn(f,5),gevent.spawn(f,5)])
11.案例-图片下载器
看看就懂
import urllib.request
import gevent
from gevent import monkey
monkey.patch_all()
def downloader(img_name, img_url):
req = urllib.request.urlopen(img_url)
img_content = req.read()
with open(img_name, "wb") as f:
f.write(img_content)
def main():
gevent.joinall([
gevent.spawn(downloader, '3.jpg', 'https://rpic.douyucdn.cn/live-cover/roomCover/2022/01/14/39e88aa4a2576eb6f0b64b71aa7730ef_big.png/dy1'),
gevent.spawn(downloader, '4.jpg', 'http://i2.hdslb.com/bfs/archive/9cbd84d68b1ebe28e39229cbe02ce7f54e8c2365.jpg@672w_378h_1c')
])
if __name__ == "__main__":
main()
三.web服务器v3.1
1.正则表达式简介
直接上案例
1.正则判断变量名是否合理
import re
def main():
while True:
name = input("请输入变量名称:(输入quit退出)")
# match自动判断开头
# ret = re.match(r"[a-zA-Z_][a-zA-Z_0-9]*$",name)
ret = re.match(r"^[a-zA-Z_][a-zA-Z_0-9]*$",name)
if name == 'quit':break
elif ret:print("成功%s" %ret.group())
else:print("失败喽！")
if __name__ == "__main__":
main()
2.正则判断常用邮箱地址
import re
def main():
while True:
email_name = input("请输入变量名称:(输入quit退出)")
# match自动判断开头,\使需要的特殊字符转义
ret = re.match(r"^[a-zA-Z_0-9]{4,20}@(163|126|qq|gmail)\.com$",email_name)
if email_name == 'quit':break
elif ret:print("成功%s" %ret.group())
else:print("失败喽！")
if __name__ == "__main__":
main()
2.http
1.实现简单的http服务器
浏览器相当于客户端，向服务器提出请求
服务器回送浏览器需要的数据
import socket
def service_client(new_socket):
'''为这个客户端返回数据'''
# 接受浏览器发送的请求（http请求）
request = new_socket.recv(1024)
print(request)
# 返回http格式的数据给浏览器
# 准备发送给浏览器的数据 -----header \r\n表示浏览器可以识别的换行
response = "HTTP/1.1 200 OK\r\n"
response += "\r\n"
# 准备发送给浏览器的数据 -----body
response += "<h1>this is a test.</h1>"
new_socket.send(response.encode("utf-8"))
#关闭
new_socket.close()
def main():
# 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 绑定
tcp_server_socket.bind(("",7890))
# 变为监听套接字
tcp_server_socket.listen(128)
while True:
# 等待客户链接
new_socket, client_addr = tcp_server_socket.accept()
# 服务
service_client(new_socket)
# 关闭
tcp_server_socket.close()
if __name__ == "__main__":
main()
2.根据客户端需要完成http服务器
import socket
def service_client(new_socket):
'''为这个客户端返回数据'''
# 接受浏览器发送的请求（http请求）
request = new_socket.recv(1024)
print(request)
print(">>>>>>>>>>" * 4) # 返回http格式的数据给浏览器
# 准备发送给浏览器的数据 -----header \r\n表示浏览器可以识别的换行
response = "HTTP/1.1 200 OK\r\n"
response += "\r\n"
# 准备发送给浏览器的数据 -----body
# response += "<h1>this is a test.</h1>"
with open("./html/index.html",'rb') as f:
f_content = f.read()
new_socket.send(response.encode("utf-8"))
new_socket.send(f_content)
#关闭
new_socket.close()
def main():
# 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 重复利用同一个端口
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
# 绑定
tcp_server_socket.bind(("",7890))
# 变为监听套接字
tcp_server_socket.listen(128)
while True:
# 等待客户链接
new_socket, client_addr = tcp_server_socket.accept()
# 服务
service_client(new_socket)
# 关闭
tcp_server_socket.close()
if __name__ == "__main__":
main()
3.返回index页面http
import socket
import re
def service_client(new_socket):
'''为这个客户端返回数据'''
# 接受浏览器发送的请求（http请求）
request = new_socket.recv(1024).decode('utf-8')
# print(request)
# print(">>>>>>>>>>" * 4) # 返回http格式的数据给浏览器
request_lines = request.splitlines()
print("")
print(">" * 20)
print(request_lines)
file_name = ''
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
if ret:
file_name = ret.group(1)
# print("*" * 50, file_name)
if file_name == '/':file_name = '/index.html'
# 准备发送给浏览器的数据 -----body
# response += "<h1>this is a test.</h1>"
try:
with open("./html" + file_name, 'rb') as f:
f_content = f.read()
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "-----file not found-----"
new_socket.send(response.encode('utf-8'))
else:
# 准备发送给浏览器的数据 -----header \r\n表示浏览器可以识别的换行
response = "HTTP/1.1 200 OK\r\n"
response += "\r\n"
new_socket.send(response.encode("utf-8"))
new_socket.send(f_content)
#关闭
new_socket.close()
def main():
# 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 重复利用同一个端口
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
# 绑定
tcp_server_socket.bind(("",7890))
# 变为监听套接字
tcp_server_socket.listen(128)
while True:
# 等待客户链接
new_socket, client_addr = tcp_server_socket.accept()
# 服务
service_client(new_socket)
# 关闭
tcp_server_socket.close()
if __name__ == "__main__":
main()
4.使用多进程完成http服务器
import multiprocessing
import socket
import re
def service_client(new_socket):
'''为这个客户端返回数据'''
# 接受浏览器发送的请求（http请求）
request = new_socket.recv(1024).decode('utf-8')
# print(request)
# print(">>>>>>>>>>" * 4) # 返回http格式的数据给浏览器
request_lines = request.splitlines()
print("")
print(">" * 20)
print(request_lines)
file_name = ''
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
if ret:
file_name = ret.group(1)
# print("*" * 50, file_name)
if file_name == '/':file_name = '/index.html'
# 准备发送给浏览器的数据 -----body
# response += "<h1>this is a test.</h1>"
try:
with open("./html" + file_name, 'rb') as f:
f_content = f.read()
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "-----file not found-----"
new_socket.send(response.encode('utf-8'))
else:
# 准备发送给浏览器的数据 -----header \r\n表示浏览器可以识别的换行
response = "HTTP/1.1 200 OK\r\n"
response += "\r\n"
new_socket.send(response.encode("utf-8"))
new_socket.send(f_content)
#关闭
new_socket.close()
def main():
# 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 重复利用同一个端口
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
# 绑定
tcp_server_socket.bind(("",7777))
# 变为监听套接字
tcp_server_socket.listen(128)
while True:
# 等待客户链接
new_socket, client_addr = tcp_server_socket.accept()
# 服务
p = multiprocessing.Process(target = service_client, args = (new_socket,))
p.start()
new_socket.close()
# 关闭
tcp_server_socket.close()
if __name__ == "__main__":
main()
5.使用多线程完成http
import threading
import socket
import re
def service_client(new_socket):
'''为这个客户端返回数据'''
# 接受浏览器发送的请求（http请求）
request = new_socket.recv(1024).decode('utf-8')
# print(request)
# print(">>>>>>>>>>" * 4) # 返回http格式的数据给浏览器
request_lines = request.splitlines()
print("")
print(">" * 20)
print(request_lines)
file_name = ''
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
if ret:
file_name = ret.group(1)
# print("*" * 50, file_name)
if file_name == '/':file_name = '/index.html'
# 准备发送给浏览器的数据 -----body
# response += "<h1>this is a test.</h1>"
try:
with open("./html" + file_name, 'rb') as f:
f_content = f.read()
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "-----file not found-----"
new_socket.send(response.encode('utf-8'))
else:
# 准备发送给浏览器的数据 -----header \r\n表示浏览器可以识别的换行
response = "HTTP/1.1 200 OK\r\n"
response += "\r\n"
new_socket.send(response.encode("utf-8"))
new_socket.send(f_content)
#关闭
new_socket.close()
def main():
# 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 重复利用同一个端口
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
# 绑定
tcp_server_socket.bind(("",7777))
# 变为监听套接字
tcp_server_socket.listen(128)
while True:
# 等待客户链接
new_socket, client_addr = tcp_server_socket.accept()
# 服务
t = threading.Thread(target = service_client, args = (new_socket,))
t.start()
# 多线程不需要所有的套接字都关闭
# new_socket.close()
# 关闭
tcp_server_socket.close()
if __name__ == "__main__":
main()
6.协程完成http服务器
import gevent
from gevent import monkey
import socket
import re
monkey.patch_all()
def service_client(new_socket):
'''为这个客户端返回数据'''
# 接受浏览器发送的请求（http请求）
request = new_socket.recv(1024).decode('utf-8')
# print(request)
# print(">>>>>>>>>>" * 4) # 返回http格式的数据给浏览器
request_lines = request.splitlines()
print("")
print(">" * 20)
print(request_lines)
file_name = ''
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
if ret:
file_name = ret.group(1)
# print("*" * 50, file_name)
if file_name == '/':file_name = '/index.html'
# 准备发送给浏览器的数据 -----body
# response += "<h1>this is a test.</h1>"
try:
with open("./html" + file_name, 'rb') as f:
f_content = f.read()
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "-----file not found-----"
new_socket.send(response.encode('utf-8'))
else:
# 准备发送给浏览器的数据 -----header \r\n表示浏览器可以识别的换行
response = "HTTP/1.1 200 OK\r\n"
response += "\r\n"
new_socket.send(response.encode("utf-8"))
new_socket.send(f_content)
#关闭
new_socket.close()
def main():
# 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 重复利用同一个端口
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
# 绑定
tcp_server_socket.bind(("",7777))
# 变为监听套接字
tcp_server_socket.listen(128)
while True:
# 等待客户链接
new_socket, client_addr = tcp_server_socket.accept()
# 服务
gevent.spawn(service_client, new_socket)
# 关闭
tcp_server_socket.close()
if __name__ == "__main__":
main()
7.单进程单线程非堵塞并发完成http服务器
import socket
def service_client(new_socket):
'''为这个客户端返回数据'''
# 接受浏览器发送的请求（http请求）
request = new_socket.recv(1024)
print(request)
print(">>>>>>>>>>" * 4) # 返回http格式的数据给浏览器
# 准备发送给浏览器的数据 -----header \r\n表示浏览器可以识别的换行
response = "HTTP/1.1 200 OK\r\n"
response += "\r\n"
# 准备发送给浏览器的数据 -----body
# response += "<h1>this is a test.</h1>"
with open("./html/index.html",'rb') as f:
f_content = f.read()
new_socket.send(response.encode("utf-8"))
new_socket.send(f_content)
#关闭
new_socket.close()
def main():
# 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 重复利用同一个端口
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
# 绑定
tcp_server_socket.bind(("",7890))
# 变为监听套接字
tcp_server_socket.listen(128)
# 设置套接字为非堵塞的方式
tcp_server_socket.setblocking(False)
# 创建一个套接字列表
new_socket_list = list()
while True:
try:
# 等待客户链接
new_socket, client_addr = tcp_server_socket.accept()
except Exception as ret:
print("-----没有客户端到来-----")
else:
print("---客户端到来---")
new_socket.setblocking(False)
new_socket_list.append(new_socket)
for new_socket in new_socket_list:
try:
recv_data = new_socket.recv(1024)
except Exception as ret:
print("客户端没有发送数据")
else:
if recv_data:
# 对方发送了数据
print("接收到数据")
else:
# 对方调用了close()
new_socket_list.remove(new_socket)
new_socket.close()
# 服务
# service_client(new_socket)
# 关闭
tcp_server_socket.close()
if __name__ == "__main__":
main()
8.单进程单线程非堵塞长连接
import socket
import re
def service_client(new_socket, request):
'''为这个客户端返回数据'''
# 接受浏览器发送的请求（http请求）
# request = new_socket.recv(1024)
# print(request)
# print(">>>>>>>>>>" * 4) # 返回http格式的数据给浏览器
# 准备发送给浏览器的数据 -----header \r\n表示浏览器可以识别的换行
request_lines = request.splitlines()
print('')
print(">" * 20)
print(request_lines)
file_name = ''
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
if ret:
file_name = ret.group(1)
if file_name == '/':
file_name = '/index.html'
# 准备发送给浏览器的数据 -----body
# response += "<h1>this is a test.</h1>"
try:
f = open("./html" + file_name, 'rb')
except:
response_body = "sorry,there are no file that you wanna."
response_header = "HTTP/1.1 404 NOT FOUND\r\n"
response_header += f'Content-Length:{len(response_body)}'
response_header += '\r\n'
response = response_header + response_body
new_socket.send(response.encode('utf-8'))
else:
f_content = f.read()
f.close()
response_body = f_content
response_header = "HTTP/1.1 200 OK\r\n"
response_header += 'Content-Length:%d\r\n' % len(response_body)
response_header += '\r\n'
response = response_header.encode('utf-8') + response_body
new_socket.send(response)
# 关闭
# new_socket.close()
def main():
# 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 重复利用同一个端口
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
# 绑定
tcp_server_socket.bind(("",7890))
# 变为监听套接字
tcp_server_socket.listen(128)
# 非堵塞
tcp_server_socket.setblocking(False)
new_socket_list = list()
while True:
try:
# 等待客户链接
new_socket, client_addr = tcp_server_socket.accept()
except Exception as ret:
pass
else:
new_socket.setblocking(False)
new_socket_list.append(new_socket)
for client_socket in new_socket_list:
try:
recv_data = client_socket.recv(1024).decode('utf-8')
except Exception as ret:
pass
else:
if recv_data:
service_client(client_socket, recv_data)
else:
client_socket.close()
new_socket_list.remove(client_socket)
# 服务
# service_client(new_socket)
# 关闭
tcp_server_socket.close()
if __name__ == "__main__":
main()
9.epoll实现http服务器
import socket
import select
import re
def service_client(new_socket, request):
'''为这个客户端返回数据'''
# 接受浏览器发送的请求（http请求）
# request = new_socket.recv(1024)
# print(request)
# print(">>>>>>>>>>" * 4) # 返回http格式的数据给浏览器
# 准备发送给浏览器的数据 -----header \r\n表示浏览器可以识别的换行
request_lines = request.splitlines()
print('')
print(">" * 20)
print(request_lines)
file_name = ''
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
if ret:
file_name = ret.group(1)
if file_name == '/':
file_name = '/index.html'
# 准备发送给浏览器的数据 -----body
# response += "<h1>this is a test.</h1>"
try:
f = open("./html" + file_name, 'rb')
except:
response_body = "sorry,there are no file that you wanna."
response_header = "HTTP/1.1 404 NOT FOUND\r\n"
response_header += f'Content-Length:{len(response_body)}'
response_header += '\r\n'
response = response_header + response_body
new_socket.send(response.encode('utf-8'))
else:
f_content = f.read()
f.close()
response_body = f_content
response_header = "HTTP/1.1 200 OK\r\n"
response_header += 'Content-Length:%d\r\n' % len(response_body)
response_header += '\r\n'
response = response_header.encode('utf-8') + response_body
new_socket.send(response)
# 关闭
# new_socket.close()
def main():
# 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 重复利用同一个端口
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
# 绑定
tcp_server_socket.bind(("",7777))
# 变为监听套接字
tcp_server_socket.listen(128)
# 非堵塞
tcp_server_socket.setblocking(False)
# 创建一个epoll对象
epl = select.epoll()
# 将监听套接字对应的fd注册到epoll中
epl.register(tcp_server_socket.fileno(), select.EPOLLIN)
fd_event_dict = dict()
while True:
fd_event_list = epl.poll() # 默认会堵塞,直到 os监测到数据到来 通过事件通知方式 告诉这个程序，此时才会解堵塞
# [(df, event), (套接字对应的文件描述符，描述符到底是什么时间例如调用recv接收等)]
for fd, event in fd_event_list:
# 等待新客户端的链接
if fd == tcp_server_socket.fileno():
new_socket, client_addr = tcp_server_socket.accept()
epl.register(new_socket.fileno(), select.EPOLLIN)
fd_event_dict[new_socket.fileno()] = new_socket
elif event == select.EPOLLIN:
# 判断已经链接的客户端是否有数据发送过来
recv_data = fd_event_dict[fd].recv(1024).decode('utf-8')
if recv_data:
service_client(fd_event_dict[fd], recv_data)
else:
fd_event_dict[fd].close()
epl.unregister(fd)
del fd_event_dict[fd]
# 服务
# service_client(new_socket)
# 关闭
tcp_server_socket.close()
if __name__ == "__main__":
main()
扫一扫
356
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
