python高阶技巧一

闭包

简单认识一下闭包

以下代码，内层inner函数不仅依赖于自身的参数b，还依赖于外层outer函数的参数a。inner就是一个闭包函数，既能访问外部变量，又保证外部变量不是全局的，不会被篡改掉，确保了外部变量的安全。

def outer(a):
def inner(b):
print(f"<{a}>{b}<{a}>")
return inner
n1 = outer('程序员') # n1的类型是一个函数
n1('学习python')
n1('学习java')
n2 = outer('软件测试工程师')
n2('功能测试')
n2('自动化测试')

如果要在内层函数修改外层函数的变量，需要用nonlocal修饰，示例代码如下：

def outer(num1):
def inner(num2):
# 要对外层num1进行修改的话，需要nonlocal修饰
nonlocal num1
num1 += num2
print(num1)
return inner
fn = outer(10)
fn(5)
# 输出为15

运行

案例：使用闭包方式简单实现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:
if initial_amount<num:
print(f"钱不够{num}了，取不出来！")
else:
initial_amount -= num
print(f"取款：-{num},账户余额：{initial_amount}")
return atm
atm = account_create()
atm(100, deposit=True)
atm(500, deposit=True)
atm(200, deposit=False)
atm(1000, deposit=False)

运行

闭包的优缺点：

优点：

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

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

缺点:

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

装饰器

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

示例代码1：

def outer(func):
def inner():
print("我要睡觉了......")
func()
print("睡醒了，我要起床了......")
return inner()
@outer # 相当于给sleep增加outer的装饰器
def sleep():
import random
import time
print("睡眠中......")
time.sleep(random.randint(1, 5))
sleep()

示例代码2：

（1）代码实现：统计一个函数的运行时间：

import time
# 统计一个函数的运行时间
def timer(func):
def gf():
start_time = time.time()
func()
end_time = time.time()
print("func运行的时间为：", end_time - start_time)
return gf
@timer
def foo():
time.sleep(3)
print("in foo")
foo()

（2）被装饰函数带参数

import time

# 统计一个函数的运行时间
def timer(func):
def gf(*args, **kwargs):
start_time = time.time()
func(*args, **kwargs)
end_time = time.time()
print("func运行的时间为：", end_time - start_time)
return gf
@timer
def foo(name, age):
time.sleep(3)
print("in foo", name, age)
foo("测试", 22)

（3）装饰器本身带参数

import time
# 统计一个函数的运行时间
def timer(timer_type):
print(timer_type)
def outer(func):
def inner(*args, **kwargs):
start_time = time.time()
func(*args, **kwargs)
end_time = time.time()
print("func运行的时间为：", end_time - start_time)
return inner
return outer
@timer(timer_type='second')
def foo(name, age):
time.sleep(3)
print("in foo", name, age)
foo("测试", 22)

（4）被装饰函数有返回值

import time
# 统计一个函数的运行时间
def timer(timer_type):
print(timer_type)
def outer(func):
def inner(*args, **kwargs):
start_time = time.time()
res = func(*args, **kwargs) # 接收返回值
end_time = time.time()
print("func运行的时间为：", end_time - start_time)
return res # 返回
return inner
return outer
@timer(timer_type='second')
def foo(name, age):
time.sleep(3)
print("in foo", name, age)
return name # 被装饰函数返回name
print(foo("测试", 22))

单例模式

背景

class Tool:
pass
t1 = Tool()
t2 = Tool()
print(t1)
print(t2)
# 输出结果：
# <__main__.Tool object at 0x000001CEB2B190D0>
# <__main__.Tool object at 0x000001CEB2B190A0>

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

某些场景下，我们需要一个类无论获取多少次类对象，都仅仅提供一个具体的实例，用以节省创建类对象的开销和内存开销，比如某些工具类，仅需1个实例，即可在各处使用。

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

定义：

保证一个类只有一个实例，并提供一个访问它的全局访问点

适用场景：当一个类只能有一个实例，而客户可以从一个众所周知的访问点访问它

单例的实现模式：

工厂模式

背景：

当需要大量创建一个类的实例的时候，可以使用工厂模式即，从原生的使用类的构造去创建对象的形式迁移到，基于工厂提供的方法去创建对象的形式

class Person:
pass
class Worker(Person):
pass
class Student(Person):
pass
class Teacher(Person):
pass
worker = Worker()
stu = Student()
teacher = Teacher()

以上是传统方式构建基于Person的不同类对象。

采用工厂模式，代码就会变成如下：

class Person:
pass
class Worker(Person):
pass
class Student(Person):
pass
class Teacher(Person):
pass
class Factory:
def get_person(self, p_type):
if p_type == 'w':
return Worker()
elif p_type == 's':
return Student()
else:
return Teacher()
factory = Factory()
worker = factory.get_person('w')
stu = factory.get_person('s')
teacher = factory.get_person('t')

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

大批量创建对象的时候有统一的入口，易于代码维护；

当发生修改,仅修改工厂类的创建方法即可；

符合现实世界的模式，即由工厂来制作产品(对象)

多线程编程（threading）

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

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

并行执行：

多个进程同时在运行，即不同的程序同时运行，称之为: 多任务并行执行；

一个进程内的多个线程同时在运行，称之为:多线程并行执行；

写一段代码，我们先看下单线程运行下结果：

import time
def sing():
while True:
print("我在唱歌，啦啦啦......")
time.sleep(1)
def dance():
while True:
print("我在跳舞，呱呱呱......")
time.sleep(2)
if __name__ == '__main__':
sing()
dance()

要想输出既在唱歌，又在跳舞，是无法满足的。

使用多线程的话，一个线程在唱歌，一个线程在跳舞，就可以满足需求。

语法：

import threading

thread_obj = threading.Thread([group [，target [，name [, args [，kwargs]]]]])

group: 暂时无用，未来功能的预留参数
target: 执行的目标任务名
args: 以元组的方式给执行任务传参
kwargs:以字典方式给执行任务传参
name: 线程名，一般不用设置

启动线程，让线程开始工作thread_obi.start()

import time
import threading
def sing():
while True:
print("我在唱歌，啦啦啦......")
time.sleep(1)
def dance():
while True:
print("我在跳舞，呱呱呱......")
time.sleep(2)
if __name__ == '__main__':
# 创建一个唱歌的线程
sing_thread = threading.Thread(target=sing)
# 创建一个跳舞的线程
dance_thread = threading.Thread(target=dance)
# 运行线程
sing_thread.start()
dance_thread.start()

Socket服务端编程

主要分为如下几个步骤

1.创建socket对象

import socket

socket_server = socket.socket(0)

2.绑定socket_server到指定IP和地址

socket_server.bind(host, port)

3.服务端开始监听端口

socket_server.listen(backlog)

backlog为int整数，表示允许的连接数量，超出的会等待，可以不填，不填会自动设置一个合理值

4.接收客户端连接获得连接对象

conn.address = socket_server.accept()

print(f"接收到客户端连接，连接来自: {address}")

accept方法是阻塞方法，如果没有连接，会卡在当前这一行不向下执行代码

accept返回的是一个二元元组，可以使用上述形式，用两个变量接收二元元组的2个元素

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

while True:
data = conn.recv(1024).decode("UTF-8")
# recv方法的返回值是字节数组(Bytes》，可以通过decode使用UTF-8解码为字符串
# recv方法的传参是buffsize，缓冲区大小，一般设置为1024即可
if data == 'exit':
break
print("接收到发送来的数据:"，data)
# 可以通过while True无限循环来持续和客户端进行数据交互
# 可以通过判定客户端发来的特殊标记，如exit，来退出无限循环

6.通过conn(客户端当次连接对象)调用send方法可以回复消息

while True:
data = conn.recv(1024).decode("UTF-8")
if data == 'exit':
break
print("接收到发送来的数据:", data)
conn.send("你好呀哈哈哈".encode("UTF-8”))

7.conn(客户端当次连接对象)和socket_server对象调用close方法,关闭连接

Socket客户端编程

主要分为如下几个步骤:

1.创建socket对象

import socket

socket_client = socket.socket()

2.连接到服务端

socket_client.connect(("localhost"，8888))

3.发送消息

while True: # 可以通过无限循环来确保持续的发送消息给服务端
send_msg = input("请输入要发送的消息")
if send_msg == exit':
# 通过特殊标记来确保可以退出无限循环
break
socket_client.send(send_msg.encode("UTF-8")) # 消息需要编码为字节数组(UTF-8编码)

4.接收返回消息

while True:
send_msg = input("请输入要发送的消息").encode("UTF-8")
socket_client.send(send_msg)
recv_data = socket_client.recv(124) # 1024是缓冲区大小，一般1024即可
#recv方法是阻塞式的，即不接收到返回，就卡在这里等待
print("服务端回复消息为:"，recv_data.decode("UTF-8"))#接受的消息需要通过UTF-8解码为字符串

5.关闭链接

socket_client.close()

正则表达式

正则表达式,又称规则表达式(Regular Expression),是使用单个字符串来描述、匹配某个句法规则的字符串,常被用来检索、替换那些符合某个模式(规则)的文本。

简单来说,正则表达式就是使用: 字符串定义规则，并通过规则去验证字符串是否匹配。

三个基础方法：

使用re模块,并基于re模块（import re）中三个基础方法来做正则匹配。

（1）match

re.match(匹配规则，被匹配字符串)

从被匹配字符串开头进行匹配，匹配成功返回匹配对象(包含匹配的信息)，匹配不成功返回空。

（2）search

re.search(匹配规则，被匹配字符串)

搜索整个字符串,找出匹配的。从前向后,找到第一个后,就停止,不会继续向后

（3）findall

re.findall(匹配规则，被匹配字符串)

匹配整个字符串,找出全部匹配项,找不到返回空list:[]

元字符匹配：

（1）单字符匹配：

实例：

import re
s = "learn @@python3 12EEAA!!66 ##study3"
# 找出全部数字
result1 = re.findall(r'\d', s)
print(result1) # ['3', '1', '2', '6', '6', '3']
# 找出特殊字符
result2 = re.findall(r'\W', s)
print(result2) # [' ', '@', '@', ' ', '!', '!', ' ', '#', '#']
# 找出全部英文字母
result3 = re.findall(r'[a-zA-Z]', s)
print(result3) # ['l', 'e', 'a', 'r', 'n', 'p', 'y', 't', 'h', 'o', 'n', 'E', 'E', 'A', 'A', 's', 't', 'u', 'd', 'y']