Python 的 `re` 模块提供强大的正则表达式操作，用于字符串的匹配、查找、替换等。以下是 `re` 模块的一些常用操作及示例：

```python
import re
```



---

## 1. 匹配操作

### `re.match()`

从字符串的开头开始匹配，返回 `Match` 对象。如果匹配不成功，返回 `None`。

```python
result = re.match(r'\d+', '123abc')  # 匹配数字开头
print(result.group())  # 输出: 123
```

### `re.search()`

搜索整个字符串，返回第一个匹配的 `Match` 对象。

```python
result = re.search(r'\d+', 'abc123xyz')  # 搜索字符串中第一个数字部分
print(result.group())  # 输出: 123
```

### `re.fullmatch()`

要求整个字符串完全匹配，返回 `Match` 对象。

```python
result = re.fullmatch(r'\d+', '123')  # 整个字符串是数字
print(result.group())  # 输出: 123
```

---

## 2. 查找操作

### `re.findall()`

返回所有匹配项的列表。

```python
result = re.findall(r'\d+', 'abc123xyz456')
print(result)  # 输出: ['123', '456']
```

### `re.finditer()`

返回所有匹配项的迭代器，每个项为一个 `Match` 对象。

```python
matches = re.finditer(r'\d+', 'abc123xyz456')
for match in matches:
    print(match.group())  # 输出: 123, 456
```

---

## 3. 替换和分割

### `re.sub()`

替换匹配的字符串，可以指定替换次数。

```python
result = re.sub(r'\d+', 'X', 'abc123xyz456')
print(result)  # 输出: abcXxyzX
```

### `re.subn()`

类似于 `sub()`，但返回包含新字符串和替换次数的元组。

```python
result = re.subn(r'\d+', 'X', 'abc123xyz456')
print(result)  # 输出: ('abcXxyzX', 2)
```

### `re.split()`

按照匹配项分割字符串，返回分割后的列表。

```python
result = re.split(r'\d+', 'abc123xyz456')
print(result)  # 输出: ['abc', 'xyz', '']
```

---

## 4. 编译正则表达式

### `re.compile()`

将正则表达式编译成 `Pattern` 对象，支持重用和预定义标志。

```python
pattern = re.compile(r'\d+')
result = pattern.findall('abc123xyz456')
print(result)  # 输出: ['123', '456']
```

---

## 5. 常用正则表达式模式

- `.`：匹配任意单个字符（除换行符）
- `\d`：匹配任意数字字符，等价于 `[0-9]`
- `\D`：匹配非数字字符
- `\w`：匹配任意字母、数字或下划线字符
- `\W`：匹配非字母、数字或下划线字符
- `\s`：匹配空白字符（空格、制表符、换行符等）
- `\S`：匹配非空白字符
- `^`：匹配字符串开头
- `$`：匹配字符串结尾
- `*`：匹配前一个字符 0 次或多次
- `+`：匹配前一个字符 1 次或多次
- `?`：匹配前一个字符 0 次或 1 次
- `{m,n}`：匹配前一个字符 m 到 n 次

---

## 6. 正则表达式标志

`re` 模块提供一些标志，用于调整正则表达式的匹配行为：

- `re.IGNORECASE` (`re.I`)：忽略大小写匹配
- `re.MULTILINE` (`re.M`)：使 `^` 和 `$` 匹配每行的开头和结尾
- `re.DOTALL` (`re.S`)：使 `.` 匹配包括换行符在内的所有字符
- `re.VERBOSE` (`re.X`)：使表达式更具可读性，允许使用空白和注释

示例：

```python
pattern = re.compile(r'hello', re.IGNORECASE)
print(pattern.match('Hello'))  # 匹配成功，忽略大小写
```

---

## 7. 获取匹配对象信息

使用 `Match` 对象的方法来获取匹配的详细信息：

- `group()`：返回匹配的字符串
- `start()`：匹配开始的位置
- `end()`：匹配结束的位置
- `span()`：返回 `(start, end)` 元组，表示匹配范围

```python
match = re.search(r'\d+', 'abc123xyz')
print(match.group())  # 输出: 123
print(match.start())  # 输出: 3
print(match.end())    # 输出: 6
print(match.span())   # 输出: (3, 6)
```

re正则模块使用

`random` 模块提供生成随机数、随机选择列表元素、打乱顺序等常用操作。以下是 `random` 模块的常用方法：

```python
import random
```



---

## 1. 随机数生成

### 生成随机整数

生成指定范围内的随机整数，包括边界值。

```python
random_int = random.randint(1, 10)  # 生成 1 到 10 之间的整数
```

### 生成随机浮点数

生成 0.0 到 1.0 之间的随机浮点数。

```python
random_float = random.random()
```

生成指定范围内的随机浮点数。

```python
random_uniform = random.uniform(1.5, 10.5)  # 生成 1.5 到 10.5 之间的浮点数
```

### 生成随机小数

生成 [0, 1) 范围内的随机小数。

```python
random_float = random.random()
```

### 生成正态分布的随机数

生成均值为 `mu`，标准差为 `sigma` 的正态分布随机数。

```python
random_gauss = random.gauss(mu=0, sigma=1)
```

---

## 2. 随机选择

### 随机选择列表中的元素

从非空序列中随机选择一个元素。

```python
elements = ['a', 'b', 'c', 'd']
random_element = random.choice(elements)
```

### 随机选择多个元素（不重复）

从列表中选择 `k` 个不同的元素。

```python
random_sample = random.sample(elements, k=2)  # 随机选择 2 个不同的元素
```

### 随机选择多个元素（可重复）

从列表中选择 `k` 个元素，允许重复。

```python
random_choices = random.choices(elements, k=3)
```

---

## 3. 顺序打乱

### 打乱列表顺序

```python
random.shuffle(elements)  # 原地打乱元素顺序
```

---

## 4. 随机种子

设置随机数种子，使得每次运行生成的随机数相同（便于调试或复现）。

```python
random.seed(42)
```

---

## 5. 范围内随机数生成

### 生成范围内的随机偶数或奇数

使用 `randrange` 生成范围内带步长的随机数（例如，偶数或奇数）。

```python
random_even = random.randrange(0, 10, 2)  # 生成 0 到 10 之间的随机偶数
```

---

## 6. 自定义概率的随机选择

指定每个元素的权重（概率），进行随机选择。

```python
elements = ['a', 'b', 'c']
weights = [0.1, 0.3, 0.6]
random_weighted_choice = random.choices(elements, weights=weights, k=1)
```

radom模块使用

Python 提供了丰富的内置函数，以下是一些常用的内置函数及其操作示例，涵盖数值运算、序列操作、类型转换、输入输出等常见用途。

---

## 1. 数值运算

### `abs()`

获取数字的绝对值。

```python
print(abs(-5))  # 输出: 5
```

### `round()`

将浮点数四舍五入到指定小数位数。

```python
print(round(3.14159, 2))  # 输出: 3.14
```



### `pow()`

计算 `x` 的 `y` 次幂，相当于 `x ** y`。

```python
print(pow(2, 3))  # 输出: 8
```

### `divmod()`

返回商和余数的元组 `(quotient, remainder)`。

```python
print(divmod(10, 3))  # 输出: (3, 1)
```

---

## 2. 序列操作

### `len()`

获取序列的长度。

```python
print(len([1, 2, 3]))  # 输出: 3
```

### `max()` 和 `min()`

获取序列中的最大值或最小值。

```python
print(max([1, 2, 3]))  # 输出: 3
print(min([1, 2, 3]))  # 输出: 1
```

### `sum()`

计算序列中所有元素的和。

```python
print(sum([1, 2, 3]))  # 输出: 6
```

### `sorted()`

对序列进行排序，返回一个新的排序后的列表。

```python
print(sorted([3, 1, 2]))  # 输出: [1, 2, 3]
```

### `reversed()`

返回一个反向迭代器。

```python
for i in reversed([1, 2, 3]):
    print(i)  # 输出: 3, 2, 1
```

---

## 3. 类型转换

### `int()`, `float()`, `str()`

将值转换为整数、浮点数或字符串。

```python
print(int("10"))    # 输出: 10
print(float("3.14"))  # 输出: 3.14
print(str(10))      # 输出: '10'
```

### `list()`, `tuple()`, `set()`, `dict()`

将其他可迭代对象转换为列表、元组、集合或字典。

```python
print(list("abc"))    # 输出: ['a', 'b', 'c']
print(tuple([1, 2]))  # 输出: (1, 2)
print(set([1, 2, 2])) # 输出: {1, 2}
```

### `ord()` 和 `chr()`

字符与 ASCII/Unicode 码之间的转换。

```python
print(ord('A'))  # 输出: 65
print(chr(65))   # 输出: 'A'
```

---

## 4. 输入输出

### `print()`

输出到控制台。

```python
print("Hello, World!")
```

### `input()`

从控制台接收输入（字符串类型）。

```python
name = input("Enter your name: ")
print("Hello, " + name)
```

---

## 5. 高阶函数

### `map()`

对序列中的每个元素应用一个函数，返回一个迭代器。

```python
numbers = [1, 2, 3]
squared = map(lambda x: x ** 2, numbers)
print(list(squared))  # 输出: [1, 4, 9]
```

### `filter()`

根据条件筛选序列中的元素。

```python
numbers = [1, 2, 3, 4]
even = filter(lambda x: x % 2 == 0, numbers)
print(list(even))  # 输出: [2, 4]
```

### `zip()`

将多个可迭代对象打包成一个迭代器。

```python
a = [1, 2]
b = ['x', 'y']
print(list(zip(a, b)))  # 输出: [(1, 'x'), (2, 'y')]
```

---

## 6. 枚举与迭代

### `enumerate()`

为可迭代对象中的每个元素提供索引。

```python
names = ['Alice', 'Bob']
for index, name in enumerate(names):
    print(index, name)
```

### `all()` 和 `any()`

检查可迭代对象中的元素是否全部为 `True` 或至少一个为 `True`。

```python
print(all([True, True, False]))  # 输出: False
print(any([True, False, False])) # 输出: True
```

---

## 7. 对象属性和类型

### `type()`

返回对象的类型。

```python
print(type(10))  # 输出: <class 'int'>
```

### `isinstance()`

检查对象是否属于特定类型。

```python
print(isinstance(10, int))  # 输出: True
```

### `dir()`

返回对象的所有属性和方法。

```python
print(dir([1, 2, 3]))  # 列出列表的属性和方法
```

python内置函数使用

## 在 PyCharm 中可以设置代码模板，具体的设置方法

1. **打开 PyCharm 设置**：  
   在顶部菜单栏中选择 `File` -> `Settings`（在 macOS 上是 `PyCharm` -> `Preferences`）。

2. **导航到文件模板设置**：  
   在设置窗口中，展开 `Editor` -> `File and Code Templates`，然后选择 `Python Script`。

3. **编辑模板内容**：  
   在模板编辑框中，输入您想要的内容，例如：

   ```python
   # _*_ coding : UTF-8 _*_
   # @Time : ${YEAR}/${MONTH}/${DAY} ${HOUR}:${MINUTE}
   # @UpdateTime : ${YEAR}/${MONTH}/${DAY} ${HOUR}:${MINUTE}
   # @Author : xxxx
   # @File : ${NAME}.py
   # @Software : PyCharm
   # @Comment : 本程序xxxx
   ```

   **说明**：  
   - `${YEAR}`, `${MONTH}`, `${DAY}`, `${HOUR}`, `${MINUTE}` 等变量将自动填充当前的日期和时间。
   - `${NAME}` 会自动填入文件名。

4. **保存设置**：  
   点击 `Apply` 和 `OK` 以保存更改。

   ---



   

## 在 PyCharm 的文件模板中可以使用的变量很多，以下是一些常见的模板变量

1. **日期和时间相关**：
   - `${YEAR}`：当前年份（如 `2024`）
   - `${MONTH}`：当前月份（两位数，如 `01`）
   - `${DAY}`：当前日期（两位数，如 `12`）
   - `${HOUR}`：当前小时（24小时制，两位数，如 `14`）
   - `${MINUTE}`：当前分钟（两位数，如 `15`）
   - `${SECOND}`：当前秒（两位数，如 `30`）

2. **文件信息**：
   - `${NAME}`：当前文件名（不包含扩展名）
   - `${FILE_NAME}`：当前文件的完整名称（包含扩展名，如 `example.py`）
   - `${PACKAGE_NAME}`：当前文件所在包的名称（例如 `my.package`）

3. **项目相关**：
   - `${PROJECT_NAME}`：当前项目的名称
   - `${USER}`：当前系统用户名

4. **类和方法信息（仅在类或方法模板中适用）**：
   - `${CLASS_NAME}`：当前类的名称
   - `${METHOD_NAME}`：当前方法的名称

这些变量在合适的模板环境中会自动替换成对应的值。

Pycharm代码模板设置

`motor` 是一个适用于 MongoDB 的异步 Python 驱动，通常和 `asyncio` 一起使用，用于非阻塞的数据库操作。 `motor` 是异步库， `pymongo`是同步库

 以下是一些常见的 操作，主要使用异步方式，并对比同样的同步方式。

### 0.安装

```shell
pip install motor pymongo
```



### 1. 导入模块并连接 MongoDB

#### 异步（Motor）

```python
import motor.motor_asyncio
from pymongo import MongoClient  # 同步操作示例使用的库

client = motor.motor_asyncio.AsyncIOMotorClient("mongodb://localhost:27017")
db = client["your_database"]
collection = db["your_collection"]
```

#### 同步（pymongo）

```python
client = MongoClient("mongodb://localhost:27017")
db = client["your_database"]
collection = db["your_collection"]
```

### 2. 插入文档

#### 异步插入单个文档

```python
async def insert_one():
    result = await collection.insert_one({"name": "Alice", "age": 25})
    print("Inserted ID:", result.inserted_id)
```

#### 同步插入单个文档

```python
result = collection.insert_one({"name": "Alice", "age": 25})
print("Inserted ID:", result.inserted_id)
```

#### 异步插入多个文档

```python
async def insert_many():
    result = await collection.insert_many([{"name": "Bob", "age": 30}, {"name": "Charlie", "age": 35}])
    print("Inserted IDs:", result.inserted_ids)
```

#### 同步插入多个文档

```python
result = collection.insert_many([{"name": "Bob", "age": 30}, {"name": "Charlie", "age": 35}])
print("Inserted IDs:", result.inserted_ids)
```

### 3. 查询文档

#### 异步查询单个文档

```python
async def find_one():
    document = await collection.find_one({"name": "Alice"})
    print("Found Document:", document)
```

#### 同步查询单个文档

```python
document = collection.find_one({"name": "Alice"})
print("Found Document:", document)
```

#### 异步查询多个文档

```python
async def find_many():
    cursor = collection.find({"age": {"$gte": 25}})
    async for document in cursor:
        print(document)
```

#### 同步查询多个文档

```python
for document in collection.find({"age": {"$gte": 25}}):
    print(document)
```

### 4. 更新文档

#### 异步更新单个文档

```python
async def update_one():
    result = await collection.update_one({"name": "Alice"}, {"$set": {"age": 26}})
    print("Matched count:", result.matched_count)
    print("Modified count:", result.modified_count)
```

#### 同步更新单个文档

```python
result = collection.update_one({"name": "Alice"}, {"$set": {"age": 26}})
print("Matched count:", result.matched_count)
print("Modified count:", result.modified_count)
```

#### 异步更新多个文档

```python
async def update_many():
    result = await collection.update_many({"age": {"$lt": 30}}, {"$set": {"status": "young"}})
    print("Matched count:", result.matched_count)
    print("Modified count:", result.modified_count)
```

#### 同步更新多个文档

```python
result = collection.update_many({"age": {"$lt": 30}}, {"$set": {"status": "young"}})
print("Matched count:", result.matched_count)
print("Modified count:", result.modified_count)
```

### 5. 删除文档

#### 异步删除单个文档

```python
async def delete_one():
    result = await collection.delete_one({"name": "Alice"})
    print("Deleted count:", result.deleted_count)
```

#### 同步删除单个文档

```python
result = collection.delete_one({"name": "Alice"})
print("Deleted count:", result.deleted_count)
```

#### 异步删除多个文档

```python
async def delete_many():
    result = await collection.delete_many({"age": {"$gte": 30}})
    print("Deleted count:", result.deleted_count)
```

#### 同步删除多个文档

```python
result = collection.delete_many({"age": {"$gte": 30}})
print("Deleted count:", result.deleted_count)
```

### 6. 聚合查询

#### 异步聚合

```python
async def aggregate():
    pipeline = [{"$match": {"age": {"$gte": 25}}}, {"$group": {"_id": "$age", "count": {"$sum": 1}}}]
    async for doc in collection.aggregate(pipeline):
        print(doc)
```

#### 同步聚合

```python
pipeline = [{"$match": {"age": {"$gte": 25}}}, {"$group": {"_id": "$age", "count": {"$sum": 1}}}]
for doc in collection.aggregate(pipeline):
    print(doc)
```

### 7. 创建索引

#### 异步创建索引

```python
async def create_index():
    index_name = await collection.create_index("name")
    print("Index created:", index_name)
```

#### 同步创建索引

```python
index_name = collection.create_index("name")
print("Index created:", index_name)
```

### 8. 查询数据表（集合）是否存在

MongoDB 中没有显式的 "表" 概念，集合相当于关系型数据库中的表。我们可以通过 `list_collection_names()` 方法检查集合是否存在。

#### 异步（Motor）

```python
async def collection_exists(db, collection_name):
    collection_names = await db.list_collection_names()
    return collection_name in collection_names
```

#### 同步（pymongo）

```python
collection_names = db.list_collection_names()
exists = "your_collection" in collection_names
print("Collection exists:", exists)
```

### 9. 统计数据表（集合）中的数据量

可以使用 `count_documents` 方法来统计符合条件的文档数。若统计整个集合的数据量，条件为空 `{}` 即可。

#### 异步统计整个集合的文档数量

```python
async def count_documents():
    total_count = await collection.count_documents({})
    print("Total documents:", total_count)
```

#### 同步统计整个集合的文档数量

```python
total_count = collection.count_documents({})
print("Total documents:", total_count)
```

#### 异步统计符合特定条件的文档数量

```python
async def count_filtered_documents():
    count = await collection.count_documents({"age": {"$gte": 25}})
    print("Filtered documents:", count)
```

#### 同步统计符合特定条件的文档数量

```python
count = collection.count_documents({"age": {"$gte": 25}})
print("Filtered documents:", count)
```

### 10. 文档查询条件

MongoDB 支持丰富的查询条件，以下是一些常见的查询条件写法：

#### 基本查询条件

- **匹配字段等于某值**：`{"field": value}`
- **字段大于某值**：`{"field": {"$gt": value}}`
- **字段小于某值**：`{"field": {"$lt": value}}`
- **字段在某范围内**：`{"field": {"$gte": min_value, "$lte": max_value}}`
- **字段不等于某值**：`{"field": {"$ne": value}}`

```python
# 异步示例
async def find_with_conditions():
    # 查询 age 大于 25 且 name 为 "Alice" 的文档
    async for doc in collection.find({"age": {"$gt": 25}, "name": "Alice"}):
        print(doc)
```

#### 查询字段存在性

- **检查字段是否存在**：`{"field": {"$exists": True}}`
- **检查字段是否不存在**：`{"field": {"$exists": False}}`

```python
# 异步示例
async def find_with_field_existence():
    async for doc in collection.find({"address": {"$exists": True}}):
        print(doc)
```

#### 正则表达式查询

可以使用 `$regex` 查询字符串字段的特定模式：

```python
# 异步示例
async def find_with_regex():
    async for doc in collection.find({"name": {"$regex": "^A"}}):
        print(doc)  # 查询 name 字段以 "A" 开头的文档
```

#### $in 和 $nin 条件查询

- `$in`：匹配字段在指定的值列表内
- `$nin`：匹配字段不在指定的值列表内

```python
# 异步示例
async def find_with_in_nin():
    async for doc in collection.find({"age": {"$in": [25, 30, 35]}}):
        print(doc)  # 查询 age 为 25、30 或 35 的文档
```

#### 组合查询：$and、$or

- `$and`：同时满足多个条件
- `$or`：满足其中一个条件

```python
# 异步示例
async def find_with_and_or():
    async for doc in collection.find({
        "$or": [
            {"age": {"$gt": 25}},
            {"name": "Alice"}
        ]
    }):
        print(doc)  # 查询 age 大于 25 或 name 为 "Alice" 的文档
```

### 11. 示例：结合所有查询条件

```python
# 异步示例，结合多种查询条件
async def complex_query():
    query = {
        "$and": [
            {"age": {"$gte": 25, "$lt": 40}},        # 年龄在 25 到 40 之间
            {"name": {"$regex": "^A"}},               # 名字以 "A" 开头
            {"address": {"$exists": True}},           # 存在 address 字段
            {"status": {"$in": ["active", "pending"]}} # status 为 "active" 或 "pending"
        ]
    }
    async for doc in collection.find(query):
        print(doc)
```