Python-Python高阶技巧：闭包、装饰器、设计模式、多线程、网络编程、正则表达式、递归

版本说明

当前版本号[20231018]。

版本	修改说明
20231018	初版

版本说明
目录
Python高阶技巧
- 闭包
- - 简单闭包
  - 修改外部函数变量的值
  - 实现以下atm取钱的闭包实现了
  - 闭包注意事项
- 装饰器
- - 装饰器的一般写法（闭包写法）
  - 装饰器的语法糖写法
- 设计模式
- - 单例模式
  - - 单例的实现模式
  - 工厂模式
- 多线程
- - 进程、线程和并行执行
  - - 进程、线程
    - 并行执行
  - 多线程编程
  - - threading模块
  - 多线程练习案例
- 网络编程
- - 服务端开发
  - - Socket
    - 客户端和服务端
    - Socket服务端编程
    - 实现服务端并结合客户端进行测试
  - 客户端开发
  - - Socket客户端编程
    - 服务端客户端相互通讯
- 正则表达式
- - 基础匹配
  - - 正则的三个基础方法
  - 元字符匹配
  - - 单字符匹配
    - 数量匹配
    - 边界匹配
    - 分组匹配
- 递归
- - 递归找文件

Python高阶技巧

闭包

通过全局变量account_amount来记录余额

尽管功能实现是ok的，但是仍有问题：

代码在命名空间上（变量定义）不够干净、整洁
全局变量有被修改的风险

如何解决？

将变量定义在函数内部是行不通的
我们需要使用闭包

在函数嵌套的前提下，内部函数使用了外部函数的变量，并且外部函数返回了内部函数，我们把这个使用外部函数变量的内部函数称为闭包。

简单闭包

修改外部函数变量的值

实现以下atm取钱的闭包实现了

闭包注意事项

优点，使用闭包可以让我们得到：

•无需定义全局变量即可实现通过函数，持续的访问、修改某个值

•闭包使用的变量的所用于在函数内，难以被错误的调用修改

缺点：

•由于内部函数持续引用外部函数的值，所以会导致这一部分内存空间不被释放，一直占用内存

示例代码：

def account_create(initial_amount=0):
    def atm(num, deposit=True):
        nonlocal initial_amount
        if deposit:
            initial_amount += num
            print(f"存款：+{num}, 账户余额：{initial_amount}")
        else:
            initial_amount -= num
            print(f"存款：-{num}, 账户余额：{initial_amount}")

    return atm

atm = account_create()
atm(300)
atm(200)
atm(100, False)

装饰器

装饰器其实也是一种闭包，其功能就是在不破坏目标函数原有的代码和功能的前提下，为目标函数增加新功能。

希望给sleep函数，增加一个功能：

•在调用sleep前输出：我要睡觉了

•在调用sleep后输出：我起床了

装饰器的一般写法（闭包写法）

装饰器的语法糖写法

示例代码：

def outer(func):
    def inner():
        print("我要睡觉了")
        func()
        print("我起床了")
    return inner

@outer
def sleep():
    import random
    import time
    print("睡眠中……")
    time.sleep(random.randint(1, 5))

sleep()

设计模式

设计模式是一种编程套路，可以极大的方便程序的开发。

最常见、最经典的设计模式，就是我们所学习的面向对象了。

除了面向对象外，在编程中也有很多既定的套路可以方便开发，我们称之为设计模式：

单例、工厂模式
建造者、责任链、状态、备忘录、解释器、访问者、观察者、中介、模板、代理模式
等等模式

单例模式

创建类的实例后，就可以得到一个完整的、独立的类对象。

通过print语句可以看出，它们的内存地址是不相同的，即t1和t2是完全独立的两个对象。

某些场景下，我们需要一个类无论获取多少次类对象，都仅仅提供一个具体的实例

用以节省创建类对象的开销和内存开销，比如某些工具类，仅需要1个实例，即可在各处使用

这就是单例模式所要实现的效果。

单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。

在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。

定义: 保证一个类只有一个实例,并提供一个访问它的全局访问点
适用场景:当一个类只能有一个实例，而客户可以从一个众所周知的访问点访问它时。

单例的实现模式

工厂模式

当需要大量创建一个类的实例的时候，可以使用工厂模式。

即，从原生的使用类的构造去创建对象的形式迁移到，基于工厂提供的方法去创建对象的形式。

使用工厂类的get_person()方法去创建具体的类对象

优点：

大批量创建对象的时候有统一的入口，易于代码维护
当发生修改，仅修改工厂类的创建方法即可
符合现实世界的模式，即由工厂来制作产品（对象）

示例代码：

class Person:
    pass

class Worker(Person):
    pass

class Student(Person):
    pass

class Teacher(Person):
    pass

class PersonFactory:
    def get_person(self, p_type):
        if p_type == 'w':
            return Worker()
        elif p_type == 's':
            return Student()
        else:
            return Teacher()

pf = PersonFactory()
worker = pf.get_person('w')
stu = pf.get_person('s')
teacher = pf.get_person('t')

多线程

进程、线程和并行执行

进程、线程

现代操作系统比如Mac OS X，UNIX，Linux，Windows等，都是支持“多任务”的操作系统。

进程：就是一个程序，运行在系统之上，那么便称之这个程序为一个运行进程，并分配进程ID方便系统管理。

线程：线程是归属于进程的，一个进程可以开启多个线程，执行不同的工作，是进程的实际工作最小单位。

进程就好比一家公司，是操作系统对程序进行运行管理的单位

线程就好比公司的员工，进程可以有多个线程（员工），是进程实际的工作者

操作系统中可以运行多个进程，即多任务运行

一个进程内可以运行多个线程，即多线程运行

注意点：

进程之间是内存隔离的，即不同的进程拥有各自的内存空间。这就类似于不同的公司拥有不同的办公场所。

线程之间是内存共享的，线程是属于进程的，一个进程内的多个线程之间是共享这个进程所拥有的内存空间的。

这就好比，公司员工之间是共享公司的办公场所。

并行执行

并行执行的意思指的是同一时间做不同的工作。

进程之间就是并行执行的，操作系统可以同时运行好多程序，这些程序都是在并行执行。

除了进程外，线程其实也是可以并行执行的。

也就是比如一个Python程序，其实是完全可以做到：

一个线程在输出：你好
一个线程在输出：Hello

像这样一个程序在同一时间做两件乃至多件不同的事情，我们就称之为：多线程并行执行

多线程编程

threading模块

绝大多数编程语言，都允许多线程编程，Pyhton也不例外。

Python的多线程可以通过threading模块来实现。

多线程练习案例

import time
import threading

def sing(msg):
    while True:
        print(msg)
        time.sleep(1)

def dance(msg):
    while True:
        print(msg)
        time.sleep(1)

if __name__ == '__main__':
    #创建一个唱歌的线程
    sing_thread = threading.Thread(target=sing, args=("我要唱歌！",))
    #创建一个跳舞的线程
    dance_thread = threading.Thread(target=dance, kwargs={"msg": "我在跳舞！"})

#使线程开始工作
sing_thread.start()
dance_thread.start()

网络编程

服务端开发

Socket

socket (简称套接字) 是进程之间通信一个工具，好比现实生活中的插座，所有的家用电器要想工作都是基于插座进行，进程之间想要进行网络通信需要socket。

Socket负责进程之间的网络数据传输，好比数据的搬运工。

客户端和服务端

2个进程之间通过Socket进行相互通讯，就必须有服务端和客户端

Socket服务端：等待其它进程的连接、可接受发来的消息、可以回复消息

Socket客户端：主动连接服务端、可以发送消息、可以接收回复

Socket服务端编程

主要分为如下几个步骤：

创建socket对象

绑定socket_server到指定IP和地址

服务端开始监听端口

接收客户端连接，获得连接对象

客户端连接后，通过recv方法，接收客户端发送的消息

通过conn（客户端当次连接对象），调用send方法可以回复消息

conn（客户端当次连接对象）和socket_server对象调用close方法，关闭连接

实现服务端并结合客户端进行测试

下载网络调试助手作为客户端

https://github.com/nicedayzhu/netAssist/releases

示例代码：

#演示Socket服务端开发

import socket
#创造Socket对象
socket_server = socket.socket()
#修改ip地址和端口
socket_server.bind(("localhost", 8888))
#监听端口
socket_server.listen(1)
#listen 方法内接受一个整数传参数， 表示接受的链接数量
#等待客户端链接
#result： tuple = socket_server.accept()
#conn = result[0]    客户端和服务端的链接对象
#address = result[1]  客户端的地址信息
conn, address = socket_server.accept()
#accept方法返回的是二元元组（链接对象，客户端地址信息）
#可以通过 变量1， 变量2 = socket_server.accept()的形式，直接接受二元元组内的两个元素
#accept()方法，是阻塞的方法，等待客户端的链接，如果没有链接，就卡在这一行不再向下执行

print(f"我接收到了客户端的链接，客户端的信息是：{address}")

while True:
    #接受客户端的信息，要使用客户端和服务端的本次链接对象，而非socket_server对象
    data: str = conn.recv(1024).decode("UTF-8")
    #recv接受的参数是缓冲区大小，一般1024即可
    #recv方法的返回值是一个字节数组也就是bytes对象，不是字符串，可通过decade方法通过UTF-8编码，将字节数组转换为字符串对象
    print(f"客户端发来的信息是：{data}")
    #发送回复消息
    msg = input("请输入你要和客户端回复的消息：")
    if msg == 'exit':
        break
    conn.send(msg.encode("UTF-8"))

#关闭链接
conn.close()
socket_server.close()