Python正则

match()和search()方法是re模块中用于正则表达式匹配的两个函数，而不是research()。

match()方法从字符串开头开始匹配，只有当模式从字符串的起始位置开始匹配成功时才会返回匹配对象。如果模式无法从字符串起始位置匹配成功，则返回None。

search()方法在整个字符串中搜索匹配模式的第一个位置，并返回匹配对象。它不要求模式从字符串的起始位置匹配成功，只要字符串中存在匹配的内容即可。

下面是一个示例代码来说明两者之间的不同：

import re

pattern = r'abc'
string = 'xabcdefg'

# 使用 match() 方法进行匹配
match_result = re.match(pattern, string)
print(match_result)  # None，因为模式无法从字符串起始位置匹配成功

# 使用 search() 方法进行匹配
search_result = re.search(pattern, string)
print(search_result)  # ，匹配成功并返回匹配对象

总结：

• match()方法从字符串起始位置开始匹配，如果匹配成功则返回匹配对象，否则返回None。
• search()方法在整个字符串中搜索匹配模式的第一个位置，如果匹配成功则返回匹配对象，否则返回None。

compile()匹配模式
在Python中，re.compile()函数用于将正则表达式模式编译为一个对象，以便可以重复使用该模式进行匹配。下面是一些常用的匹配模式及相应的示例：

1. re.IGNORECASE：不区分大小写匹配

import re

pattern = re.compile(r"hello", re.IGNORECASE)
result = pattern.search("Hello World")
print(result.group())  # 输出: Hello

2. re.MULTILINE：多行匹配，使^和$匹配每行的开始和结束

import re

pattern = re.compile(r"^hello", re.MULTILINE)
result = pattern.findall("hello world\nhello, python")
print(result)  # 输出: ['hello', 'hello']

3. re.DOTALL：匹配任意字符的模式，包括换行符\n

import re

pattern = re.compile(r"hello.*world", re.DOTALL)
result = pattern.search("hello\nworld")
print(result.group())  # 输出: hello\nworld

4. re.ASCII：只匹配ASCII字符的模式

import re

pattern = re.compile(r"[a-z]", re.ASCII)
result = pattern.findall("Hello, Python")
print(result)  # 输出: ['e', 'l', 'l', 'o', 'y', 't', 'h', 'o', 'n']

5. re.DEBUG：打印调试信息，方便调试正则表达式

import re

pattern = re.compile(r"\d{3}-\d{4}", re.DEBUG)
result = pattern.search("My phone number is 123-4567")
# 输出调试信息:
# MAX_REPEAT 3 4
#   LITERAL 45
#     IN
#       RANGE (48, 57)
#     MAX_REPEAT 0 4
#       IN
#         RANGE (48, 57)
#   LITERAL 45
#     IN
#       RANGE (48, 57)
print(result.group())  # 输出: 123-4567

这些只是一些常用的匹配模式，re.compile()函数还支持其他更多的选项和模式。可以通过查阅Python官方文档来了解更多详细信息。

Python分组应用
正则表达式分组是指在正则表达式中用括号 () 将一部分模式进行分组。分组的概念和用法如下：

1. 分组概念：将不同的模式按照逻辑关系组合起来，形成一个整体。分组可以被当做一个整体来操作，方便进行匹配、替换和提取等操作。分组可以嵌套使用。

2. 用法：

   • 匹配分组：使用括号将要匹配的部分模式包围起来，形成一个分组。可以使用“|”将多个分组进行选择匹配。
   • 替换分组：使用括号将要替换的部分模式包围起来，并使用“\数字”的方式引用分组，其中数字表示分组的序号。
   • 提取分组：使用括号将要提取的部分模式包围起来，将匹配到的内容提取出来。

3. 分组序号：每个分组都有一个唯一的序号，从左向右以左括号的顺序进行标记，从 1 开始计数。

4. 分组引用：可以使用“\数字”的方式引用分组，其中数字表示分组的序号。例如要替换分组1的内容，可以使用 \1 来引用分组1的内容。

5. 命名分组：可以给分组指定一个名称，方便引用。命名分组使用语法 (?Ppattern) 进行定义，其中 name 为分组名称，pattern 为模式。

6. 分组修饰符：可以在分组中使用修饰符进行特定的操作。

   • ?: 在分组中加入 ?: 前缀，表示非捕获分组，不会保留此分组的匹配结果。
   • ?= 在分组中加入 ?= 前缀，表示正向肯定预查，只匹配文本中满足预查条件的内容。
   • ?! 在分组中加入 ?! 前缀，表示正向否定预查，只匹配文本中不满足预查条件的内容。

7. 分组示例：

import re

# 匹配分组示例
pattern = r"(dog|cat)"
text = "I have a dog and a cat"
result = re.findall(pattern, text)
print(result)  # ['dog', 'cat']

# 替换分组示例
pattern = r"(\d+)-(\d+)-(\d+)"
text = "Today is 2021-01-01"
result = re.sub(pattern, r"\3/\2/\1", text)
print(result)  # Today is 01/01/2021

# 提取分组示例
pattern = r"(\d+)-(\d+)-(\d+)"
text = "Today is 2021-01-01"
result = re.search(pattern, text)
if result:
    year = result.group(1)
    month = result.group(2)
    day = result.group(3)
    print(year, month, day)  # 2021 01 01

以上是关于Python正则表达式分组概念与用法的详解。分组可以使正则表达式更加灵活和方便，能够处理更复杂的匹配、替换和提取需求。

findall() 与finditer() 方法
在Python中，findall()和finditer()都是正则表达式模块re的方法，用于匹配字符串并返回匹配结果。

区别：

• findall()：该方法会返回所有匹配的字符串列表，每个匹配的字符串作为列表的一个元素。如果正则表达式中包含分组，则返回的是所有分组的元组。
• finditer()：该方法返回的是一个迭代器对象，使用迭代器可以逐个访问每个匹配的匹配对象。每个匹配对象包含匹配的字符串以及其他相关信息，如起始位置和结束位置等。

具体用法举例：

import re

# 定义待匹配的字符串
text = 'hello world, hello python, hello regex'

# 使用findall()方法匹配所有的hello开头的单词
result_findall = re.findall(r'hello\w+', text)
print(result_findall)  # ['hello', 'hello', 'hello']

# 使用finditer()方法匹配所有的hello开头的单词
result_finditer = re.finditer(r'hello\w+', text)
for match in result_finditer:
    print(match.group())  # hello, hello, hello

注意，findall()方法返回的是一个列表，而finditer()方法返回的是一个迭代器对象，需要通过循环逐个获取匹配结果。如果只对匹配结果进行遍历，使用finditer()方法可以降低内存消耗。

re.sub() 与re.subn() 区别与举例
sub()方法用于替换字符串中的匹配项，可以指定替换的次数。示例如下：

import re

# 替换匹配的字符为指定字符串
text = "Hello, my name is Alice."
new_text = re.sub(r"Alice", "Bob", text)
print(new_text)
# Output: Hello, my name is Bob.

# 替换所有匹配的字符为指定字符串
text = "Hello, my name is Alice. Alice is my friend."
new_text = re.sub(r"Alice", "Bob", text)
print(new_text)
# Output: Hello, my name is Bob. Bob is my friend.

# 限制替换次数
text = "Hello, my name is Alice. Alice is my friend."
new_text = re.sub(r"Alice", "Bob", text, count=1)
print(new_text)
# Output: Hello, my name is Bob. Alice is my friend.

subn()方法与sub()方法功能相同，但返回一个元组，包含新字符串和替换次数。示例如下：

import re

text = "Hello, my name is Alice. Alice is my friend."
new_text, count = re.subn(r"Alice", "Bob", text)
print(new_text)
# Output: Hello, my name is Bob. Bob is my friend.
print(count)
# Output: 2

在上面的示例中，subn()方法返回的count为2，表示共进行了两次替换。

Python 时间模块
time 和 datetime 是 Python 中用于处理时间的两个模块，time 模块更适合对时间的基本操作和格式化输出，而 datetime 模块则提供了更多的功能，用于处理日期和时间的组合、计算时间差等高级操作。

1. time 模块主要用于对时间的基本操作，包括获取当前时间戳、休眠、转换时间格式等。它使用的是时间戳（从1970年1月1日开始计算的秒数）来表示时间。

2. datetime 模块提供了更多的功能来处理日期和时间。它包含了 date、time 和 datetime 对象用于表示日期和时间。date 对象表示日期，time 对象表示时间，datetime 对象表示日期和时间的组合。

下面是两个模块的一些常见用法区别：

• 时间戳获取：

  • time 模块使用 time.time() 方法获取当前时间的时间戳，返回一个浮点数。
  • datetime 模块使用 datetime.now() 方法获取当前时间的 datetime 对象，可以通过 timestamp() 方法将其转换为时间戳。

• 时间格式化：

  • time 模块使用 time.strftime() 方法将时间格式化为指定格式的字符串。
  • datetime 模块的 datetime 对象有一个内置的 strftime() 方法，可以将日期和时间格式化为字符串。

• 时间差计算：

  • time 模块可以使用 time.sleep() 方法进行暂停一段时间的操作，单位为秒。
  • datetime 模块的 timedelta 类可以用于计算两个日期或时间之间的差值，得到一个表示时间差的对象。

举例DEMO

1. 获取当前时间：

import time

current_time = time.time()
print(current_time)

#输出：1702081565.4168005

2. 格式化当前时间：

import time

current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print(current_time)
#输出：2023-12-09 08:27:09

3. 将时间戳转换为可读格式：

import time

timestamp = 1584138389
readable_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(timestamp))
print(readable_time)
#输出：2023-12-09 08:28:24

4. 延迟执行：

import time

print("开始")
time.sleep(5)
print("5秒后")

5. 获取程序运行时间：

import time

start_time = time.time()

# 执行一些代码

end_time = time.time()
execution_time = end_time - start_time
print(f"程序执行时间: {execution_time}秒")

常用的datetime模块功能的使用示例：

1. 获取当前日期和时间：

import datetime

now = datetime.datetime.now()
print("当前日期和时间:", now)
#当前日期和时间: 2023-12-09 08:36:05.855800

2. 获取当前日期：

import datetime

today = datetime.date.today()
print("当前日期:", today)
#当前日期: 2023-12-09

3. 获取当前时间：

import datetime

current_time = datetime.datetime.now().time()
print("当前时间:", current_time)
#当前时间: 08:36:29.506800

4. 格式化日期时间：

import datetime

now = datetime.datetime.now()
formatted_datetime = now.strftime("%Y-%m-%d %H:%M:%S")
print("格式化日期和时间:", formatted_datetime)
#格式化日期和时间: 2023-12-09 08:36:43

5. 将字符串转换为日期：

import datetime

date_string = "2022-01-01"
converted_date = datetime.datetime.strptime(date_string, "%Y-%m-%d").date()
print("转换后的日期:", converted_date)
#转换后的日期: 2022-01-01

6. 计算两个日期之间的差异：

import datetime

date1 = datetime.date(2022, 1, 1)
date2 = datetime.date(2022, 2, 1)
diff = date2 - date1
print("日期差异:", diff.days)
#日期差异: 31

7. 添加或减去时间间隔：

import datetime

now = datetime.datetime.now()
one_hour_later = now + datetime.timedelta(hours=1)
one_day_earlier = now - datetime.timedelta(days=1)
print("一小时后的时间:", one_hour_later)
print("一天前的时间:", one_day_earlier)

#一小时后的时间: 2023-12-09 09:37:44.822800
#一天前的时间: 2023-12-08 08:37:44.822800

时间元组
在Python中，时间元组是一个包含了9个元素的元组，表示了一个特定时间的不同方面。这些元素包括年份、月份、日期、小时、分钟、秒钟、星期、一年中的第几天以及夏令时信息。

时间元组的结构如下：
(年, 月, 日, 时, 分, 秒, 星期, 一年中的第几天, 夏令时)

下面是一个例子：

import time

# 获取当前时间的时间元组
current_time = time.localtime()

# 打印时间元组的各个元素
print("年份：", current_time.tm_year)
print("月份：", current_time.tm_mon)
print("日期：", current_time.tm_mday)
print("小时：", current_time.tm_hour)
print("分钟：", current_time.tm_min)
print("秒钟：", current_time.tm_sec)
print("星期：", current_time.tm_wday)
print("一年中的第几天：", current_time.tm_yday)
print("夏令时：", current_time.tm_isdst)

#输出
年份： 2023
月份： 12
日期： 9
小时： 8
分钟： 50
秒钟： 22
星期： 5
一年中的第几天： 343
夏令时： 0

执行以上代码会输出当前时间的时间元组的各个元素值。请注意，时间元组中的月份、日期、小时、分钟和秒钟的取值范围通常是在1到12、1到31、0到23、0到59和0到61之间，但具体取值范围可能会因为系统的不同而有所变化。星期的取值范围是0到6，0代表星期一，1代表星期二，以此类推。一年中的第几天的取值范围是1到366，夏令时的取值为-1、0或1，其中-1表示不确定是否为夏令时。