八、正则表达式和网络编程

最新推荐文章于 2024-04-29 10:40:41 发布

这丸子

最新推荐文章于 2024-04-29 10:40:41 发布

阅读量85

点赞数

分类专栏： Python编程零基础强势入门教程文章标签：正则表达式网络 python

本文链接：https://blog.csdn.net/qq_36754088/article/details/129996872

版权

Python编程零基础强势入门教程专栏收录该内容

10 篇文章 1 订阅

订阅专栏

8.1 正则表达式的基本语法和使用

正则表达式是一种文本模式，用于描述字符串的特定模式，可以用于文本匹配、搜索和替换等操作。在Python中，我们可以使用re模块来支持正则表达式的处理。

8.1.1 正则表达式的基本语法

在正则表达式中，我们可以使用各种字符和符号来描述字符串的特定模式。下面是一些常用的正则表达式符号和它们的含义：

.：匹配任意一个字符，除了换行符。
^：匹配字符串的开头。
$：匹配字符串的结尾。
*：匹配前面的字符出现0次或多次。
+：匹配前面的字符出现1次或多次。
?：匹配前面的字符出现0次或1次。
{m}：匹配前面的字符出现m次。
{m,n}：匹配前面的字符出现m到n次。
[]：匹配中括号中的任意一个字符。
|：匹配左右两边任意一个表达式。
()：标记一个子表达式的开始和结束位置。

例如，下面的正则表达式可以匹配一个由数字和字母组成的字符串：

^[0-9a-zA-Z]+$

在上面的正则表达式中，^表示字符串的开头，$表示字符串的结尾，[0-9a-zA-Z]表示一个数字或字母，+表示前面的字符出现1次或多次。

8.1.2 正则表达式的使用

在Python中，我们可以使用re模块来支持正则表达式的处理。re模块提供了一组函数，用于编译、匹配、搜索和替换字符串。

8.1.2.1 编译正则表达式

在使用正则表达式之前，我们需要先编译它。在Python中，可以使用re.compile()函数来编译正则表达式，将其转换为一个正则表达式对象。

例如，下面的代码将一个正则表达式编译为一个正则表达式对象：

import re

pattern = re.compile(r'^[0-9a-zA-Z]+$')

在上面的代码中，r表示原始字符串，^和$需要使用\来转义。

8.1.2.2 匹配和搜索字符串

在编译好正则表达式之后，我们可以使用正则表达式对象的match()、search()和findall()方法来匹配和搜索字符串。

match()方法用于从字符串的开头开始匹配，如果匹配成功则返回一个匹配对象，否则返回None。

例如，下面的代码使用match()方法匹配一个字符串：

import re

pattern = re.compile(r'^[0-9a-zA-Z]+$')
string = 'Hello123'

result = pattern.match(string)

if result:
    print('匹配成功')
else:
    print('匹配失败')

在上面的代码中，由于字符串Hello123以字母开头，所以匹配失败。

search()方法用于在整个字符串中搜索，如果匹配成功则返回一个匹配对象，否则返回None。

例如，下面的代码使用search()方法搜索一个字符串：

import re

pattern = re.compile(r'[0-9]+')
string = 'Hello123'

result = pattern.search(string)

if result:
    print('匹配成功')
else:
    print('匹配失败')

在上面的代码中，由于字符串Hello123中包含数字123，所以匹配成功。

findall()方法用于在整个字符串中查找所有匹配的子串，并以
列表的形式返回。

例如，下面的代码使用findall()方法查找一个字符串中的所有数字：
```
import re

pattern = re.compile(r'[0-9]+')
string = 'Hello123 World456'

result = pattern.findall(string)

print(result)
```
在上面的代码中，findall()方法会查找字符串Hello123 World456中的所有数字，并以列表的形式返回结果['123', '456']。

8.1.2.3 替换字符串

除了匹配和搜索字符串之外，我们还可以使用正则表达式对象的sub()方法来替换字符串中的子串。

例如，下面的代码使用sub()方法将一个字符串中的所有数字替换为#：
```
import re

pattern = re.compile(r'[0-9]+')
string = 'Hello123 World456'

result = pattern.sub('#', string)

print(result)
```
在上面的代码中，sub()方法会查找字符串Hello123 World456中的所有数字，并将其替换为#，最终结果为Hello# World#。

8.1.3 正则表达式的注意事项

在使用正则表达式时，需要注意以下几点：
- 正则表达式符号和字符是区分大小写的。
- 在使用.符号时，需要注意它不能匹配换行符。
- 在使用\符号时，需要注意它需要进行转义，例如\d表示匹配数字，而\\表示匹配\符号本身。
- 在使用重复符号时，需要注意它们的贪婪性。例如，*和+符号默认是贪婪的，会尽可能匹配更多的字符，而*?和+?符号是非贪婪的，会尽可能匹配更少的字符。
正则表达式是一种强大的文本处理工具，可以帮助我们快速地进行文本匹配、搜索和替换等操作。在Python中，使用re模块可以轻松地处理正则表达式。

8.2 网络编程的基础知识和常用模块

网络编程是指使用计算机网络进行通信的编程技术。在Python中，我们可以使用一些常用的网络编程模块来实现网络通信功能，例如socket、select和asyncio等。

8.2.1 socket模块

socket是Python中最基础的网络编程模块，它提供了一组函数和类，用于实现网络通信功能。socket模块支持多种网络协议，例如TCP、UDP和Unix域套接字等。

8.2.1.1 创建套接字

在使用socket模块进行网络编程时，我们首先需要创建一个套接字对象。可以使用socket.socket()函数来创建一个套接字对象。

例如，下面的代码创建一个TCP套接字对象：

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

在上面的代码中，AF_INET表示使用IPv4协议，SOCK_STREAM表示使用TCP协议。

8.2.1.2 绑定端口和地址

在创建套接字对象之后，我们需要将套接字绑定到一个端口和地址上，以便其他计算机可以通过该地址和端口来访问我们的程序。

可以使用bind()方法来绑定端口和地址。例如，下面的代码将套接字绑定到本地主机的8000端口上：

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('localhost', 8000))

在上面的代码中，bind()方法的参数是一个元组，包含要绑定的地址和端口。

8.2.1.3 监听连接

在将套接字绑定到端口和地址上之后，我们需要开始监听连接请求。可以使用listen()方法来监听连接。

例如，下面的代码将套接字设置为监听状态，并设置最大允许连接数为5：

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('localhost', 8000))
sock.listen(5)

在上面的代码中，listen()方法的参数是一个整数，表示最大允许连接数。

8.2.1.4 接受连接

在设置套接字为监听状态之后，我们需要等待客户端的连接请求，并接受连接。可以使用accept()方法来接受连接请求，并返回一个新的套接字对象，用于与客户端进行通信。

例如，下面的代码接受一个客户端连接，并返回一个新的套接字对象：

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('localhost', 8000))
sock.listen(5)

client_sock, client_addr = sock.accept()

在上面的代码中，accept()方法会阻塞程序，直到有客户端连接到服务器。client_sock是一个新的套接字对象，用于与客户端进行通信，client_addr是客户端的地址和端口信息。

8.2.1.5 发送和接收数据

在与客户端建立连接之后，我们可以使用套接字对象的send()方法发送数据，使用recv()方法接收数据。

例如，下面的代码使用send()方法向客户端发送一条消息，并使用recv()方法接收客户端的回复：

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('localhost', 8000))
sock.listen(5)

client_sock, client_addr = sock.accept()

client_sock.send(b'Hello, client!')
data = client_sock.recv(1024)
print(data)

在上面的代码中，send()方法的参数是一个字节串对象，表示要发送的数据。recv()方法的参数是一个整数，表示要接收的数据的最大字节数。

8.2.1.6 关闭套接字

在完成网络通信之后，我们需要关闭套接字对象，以释放系统资源。可以使用close()方法来关闭套接字。

例如，下面的代码在完成网络通信之后，关闭套接字：

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('localhost', 8000))
sock.listen(5)

client_sock, client_addr = sock.accept()

client_sock.send(b'Hello, client!')
data = client_sock.recv(1024)
print(data)

client_sock.close()
sock.close()

在上面的代码中，先调用close()方法关闭客户端的套接字，再调用close()方法关闭服务器的套接字。

8.2.2 select模块

select模块是一个高级的网络编程模块，可以实现多路复用的网络通信功能。在使用select模块时，我们可以将多个套接字对象注册到一个select对象中，然后使用select()方法来等待套接字对象的读写事件，并返回就绪的套接字对象。

8.2.2.1 创建select对象

可以使用select.select()函数来创建一个select对象。例如，下面的代码创建一个select对象，并将三个套接字对象注册到该对象中：

import select
import socket

sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock1.bind(('localhost', 8000))
sock1.listen(5)

sock2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock2.bind(('localhost', 8001))
sock2.listen(5)

sock3 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock3.bind(('localhost', 8002))
sock3.listen(5)

inputs = [sock1, sock2, sock3]
outputs = []
errors = []

ready_inputs, ready_outputs, ready_errors = select.select(inputs, outputs, errors)

在上面的代码中，select.select()函数的参数是一个列表，包含要注册到select对象中的套接字对象。

8.2.2.2 等待事件

在将套接字对象注册到select对象中之后，我们可以使用select()方法来等待套接字对象的读写事件，并返回就绪的套接字对象。

例如，下面的代码使用select()方法等待套接字对象的读写事件：

import select
import socket

sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock1.bind(('localhost', 8000))
sock1.listen(5)

sock2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock2.bind(('localhost', 8001))
sock2.listen(5)

sock3 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock3.bind(('localhost', 8002))
sock3.listen(5)

inputs = [sock1, sock2, sock3]
outputs = []
errors = []

while True:
    ready_inputs, ready_outputs, ready_errors = select.select(inputs, outputs, errors)
    for sock in ready_inputs:
        if sock == sock1:
            client_sock, client_addr = sock1.accept()
            inputs.append(client_sock)
        else:
            data = sock.recv(1024)
            if not data:
                inputs.remove(sock)
                sock.close()
            else:
                outputs.append(sock)
                sock.send(data)
    for sock in ready_outputs:
        outputs.remove(sock)
        sock.send(b'ACK')

在上面的代码中，先将三个套接字对象注册到select对象中，然后进入一个无限循环。在每次循环中，使用select()方法等待套接字对象的读写事件，并返回就绪的套接字对象。对于就绪的套接字对象，根据其类型进行不同的处理。

8.2.2.3 关闭套接字

在完成网络通信之后，我们需要关闭套接字对象以释放系统资源。可以使用close()方法来关闭套接字。

例如，下面的代码在完成网络通信之后，关闭套接字：

import select
import socket

sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock1.bind(('localhost', 8000))
sock1.listen(5)

sock2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock2.bind(('localhost', 8001))
sock2.listen(5)

sock3 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock3.bind(('localhost', 8002))
sock3.listen(5)

inputs = [sock1, sock2, sock3]
outputs = []
errors = []

while True:
    ready_inputs, ready_outputs, ready_errors = select.select(inputs, outputs, errors)
    for sock in ready_inputs:
        if sock == sock1:
            client_sock, client_addr = sock1.accept()
            inputs.append(client_sock)
        else:
            data = sock.recv(1024)
            if not data:
                inputs.remove(sock)
                sock.close()
            else:
                outputs.append(sock)
                sock.send(data)
    for sock in ready_outputs:
        outputs.remove(sock)
        sock.send(b'ACK')

sock1.close()
sock2.close()
sock3.close()

在上面的代码中，先调用close()方法关闭所有套接字对象，以释放系统资源。

8.2.3 asyncio模块

asyncio模块是Python标准库中的一个高级网络编程模块，可以实现异步非阻塞的网络通信功能。在使用asyncio模块时，我们可以使用协程来进行网络通信，并使用事件循环来调度协程的执行。

8.2.3.1 创建协程

在asyncio模块中，我们可以使用async def关键字来定义一个协程函数。例如，下面的代码定义了一个协程函数，用于异步接收客户端发送的数据：

import asyncio

async def handle_client(reader, writer):
    data = await reader.read(1024)
    writer.write(data)
    await writer.drain()
    writer.close()

在上面的代码中，handle_client()函数是一个协程函数，接受两个参数：reader和writer，分别代表输入流和输出流。在函数中，使用await关键字来等待输入流的数据，并使用输出流来发送数据。

8.2.3.2 创建事件循环

在使用asyncio模块时，我们需要创建一个事件循环来调度协程的执行。可以使用asyncio.get_event_loop()函数来创建一个事件循环对象。

例如，下面的代码创建一个事件循环对象，并将一个协程函数注册到该对象中：

import asyncio

async def handle_client(reader, writer):
    data = await reader.read(1024)
    writer.write(data)
    await writer.drain()
    writer.close()

loop = asyncio.get_event_loop()
coro = asyncio.start_server(handle_client, '127.0.0.1', 8000, loop=loop)
server = loop.run_until_complete(coro)

在上面的代码中，先创建一个事件循环对象，然后使用asyncio.start_server()函数创建一个服务器对象，并将一个协程函数注册到该服务器对象中。最后使用loop.run_until_complete()方法将服务器对象注册到事件循环中。

8.2.3.3 运行事件循环

在将协程函数注册到事件循环中之后，我们需要运行事件循环以调度协程的执行。可以使用loop.run_forever()方法来运行事件循环。

例如，下面的代码运行事件循环以调度协程的执行：

import asyncio

async def handle_client(reader, writer):
    data = await reader.read(1024)
    writer.write(data)
    await writer.drain()
    writer.close()

loop = asyncio.get_event_loop()
coro = asyncio.start_server(handle_client, '127.0.0.1', 8000, loop=loop)
server = loop.run_until_complete(coro)
loop.run_forever()

在上面的代码中，先创建一个事件循环对象，然后使用asyncio.start_server()函数创建一个服务器对象，并将一个协程函数注册到该服务器对象中。最后使用loop.run_until_complete()方法将服务器对象注册到事件循环中，并使用loop.run_forever()方法运行事件循环以调度协程的执行。

8.2.4 Trio模块

Trio模块是一个Python库，提供了异步非阻塞的网络编程功能。与asyncio模块类似，Trio模块也使用协程来实现异步非阻塞的网络通信。

8.2.4.1 创建任务

在Trio模块中，我们可以使用trio.run()函数来创建一个任务并运行事件循环。例如，下面的代码创建一个任务，并在任务中异步接收客户端发送的数据：

import trio

async def handle_client(stream):
    data = await stream.receive_some(1024)
    await stream.send_all(data)

async def main():
    with trio.socket.socket() as sock:
        sock.bind(('127.0.0.1', 8000))
        sock.listen(5)
        while True:
            client_sock, client_addr = await sock.accept()
            async with trio.open_nursery() as nursery:
                nursery.start_soon(handle_client, client_sock)

trio.run(main)

在上面的代码中，先使用trio.socket.socket()函数创建一个套接字对象，然后绑定到本地地址并监听客户端连接。在客户端连接时，使用trio.open_nursery()函数创建一个新的任务，并在任务中调用handle_client()协程函数来处理客户端发送的数据。

8.2.4.2 运行事件循环

在创建任务后，我们需要使用trio.run()函数来运行事件循环并执行任务。例如，下面的代码运行事件循环并执行任务：

import trio

async def handle_client(stream):
    data = await stream.receive_some(1024)
    await stream.send_all(data)

async def main():
    with trio.socket.socket() as sock:
        sock.bind(('127.0.0.1', 8000))
        sock.listen(5)
        while True:
            client_sock, client_addr = await sock.accept()
            async with trio.open_nursery() as nursery:
                nursery.start_soon(handle_client, client_sock)

trio.run(main)

在上面的代码中，先使用trio.socket.socket()函数创建一个套接字对象，然后绑定到本地地址并监听客户端连接。在客户端连接时，使用trio.open_nursery()函数创建一个新的任务，并在任务中调用handle_client()协程函数来处理客户端发送的数据。最后使用trio.run()函数运行事件循环并执行任务。

8.2.5 总结

本节介绍了Python中常用的三个网络编程模块：socket、asyncio和Trio。在使用这些模块时，我们可以根据具体的需求选择合适的模块，并使用相应的函数和方法来实现网络通信功能。在选择网络编程模块时，我们需要考虑到应用场景、性能需求、开发难度等方面的因素，并综合考虑选择合适的模块。

这丸子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
八、正则表达式和网络编程

本节介绍了Python中常用的三个网络编程模块：socket、asyncio和Trio。在使用这些模块时，我们可以根据具体的需求选择合适的模块，并使用相应的函数和方法来实现网络通信功能。在选择网络编程模块时，我们需要考虑到应用场景、性能需求、开发难度等方面的因素，并综合考虑选择合适的模块。
复制链接

扫一扫