24. 阶段总结
目标:对第三模块 阶段的知识点进行总结和练习。
概要:
- 知识补充
- 阶段总结(思维导图)
- 考试题
1. 知识点补充
1.1 并发编程 & 网络编程
从知识点的角度来看,本身两者其实没有什么关系:
-
网络编程,基于网络基础知识、socket模块实现网络的数据传输。
-
并发编程,基于多进程、多线程等 来提升程序的执行效率。
但是,在很多 “框架” 的内部其实会让两者结合起来,使用多进程、多线程等手段来提高网络编程的处理效率。
案例1:多线程socket服务端
基于多线程实现socket服务端,实现同时处理多个客户端的请求。
-
服务端
import socket import threading def task(conn): while True: client_data = conn.recv(1024) data = client_data.decode('utf-8') print("收到客户端发来的消息:", data) if data.upper() == "Q": break conn.sendall("收到收到".encode('utf-8')) conn.close() def run(): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.bind(('127.0.0.1', 8001)) sock.listen(5) while True: # 等待客户端来连接(主线程) conn, addr = sock.accept() # 创建子线程 t = threading.Thread(target=task, args=(conn,)) t.start() sock.close() if __name__ == '__main__': run()
-
客户端
import socket # 1. 向指定IP发送连接请求 client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.connect(('127.0.0.1', 8001)) while True: txt = input(">>>") client.sendall(txt.encode('utf-8')) if txt.upper() == 'Q': break reply = client.recv(1024) print(reply.decode("utf-8")) # 关闭连接,关闭连接时会向服务端发送空数据。 client.close()
案例2:多进程socket服务端
基于多进程实现socket服务端,实现同时处理多个客户端的请求。
-
服务端
import socket import multiprocessing def task(conn): while True: client_data = conn.recv(1024) data = client_data.decode('utf-8') print("收到客户端发来的消息:", data) if data.upper() == "Q": break conn.sendall("收到收到".encode('utf-8')) conn.close() def run(): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.bind(('127.0.0.1', 8001)) sock.listen(5) while True: # 等待客户端来连接 conn, addr = sock.accept() # 创建了子进程(至少有个线程) t = multiprocessing.Process(target=task, args=(conn,)) t.start() sock.close() if __name__ == '__main__': run()
-
客户端
import socket # 1. 向指定IP发送连接请求 client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.connect(('127.0.0.1', 8001)) while True: txt = input(">>>") client.sendall(txt.encode('utf-8')) if txt.upper() == 'Q': break reply = client.recv(1024) print(reply.decode("utf-8")) # 关闭连接,关闭连接时会向服务端发送空数据。 client.close()
1.2 并发和并行
如何来理解这些概念呢?
-
串行,多个任务排队按照先后顺序逐一去执行。
-
并发,假设有多个任务,只有一个CPU,那么在同一时刻只能处理一个任务,为了避免串行,可以让将任务切换运行(每个任务运行一点,然后再切换),达到并发效果(看似都在同时运行)。
并发在Python代码中体现:协程、多线程(由CPython的GIL锁限制,多个线程无法被CPU调度)。
-
并行,假设有多个任务,有多个CPU,那么同一时刻每个CPU都是执行一个任务,任务就可以真正的同时运行。
并行在Python代码中的体现:多进程。
1.3 单例模式
在python开发和源码中关于单例模式有两种最常见的编写方式,分别是:
-
基于
__new__
方法实现import threading import time class Singleton: instance = None lock = threading.RLock() def __init__(self): self.name = "盖伦" def __new__(cls, *args, **kwargs): if cls.instance: return cls.instance with cls.lock: if cls.instance: return cls.instance # time.sleep(0.1) cls.instance = object.__new__(cls) return cls.instance obj1 = Singleton() obj2 = Singleton() print(obj1 is obj2) # True
-
基于模块导入方式
# utils.py class Singleton: def __init__(self): self.name = "盖伦" ... single = Singleton()
from xx import single print(single) from xx import single print(single)
2. 阶段总结
3. 练习
-
简述面向对象的三大特性
继承,将多个子类中相同的方法放在父类中,子类可以继承父类中的方法(提升重用性) 封装,将多个数据封装到一个对象; 将同类的方法编写(封装)在一个类型中。 多态,天然支持多态,崇尚鸭子模型,不会对类型进行限制,只要具备相应的属性即可,例如: def func(arg): arg.send() 不管arg是什么类型,只要具备send方法即可。
-
super的作用?
根据mro的顺序,向上寻找类。
-
实例变量和类变量的区别?
实例变量,属于对象,每个对象中都各自存储各自的实例变量。 类变量,属于类,在类中存储。
-
@staticmethod 和 @classmethod的区别?
@staticmethod,静态方法; 定义时:可以有任意个参数; 执行时:类和对象均可以触发执行。 @classmethod,类方法; 定义时:至少有一个cls参数; 执行时:类和对象均可以触发执行,自动把当前类当做参数传递给cls。
-
简述
__new__
和__init__
的区别?__new__,构造方法,用于创建对象。 __init__,初始化方法,用于在对象中初始化值。
-
在Python中如何定义私有成员?
用两个下划线开头。
-
请基于
__new__
实现一个单例类(加锁)。import threading class Singleton(object): instance = None lock = threading.RLock() def __init__(self, name, age): self.name = name self.age = age def __new__(cls, *args, **kwargs): if cls.instance: return cls.instance with cls.lock: if cls.instance: return cls cls.instance = super().__new__(cls) return cls.instance obj1 = Singleton('盖伦', 18) print(obj1) obj2 = Singleton('vn', 18) print(obj2) # 注意:单例模式,用于用的是第一次创建的那个对象,但对象中的实例变量会被重置。
-
比较以下两段代码的区别
class Foo(object): def func(self,num): pass obj = Foo() obj.func(123) obj = Foo() Foo.func(obj,123)
class F1(object): def func(self,num): print("F1.func",num) class F2(F1): def func(self,num): print("F2.func",num) class F3(F2): def run(self): F1.func(self,1) # 直接执行F1中的func方法。 obj = F3() obj.run()
class F1(object): def func(self,num): print("F1.func",num) class F2(F1): def func(self,num): print("F2.func",num) class F3(F2): def run(self): super().func(1) # 根据mro的顺序,执行F2中的func方法 obj = F3() obj.run()
-
补充代码实现
class Context: pass with Context() as ctx: ctx.do_something() # 请在Context类下添加代码完成该类的实现
class Context: def __enter__(self): print("进入") return self def __exit__(self, exc_type, exc_val, exc_tb): print("出去") def do_something(self): print("执行") with Context() as ctx: ctx.do_something()
-
简述 迭代器、可迭代对象 的区别?
迭代器, 1.当类中定义了 __iter__ 和 __next__ 两个方法。 2.__iter__ 方法需要返回对象本身,即:self 3. __next__ 方法,返回下一个数据,如果没有数据了,则需要抛出一个StopIteration的异常。 可迭代对象,在类中定义了 __iter__ 方法并返回一个迭代器对象。
-
什么是反射?
反射,通过字符串的形式去操作对象中的成员。例如:getattr/setattr/delattr/hashattr
-
简述OSI七层模型。
OSI七层模型分为:应用层、表示层、会话层、传输层、网络层、数据连路程、物理层,其实就是让各层各司其职,完成各自的事。 以Http协议为例,简述各层的职责: 应用层,规定数据传格式。 "GET /s?wd=你好 HTTP/1.1\r\nHost:www.baidu.com\r\n\r\n" 表示层,对应用层数据的编码、压缩(解压缩)、分块、加密(解密)等任务。 "GET /s?wd=你好 HTTP/1.1\r\nHost:www.baidu.com\r\n\r\n你好".encode('utf-8') 会话层,负责与目标建立、中断连接。 传输层,建立端口到端口的通信,其实就确定双方的端口信息。 数据:"GET /s?wd=你好 HTTP/1.1\r\nHost:www.baidu.com\r\n\r\n你好".encode('utf-8') 端口: - 目标:80 - 本地:6784 网络层,标记IP信息。 数据:"GET /s?wd=你好 HTTP/1.1\r\nHost:www.baidu.com\r\n\r\n你好".encode('utf-8') 端口: - 目标:80 - 本地:6784 IP: - 目标IP:110.242.68.3 - 本地IP:192.168.10.1 数据连路程,设置MAC地址信息 数据:"POST /s?wd=你好 HTTP/1.1\r\nHost:www.baidu.com\r\n\r\n你好".encode('utf-8') 端口: - 目标:80 - 本地:6784 IP: - 目标IP:110.242.68.3(百度) - 本地IP:192.168.10.1 MAC: - 目标MAC:FF-FF-FF-FF-FF-FF - 本机MAC:11-9d-d8-1a-dd-cd 物理层,将二进制数据在物理媒体上传输。
-
UDP和TCP的区别。
- UDP,UDP不提供可靠性,它只是把应⽤程序传给IP层的数据报发送出去, 但是并不能保证它们能到达⽬的地。 由于UDP在传输数据报前不⽤在客户和服务器之间建⽴⼀个连接, 且没有超时重发等机制, 故⽽传输速度很快。常见的有:语音通话、视频通话、实时游戏画面 等。 - TCP,在收发数据前,必须和对方建立可靠的连接,然后再进行收发数据。常见有:网站、手机APP数据获取等。
-
简述TCP三次握手和四次挥手的过程。
创建连接,三次握手: 第一次:客户端向服务端请求,发送:seq=100(随机值); 第二次:服务端接收请求,然后给客户端发送:seq=300(随机值)、ack=101(原来客户端口发来请求的seq+1) 第三次:客户接接收请求,然后给服务端发送:seq=101(第2次返回的值)、 ack=301(第2次seq+1) 第1、2次过程,客户端发送了数据seq,服务端也回给了seq+1,证明:客户端可以正常收发数据。此时,服务端不知客户端是否正常接收到了。 第2、3次过程,服务端发送了数据seq,客户端也返回了seq+1,证明:服务端可以正常收发数据。 断开连接,四次挥手:(任意一方都可以发起) 第一次:客户端向服务端发请求,发送:<seq=100><ack=300> (我要与你断开连接) 第二次:服务端接收请求,然后给客户端发送:<seq=300><ack=101> (已收到,可能还有数据未处理,等等) 第三次:服务端接收请求,然后给客户端发送:<seq=300><ack=101> (可以断开连接了) 第四次:客户端接收请求,然后给服务端发送:<seq=101><ack=301> (好的,可以断开了)
-
简述你理解的IP和子网掩码。
子网掩码用于给IP划分网段,IP分为:网络地址 + 主机地址。 简而言之,子网掩码掩盖的IP部分就是网络地址,未掩盖就是主机部分。 例如: IP:192.168.1.199 11000000.10101000.00000001.11000111 子网掩码:255.255.255.0 11111111.11111111.11111111.00000000 此时,网络地址就是前24位 + 主机地址是后8位。你可能见过有些IP这样写 192.168.1.199/24,意思也是前24位是网络地址。
-
端口的作用?
在网络编程中,IP代指的是计算机,而端口则代指计算机中的某个程序。以方便对计算机中的多个程序进程区分。
-
什么是粘包?如何解决粘包?
两台电脑在进行收发数据时,其实不是直接将数据传输给对方。 - 对于发送者,执行 `sendall/send` 发送消息时,是将数据先发送至自己网卡的 写缓冲区 ,再由缓冲区将数据发送给到对方网卡的读缓冲区。 - 对于接受者,执行 `recv` 接收消息时,是从自己网卡的读缓冲区获取数据。 所以,如果发送者连续快速的发送了2条信息,接收者在读取时会认为这是1条信息,即:2个数据包粘在了一起。 解决思路: 双方约定好规则,在每次收发数据时,都按照固定的 数据头 + 数据 来进行处理数据包,在数据头中设置好数据的长度。
-
IO多路复用的作用是什么?
可以监听多个 IO对象 的变化(可读、可写、异常)。 在网络编程中一般与非阻塞的socket对象配合使用,以监听 socket服务端、客户端是否 (可读、可写、异常) IO多路复用有三种模式: - select,限制1024个 & 轮训的机制监测。 - poll,无限制 & 轮训的机制监测。 - epoll,无限制 & 采用回调的机制(边缘触发)。
-
简述进程、线程、协程的区别。
线程,是计算机中可以被cpu调度的最小单元。 进程,是计算机资源分配的最小单元(进程为线程提供资源)。 一个进程中可以有多个线程,同一个进程中的线程可以共享此进程中的资源。 由于CPython中GIL的存在: - 线程,适用于IO密集型操作。 - 进程,适用于计算密集型操作。 协程,协程也可以被称为微线程,是一种用户态内的上下文切换技术,在开发中结合遇到IO自动切换,就可以通过一个线程实现并发操作。 所以,在处理IO操作时,协程比线程更加节省开销(协程的开发难度大一些)。
-
什么是GIL锁?其作用是什么?
GIL, 全局解释器锁(Global Interpreter Lock),是CPython解释器特有一个玩意,让一个进程中同一个时刻只能有一个线程可以被CPU调用。
-
进程之间如何实现数据的共享?
multiprocessing.Value 或 multiprocessing.Array multiprocessing.Manager multiprocessing.Queue multiprocessing.Pipe
-
已知一个订单对象(tradeOrder)有如下字段:
字段英文名 中文名 字段类型 取值举例 nid ID int 123456789 name 姓名 str 张三 items 商品列表 list 可以存放多个订单对象 is_member 是否是会员 bool True 商品对象有如下字段:
字段英文名称 中文名 字段类型 取值 id 主键 int 987654321 name 商品名称 str 手机 请根据要求实现如下功能:
- 编写相关类。
- 创建订单对象并根据关系关联多个商品对象。
- 用json模块将对象进行序列化为JSON格式(提示:需自定义
JSONEncoder
)。
import json class ObjectJsonEncoder(json.JSONEncoder): def default(self, o): if type(o) in {Order, Goods}: return o.__dict__ else: return o class Order(object): def __init__(self, nid,name,is_member): self.nid = nid self.name = name self.is_member = is_member self.items = [] class Goods(object): def __init__(self, id, name): self.id = id self.name = name od = Order(666,"盖伦",True) od.items.append( Goods(1, "汽车") ) od.items.append( Goods(2, "美女") ) od.items.append( Goods(3, "游艇") ) data = json.dumps(od, cls=ObjectJsonEncoder) print(data)
-
基于面向对象的知识构造一个链表。
注意:每个链表都是一个对象,对象内部均存储2个值,分为是:当前值、下一个对象 。
class Node(object): def __init__(self, value, _next): self.value = value self.next = _next # 手动创建链表 v4 = Node("ez",None) v3 = Node("提莫",v4) v2 = Node("盖伦",v3) v1 = Node("vn",v2) # 根据列表创建链表 data_list = ["vn", "盖伦", "提莫", "ez"] root = None for index in range(len(data_list) - 1, -1, -1): # [3,2,1,0] node = Node( data_list[index] , root) root = node
-
读源码,分析代码的执行过程。
-
socket服务端
import socket import threading class BaseServer: def __init__(self, server_address, request_handler_class): # ("127.0.0.1", 8000), MyHandler -> 类 self.server_address = server_address self.request_handler_class = request_handler_class def serve_forever(self): while True: # 等待客户端来连接 # conn,address = socket.accept() request, client_address = self.get_request() self.process_request(request, client_address) def finish_request(self, request, client_address): # MyHandler -> 类 # MyHandler() -> MyHandler.__init__(conn,address, self) # MyHandler.__call__方法 self.request_handler_class(request, client_address, self)() def process_request(self, request, client_address): pass def get_request(self): return "傻儿子", "vn" class TCPServer(BaseServer): address_family = socket.AF_INET socket_type = socket.SOCK_STREAM request_queue_size = 5 allow_reuse_address = False def __init__(self, server_address, request_handler_class, bind_and_activate=True): # ("127.0.0.1", 8000), MyHandler BaseServer.__init__(self, server_address, request_handler_class) self.socket = socket.socket(self.address_family, self.socket_type) self.server_bind() self.server_activate() def server_bind(self): self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.socket.bind(self.server_address) # (IP、端口) self.server_address = self.socket.getsockname() def server_activate(self): self.socket.listen(self.request_queue_size) def get_request(self): return self.socket.accept() def close_request(self, request): request.close() class ThreadingMixIn: def process_request_thread(self, request, client_address): self.finish_request(request, client_address) self.close_request(request) def process_request(self, request, client_address): t = threading.Thread(target=self.process_request_thread, args=(request, client_address)) t.start() class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass class BaseRequestHandler: def __init__(self, request, client_address, server): # conn self.request = request self.client_address = client_address self.server = server self.setup() def __call__(self, *args, **kwargs): try: self.handle() finally: self.finish() def setup(self): pass def handle(self): pass def finish(self): pass class MyHandler(BaseRequestHandler): def handle(self): print(self.request) # conn self.request.sendall(b'hahahahah...') # 在server封装了点值、然后又创建socket服务端 server = ThreadingTCPServer( ("127.0.0.1", 8000), MyHandler ) server.serve_forever()
-
socket客户端
import socket # 1. 向指定IP发送连接请求 client = socket.socket() client.connect(('127.0.0.1', 8000)) # 向服务端发起连接(阻塞)10s # 2. 连接成功之后,发送消息 client.sendall('hello'.encode('utf-8')) # 3. 等待,消息的回复(阻塞) reply = client.recv(1024) print(reply) # 4. 关闭连接 client.close()
-
-
请自己基于socket模块和threading模块实现 门票预订 平台。(无需考虑粘包)
-
用户作为socket客户端
- 输入
景区名称
,用来查询景区的余票。 - 输入
景区名称-预订者-数量
,例如:欢乐谷-vn-8
,用于预定门票。
- 输入
-
socket服务端,可以支持并发多人同时查询和购买(为每个客户度创建一个线程)。
-
服务端数据存储结构如下:
db ├── tickets │ ├── 欢乐谷.txt # 内部存储放票数量 │ ├── 迪士尼.txt │ └── 长城.txt └── users ├── vn.txt # 内部存储次用户预定记录 └── 盖伦.txt # 注意:当用户预定门票时,放票量要减去相应的数量(变为0之后,则不再接受预定)。 约定时会存在多个线程同时操作文件去修改数值。
server.py
import os import socket import threading import datetime import time BOOKING_LOCK = threading.RLock() BASE_DIR = os.path.dirname(os.path.abspath(__file__)) TICKETS_PATH = os.path.join(BASE_DIR, "db", 'tickets') USERS_PATH = os.path.join(BASE_DIR, "db", 'users') def search(conn, name): """ 查询 :param conn: 客户端连接对象 :param name: 景区名称 """ file_name = "{}.txt".format(name) file_path = os.path.join(TICKETS_PATH, file_name) if not os.path.exists(file_path): conn.sendall("暂不支持此景区{}的预定。".format(name).encode('utf-8')) return with open(file_path, mode='r', encoding='utf-8') as file_object: count = int(file_object.read().strip()) conn.sendall("景区{}剩余票数为:{}。".format(name, count).encode('utf-8')) def booking(conn, name, user, count): """ 预定 :param conn: 客户端连接对象 :param name: 景区名称 :param user: 预订者 :param count: 预定数量 """ file_name = "{}.txt".format(name) file_path = os.path.join(TICKETS_PATH, file_name) if not os.path.exists(file_path): conn.sendall("暂不支持此景区{}的预定。".format(name).encode('utf-8')) return if not count.isdecimal(): conn.sendall("预定数量必须是整型。".encode('utf-8')) return booking_count = int(count) if booking_count < 1: conn.sendall("预定数量至少1张。".encode('utf-8')) return # 线程锁 BOOKING_LOCK.acquire() with open(file_path, mode='r', encoding='utf-8') as file_object: count = int(file_object.read().strip()) if booking_count > count: conn.sendall("预定失败,景区{}剩余票数为:{}。".format(name, count).encode('utf-8')) return count = count - booking_count with open(file_path, mode='w', encoding='utf-8') as file_object: file_object.write(str(count)) user_file_name = "{}.txt".format(user) user_path = os.path.join(USERS_PATH, user_file_name) with open(user_path, mode='a', encoding='utf-8') as file_object: line = "{},{},{}\n".format(datetime.datetime.now().strftime("%Y-%m-%d"), name, booking_count) file_object.write(line) # 人为让预定时间久一点 time.sleep(5) conn.sendall("预定成功".encode('utf-8')) BOOKING_LOCK.release() def task(conn): """ 当用户连接成功后,处理客户端的请求 """ while True: client_data = conn.recv(1024) if not client_data: print("客户端失去连接") break data = client_data.decode('utf-8') if data.upper() == "Q": print("客户端退出") break data_list = data.split("-") if len(data_list) == 1: search(conn, *data_list) elif len(data_list) == 3: booking(conn, *data_list) else: conn.sendall("输入格式错误".encode('utf-8')) conn.close() def initial_path(): """ 初始化文件路径 """ path_list = [TICKETS_PATH, USERS_PATH] for path in path_list: if os.path.exists(path): continue os.makedirs(path) def run(): """ 主函数 """ initial_path() sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.bind(('127.0.0.1', 8001)) sock.listen(5) while True: # 等待客户端来连接 conn, addr = sock.accept() t = threading.Thread(target=task, args=(conn,)) t.start() sock.close() if __name__ == '__main__': run()
client.py
import socket client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.connect(('127.0.0.1', 8001)) print("门票预定系统") while True: txt = input(">>>") # 景区 or 景区-用户-asd client.sendall(txt.encode('utf-8')) if txt.upper() == 'Q': break reply = client.recv(1024) print(reply.decode("utf-8")) client.close()
-
-