文章目录
第三章：
3.1 闭包
在函数嵌套前提下，内部函数使用了外部函数的变量，并外部函数返回内部函数，把这个使用外部函数变量的内部函数称为闭包
def outer(logo):
def inner(msg):
print(f"<logo>{msg}<logo>")
return inner
fn1 = outer("Hello")
fn1("world")
fn1("World")
fn2 = outer("Python")
fn2("hello")
fn2("Hello")
例：
def account_Create(amount_Init=0):
def atm(num, deposit=True):
nonlocal amount_Init
if deposit:
amount_Init += num
print(f"存款+{num}，账户余额{amount_Init}")
else:
amount_Init -= num
print(f"存款-{num}，账户余额{amount_Init}")
return atm
fn = account_Create()
fn(100)
fn(300, True)
fn(200, False)
优点：
无需定义全局变量就可实现通过函数，持续访问，修改某个值
闭包使用的变量所用在函数内，难以被错误的调用修改
缺点：
- 内部函数持续引用外部函数的值，以至于这一部分内存空间不被释放，一直占用内存
在闭包函数中想要修改外部函数的变量值，需用nonlocal声明该外部变量
3.2 装饰器
作用：不破坏目标函数原有的代码和功能的前提下，为目标函数增加新功能
def outer(func):
def inner():
print("11111")
func()
print("22222")
return inner
def sleep():
import random
import time
print("睡觉Zzzz")
time.sleep(random.randint(1,3))
fn = outer(sleep)
fn()
语法糖写法
def outer(func):
def inner():
print("11111")
func()
print("22222")
return inner
@outer
def sleep():
import random
import time
print("睡觉Zzzz")
time.sleep(random.randint(1,3))
sleep()
3.3 设计模式
除了面向对象外，在编程中有很多既定的套路可方便开发，称为设计模式
单例、工厂模式
建造者、状态、备忘录、访问者、模板、代理模式
等模式
3.3.1 单例模式
作用：确保某一个类只有一个实例存在
保证一个类只有一个实例，并提供一个访问的全局访问点。
# test02
class strTools:
pass
str_tool = strTools()
# test
from test02 import str_tool
s1 = str_tool
s2 = str_tool
print(s1)
print(s2)
"""
<test02.strTools object at 0x000001BFBED43EF0>
<test02.strTools object at 0x000001BFBED43EF0>
"""
3.3.2 工厂模式
当需要大量创建一个类的实例时，可使用工厂模式。从原生的使用类去构造去创建对象的形式，迁移到，基于工厂提供的方法去创建对象的形式。
class Person:
pass
class Worker(Person):
pass
class Student(Person):
pass
class Teacher(Person):
pass
class Factory:
def get_person(self,person_Type):
if person_Type == 'w':
return Worker()
elif person_Type == 's':
return Student()
else:
return Teacher()
factory = Factory()
worker = factory.get_person('w')
student = factory.get_person('s')
teacher = factory.get_person('t')
大批量创建对象时有统一的入口，易于代码维护
当发生变化时，只需修改工厂类的创建方法即可
符合现实世界的模式，由工厂来制作产品(对象)
3.4 多线程
3.4.1 进程、线程和并行执行
进程：一个程序，运行在系统之上，那便称该程序为一个运行进程，并分配进程ID方便管理系统
线程：线程归属于进程，一个进程可开启多个线程，执行不同的工作，是进程的实际工作最小单位
多任务运行：操作系统中可运行多个进程
多线程运行：一个进程内可运行多个线程
进程之间是内存隔离的，不同的进程拥有各自的内存空间。
线程之间是内存共享的，线程是属于进程的，一个进程内的多个线程之间是共享该进程所拥有的内存空间
并行执行：同一时间做不同的工作
多任务同时运行，即不同的程序同时运行，称为：多任务并行执行
一个程序在同一时间做两件或更多件不同的事情时，称为：多线程并行执行
3.4.2 多线程编程
通过threading模块实现
import threading
thread_obj = threading.Thread([group [, target, [, name[, args[, kwargs]]]]])
thread_obj.start() # 启动线程，让线程开始工作
group：未来功能的预留参数
target：执行的目标任务名
args：以元组方式给执行任务传参
kwargs：以字典方式给执行任务传参
name：线程名
import threading
import time
def Coffee():
while True:
print("喝咖啡")
time.sleep(1)
def Tea():
while True:
print("喝茶")
time.sleep(1)
# 创建进程
coffee_thread = threading.Thread(target=Coffee)
tea_thread = threading.Thread(target=Tea)
# 执行进程
coffee_thread.start()
tea_thread.start()
import threading
import time
def Coffee(msg):
while True:
print(msg)
time.sleep(1)
def Tea(msg):
while True:
print(msg)
time.sleep(1)
# 创建进程
coffee_thread = threading.Thread(target=Coffee, args=("喝咖啡"))
tea_thread = threading.Thread(target=Tea, args={"msg": "喝茶"})
# 执行进程
coffee_thread.start()
tea_thread.start()
3.5 网络编程
3.5.1 Socket
socket：进程之间通讯的一个工具，进程之间想要进行网络通信需要socket
socket负责进程之间的网络数据传输
2个进程之间通过Socket进行相互通信，必须有服务端和客户端
Socket服务端：等待其他进程的连接、可接收发来的信息、可回复信息
Socket客户端：主动连接服务器、可发送信息、可接收回复
3.5.2 服务端开发
步骤：
1.创建socket对象
2.绑定socket_server到指定IP地址和端口
3.服务端开始监听端口
4.接收客户端连接，获取链接对象
5.连接客户端后，通过recv方法，接收客户端所发来的信息
6.通过conn，调用send方法可回复消息
7.conn和socket_server对象调用close方法，关闭连接
import socket # 导包
socket_server = socket.socket() # 创建socket对象
socket_server.bind(("localhost", 8888)) # 绑定IP地址和端口
socket_server.listen(1) # 监听端口
# listen方法内接收一个整数传参数，表示接收的链接数量
conn, address = socket_server.accept() # 接收客户端连接，获取连接对象
"""
result: tuple = socket_server.accept()
conn = result[0] # 客户端和服务端的连接对象
address = result[1]# 客户端的地址信息
accept方法返回的是二元元组(连接对象，客户端地址信息)
可通过变量1，变量2 = socket_server.accept()的形式，直接接收二元元组内的两个元素
accept()方法，是阻塞的方法，等待客户端的连接，若没有连接，卡着不执行了
"""
print(f"接收到客户端的连接，信息是:{address}")
data: str = conn.recv(1024).decode("UTF-8") # 连接客户端后，通过recv方法，接收客户端所发来的信息
""""
接收客户端信息，使用客户端和服务端的本次连接对象，而非socket_server对象
recv接收的参数是缓冲区大小，一般1024
recv方法的返回值是一个字节数组也是Bytes对象，不是字符串，可通过decode方法UTF-8编码，将字节数组转换为字符串对象
"""
print(f"客户端发来的信息是：{data}")
msg = input("请输入和客户端回复的信息：").encode("UTF-8") # 发送回复信息
conn.send(msg) # 通过conn，调用send方法可回复消息
conn.close() # conn和socket_server对象调用close方法，关闭连接
socket_server.close()
优化：
import socket
socket_server = socket.socket()
socket_server.bind(("localhost", 8888))
socket_server.listen(1)
conn, address = socket_server.accept()
print(f"接收到客户端的连接，来的{address}")
while True:
data = conn.recv(1024).decode("UTF-8")
if data == 'exit':
break
print(f"发送来的信息是:{data}")
reply = input("请输入回复的信息:").encode("UTF-8")
conn.send(reply)
conn.close()
socket_server.close()
3.5.3 客户端开发
步骤：
1.创建socket对象
2.连接到服务端
3.发送消息
4.接收并返回消息
5.关闭连接
import socket # 导包
socket_client = socket.socket() # 创建socket对象
socket_client.connect(("localhost", 8888)) # 连接到服务器
socket_client.send("你好".encode("UTF-8")) # 发送消息
data = socket_client.recv(1024) # 接收信息并返回
print(f"服务端返回的信息为：{data}") #
socket_client.close() # 关闭连接
3.6 正则表达式
正则表达式又称规则表达式，是使用单个字符串来描述、匹配某个句法规则的字符串，常被用来检索、替换哪些符号某个模式的文本。
使用：字符串定义规则，并通过规则去验证字符串是否匹配
3.6.1 基础匹配
三个基础方法：
<1>match
<2>search
<3>findall
- re.match(匹配规则，被匹配字符串)
从被匹配字符串开头进行匹配，匹配成功返回匹配对象，不成功则返回空
import re
str = "hello python"
ret = re.match("hello", str)
print(ret) # <re.Match object; span=(0, 5), match='hello'>
print(ret.span()) # (0, 5)
print(ret.group()) # hello
str2 = "1hello python"
ret2 = re.match("hello", str2)
print(ret2) # None
print(ret2.span())
print(ret2.group())
- search(匹配规则，被匹配字符串)
搜索整个字符串，找出匹配的字符串，从前往后，找到第一个后就停止，不会继续向后
import re
str = "hello python"
ret = re.search("python", str)
print(ret) # <re.Match object; span=(6, 12), match='python'>
print(ret.span()) # (6, 12)
print(ret.group()) # python
str2 = "hello 1python"
ret2 = re.search("python", str2)
print(ret2) # None # <re.Match object; span=(7, 13), match='python'>
print(ret2.span()) # (7, 13)
print(ret2.group()) # python
- findall(匹配规则，被匹配字符串)
匹配整个字符串，找出全部匹配项，找不到返回空list：[]
import re
str = "hello python"
ret = re.findall("python", str)
print(ret) # ['python']
str2 = "hello 1python"
ret2 = re.search("world", str2)
print(ret2) # None
3.6.2 元字符匹配
单字符匹配：
| 字符 | 功能 |
|---|---|
| . | 匹配任意1个字符，除了\n |
| [] | 匹配[]内列举的字符 |
| \d | 匹配数字，0-9 |
| \D | 匹配非数字 |
| \s | 匹配空白，空格、tab键 |
| \S | 匹配非空白 |
| \w | 匹配单词字符，a-z、A-Z 、0-9、_ |
| \W | 匹配非单词字符 |
import re
str = "hello 2python"
ret = re.findall(r'[e-h]', str) # 字符串前加上r标记，表示字符串中转义字符无效,为普通字符
print(ret) # ['h', 'e', 'h']
元字符匹配：
| 字符 | 功能 |
|---|---|
| * | 匹配前一个规则的字符出现0次至无数次 |
| + | 匹配前一个规则的字符出现1次至无数次 |
| ？ | 匹配前一个规则的字符出现0次或1次 |
| {m} | 匹配前一个规则的字符出现m次 |
| {m,} | 匹配前一个规则的字符出现至少m次 |
| {m, n} | 匹配前一个规则的字符出现m至n次 |
边界匹配：
| 字符 | 功能 |
|---|---|
| ^ | 匹配字符串开头 |
| $ | 匹配字符串结尾 |
| \b | 匹配一个单词的边界 |
| \B | 匹配非单词边界 |
分组匹配：
| 字符 | 功能 |
|---|---|
| () | 括号中字符作为一个分组 |
import re
# 1
r = '^[0-9a-zA-Z]{6,10}$' # 只能由字母和数字组成，长度范围6-10位
str = '123456abc'
print(re.findall(r, str)) # ['123456abc']
# 2 纯数字，长度5-10位，第一位不可为0
r = '^[1-9][0-9]{5,9}$'
str = '12345678'
print(re.findall(r, str)) # ['12345678']
# 3 匹配邮箱地址，只允许168、qq邮箱地址
r = r'(^[\w-]+(\.[\w-]+)*@(163|qq)(\.[\w-]+)+$)'
str = 'ziqi@163.com'
print(re.findall(r, str)) # [('ziqi@163.com', '', '163', '.com')]
3.7 递归
方法/函数自己调用自己的一种特殊编程写法
def func():
if 1:
func()
return 0
import os
def test_os():
print(os.listdir("D:/test")) # 列出路径下的内容
print(os.path.isdir("D:/test/a")) # 判断指定路径是不是文件夹
print(os.path.exists("D:/test")) # 判断指定路径是否存在
def get_files(path):
"""
从指定的文件中用递归的方式，获取全部的文件列表
:param path: 被判断的文件夹
:return: 包含全部文件，若目录不存在或无文件则返回一个空list[]
"""
file_list = []
if os.path.exists(path):
for f in os.listdir(path):
new_path = path + "/" + f
if os.path.isdir(new_path):
get_files(new_path)
else:
file_list.append(new_path)
else:
print(f"指定目录{path}不存在")
return []
print(get_files("D:/test"))