Python多线程、Socket网络编程与正则表达式实战指南

闭包与非局部变量管理

在全局作用域中直接修改外部变量（如使用 global）容易引发任意访问与意外覆盖的风险。为了解决此类数据安全问题，Python 引入了闭包机制，通过嵌套函数与 nonlocal 关键字实现变量状态的私有化封装。

闭包的定义条件为：在函数嵌套的前提下，内部函数引用外部函数的变量，并且外部函数返回了该内部函数。此时被引用的外部变量不会随外部函数执行结束而被销毁。

def out(account):
    def atm(num, flag):
        nonlocal account  # 声明变量来自外层作用域且可被修改
        if flag:
            account += num
            print("余额", account)
        else:
            account -= num
            print("余额", account)
    return atm

atm_func = out(100)  # 初始化起始余额并获取内部函数
atm_func(200, True)  # 存入200元
atm_func(100, False) # 取出100元

通过上述结构，account 不再是全局变量，只能通过 atm_func 调用进行修改，有效隔离了外部干扰。

Python多线程基础与并发控制

现代操作系统支持多程序并行运行（进程），而一个进程内部可包含多个执行流（线程）。线程是 CPU 调度的基本单位。Python 通过内置的 threading 模块提供多线程能力，核心类为 threading.Thread。

第1步：创建并启动线程

入口位于 threading.Thread 构造函数，常用参数包括 target（任务函数）、args（位置参数元组）、kwargs（字典参数）。调用 start() 后即可触发异步执行。

import time
import threading

def sing(**kwargs):
    while True:
        print(kwargs["name"], "在唱歌")
        time.sleep(1)

def dance():
    while True:
        print("正在跳舞")
        time.sleep(1)

if __name__ == '__main__':
    t_sing = threading.Thread(target=sing, kwargs={"name": "张三"})
    t_dance = threading.Thread(target=dance)
    t_sing.start()
    t_dance.start()

第2步：控制线程生命周期（daemon 与 join）

守护线程（daemon）： 当 daemon=True 时，主线程退出会强制终止所有子线程；默认为 False，即主线程会等待所有非守护子线程执行完毕后再结束。

import time
import threading

count = 0
def worker(name):
    global count
    while count < 3:
        count += 1
        print(f"{name} 工作...")
        time.sleep(0.5)
        threading.Thread(target=worker, args=("子线程",)).start()

if __name__ == '__main__':
    main_thread = threading.Thread(target=worker, args=("主线程",), daemon=False)
    main_thread.start()

线程阻塞（join）： 在并发场景中，若需等待特定线程完成后才继续后续逻辑，可使用 join() 方法。该方法会使调用方线程暂停，直至目标线程终止。

import time
import threading

class TaskThread(threading.Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name
    def run(self):
        for i in range(3):
            print(i, self.name, time.ctime(time.time()))
            time.sleep(0.5)

t_a = TaskThread("线程A")
t_a.start()

for i in range(5):
    print("主流程步骤", i)
    if i == 2:
        t_a.join()  # 阻塞主流程，直到线程A执行完毕

第3步：线程同步与互斥锁

多个线程同时读写共享可变数据时会引发竞态条件。使用 threading.Lock() 或 threading.RLock() 可实现简单的互斥同步。acquire() 相当于加锁，release() 相当于解锁。未获锁的线程将阻塞等待。

典型场景为多窗口并发售票：若无锁保护，两窗口可能同时读取到同一剩余票数并完成扣减，导致超售。

import time
import threading

class TicketWindow(threading.Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name
    def run(self):
        global tickets
        while tickets > 0:
            lock.acquire()
            if tickets <= 0:
                break
            print(f"{self.name} 卖出第 {tickets} 张票")
            tickets -= 1
            time.sleep(0.5)
            lock.release()

tickets = 5
lock = threading.Lock()  # 创建互斥锁实例

w1 = TicketWindow("窗口一")
w2 = TicketWindow("窗口二")
w1.start()
w2.start()

加锁后，tickets 在修改期间被其他线程拦截，确保数据读写一致性。

Socket网络编程：客户端与服务端交互

Python 标准库 socket 模块提供了底层 TCP/IP 通信能力。通过套接字（Socket）可实现服务器监听与客户端主动连接的标准 C/S 架构。

第1步：搭建服务端

服务端需依次完成：创建 Socket 对象 → bind() 绑定地址端口 → listen() 开启监听队列 → accept() 阻塞接收连接 → recv()/send() 进行字节收发 → close() 释放资源。

import socket

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("localhost", 8888))  # 绑定本机IP与端口
server.listen(5)  # 设置最大排队连接数

while True:
    conn, addr = server.accept()
    print("客户端已连接:", addr)
    
    data = conn.recv(1024).decode("utf-8")
    if data == "exit":
        conn.send("再见".encode())
        conn.close()
        break
    print("收到消息:", data)
    
    response = input("输入回复内容: ")
    conn.send(response.encode())
    conn.close()

server.close()

第2步：实现客户端

客户端通过 connect() 主动发起握手，随后使用 send() 发送字节数据，recv() 接收响应，最后关闭套接字。

import socket

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(("localhost", 8888))  # 连接服务端地址

msg = input("请输入要发送的数据: ")
client.send(msg.encode())
resp = client.recv(1024).decode("utf-8")
print("服务器返回:", resp)

client.close()

以下为典型的终端运行效果示意：

正则表达式实战：匹配规则与常用方法

正则表达式（Regex）是一套用于模式匹配的字符序列。Python 借助 re 模块原生支持全部正则功能，核心函数包含 match、search 与 findall。

常用函数对比

• re.match(pattern, string)：仅从字符串起始位置尝试匹配，失败返回 None。
• re.search(pattern, string)：扫描整个字符串，返回第一个成功匹配的位置。
• re.findall(pattern, string)：查找所有符合条件的子串，返回列表。若模式包含分组则返回元组列表。

import re

text = "hi hello world hi"
res1 = re.match(r"hello", text)       # 返回 None（开头不匹配）
res2 = re.search(r"hello", text)      # 成功，span=(3, 8)
res3 = re.findall(r"\w+", text)       # ['hi', 'hello', 'world', 'hi']

核心修饰符与元字符速查

可选标志可通过按位或 | 组合，例如：re.I | re.M。下表列出常用标志：

实战校验示例

import re

# 1. 账号校验：6-16位英文数字
rule_acct = r'^[0-9a-zA-Z]{6,16}$'
print(bool(re.match(rule_acct, 'User_123')))  # True

# 2. 手机号校验：1开头，第二位3/5/8，共11位纯数字
rule_phone = r'^1[358]\d{9}$'
print(bool(re.match(rule_phone, '13812345678')))  # True

# 3. 邮箱格式校验：10位数字@后缀.com
rule_email = r'^[0-9]{10}@(qq|136|gmail)\.com$'
print(bool(re.match(rule_email, '1234567890@qq.com')))

以上就是Python多线程、网络编程与正则表达式详细内容的详细内容，更多关于Python高级特性与并发处理的资料请关注本站其它相关文章！