`httpx` 是一个功能强大的 HTTP 客户端库，支持同步和异步操作。以下是 `httpx` 的常用操作：

## 1. 安装 `httpx`

```bash
pip install httpx
```

---



## 同步操作

### 导入 `httpx` 并发送请求

```python
import httpx
```

### 常用请求操作

#### GET 请求

```python
response = httpx.get("https://api.example.com/data")
response.encoding = response.charset_encoding #设置编码
print(response.status_code)
print(response.json()) # 获取 JSON 响应
print(response.text) # 获取文本响应
```

#### POST 请求

```python
payload = {"key": "value"}
response = httpx.post("https://api.example.com/data", json=payload)
print(response.json())
```

#### 其他 HTTP 方法

```python
# PUT 请求
response = httpx.put("https://api.example.com/data", json={"update": "value"})

# DELETE 请求
response = httpx.delete("https://api.example.com/data")
```

### 设置请求参数、头部、超时

```python
response = httpx.get("https://api.example.com/data", params={"query": "test"}, headers={"Authorization": "Bearer token"}, timeout=10.0)
print(response.json())
```

### 上传文件

```python
files = {"file": ("filename.txt", open("filename.txt", "rb"), "text/plain")}
response = httpx.post("https://api.example.com/upload", files=files)
print(response.status_code)
```

### 会话管理

使用 `httpx.Client` 可以维持一个会话（session），对多个请求使用同一配置。

```python
with httpx.Client(base_url="https://api.example.com") as client:
 response = client.get("/data")
 print(response.json())
```

---

## 异步操作

`httpx` 支持异步请求，适合高并发和网络密集型应用。

### 导入 `httpx` 和 `asyncio`

```python
import httpx
import asyncio
```

### 异步请求操作

#### 异步 GET 请求

```python
async def fetch_data():
 async with httpx.AsyncClient() as client:
 response = await client.get("https://api.example.com/data")
 print(response.json())

# 运行异步任务
asyncio.run(fetch_data())
```

#### 异步 POST 请求

```python
async def send_data():
 async with httpx.AsyncClient() as client:
 response = await client.post("https://api.example.com/data", json={"key": "value"})
 print(response.json())

asyncio.run(send_data())
```

### 异步上传文件

```python
async def upload_file():
 async with httpx.AsyncClient() as client:
 files = {"file": ("filename.txt", open("filename.txt", "rb"), "text/plain")}
 response = await client.post("https://api.example.com/upload", files=files)
 print(response.status_code)

asyncio.run(upload_file())
```

### 异步并发请求

可以使用 `asyncio.gather` 实现多个异步任务并发执行。

```python
async def fetch(url):
 async with httpx.AsyncClient() as client:
 response = await client.get(url)
 return response.json()

async def main():
 urls = ["https://api.example.com/data1", "https://api.example.com/data2"]
 results = await asyncio.gather(*[fetch(url) for url in urls])
 print(results)

asyncio.run(main())
```

### 异步会话管理

```python
async def fetch_data_with_session():
 async with httpx.AsyncClient(base_url="https://api.example.com") as client:
 response = await client.get("/data")
 print(response.json())

asyncio.run(fetch_data_with_session())
```

---

## 异步与同步的常见配置选项

### 超时设置

可以为 `httpx` 请求设置不同类型的超时：

```python
timeout = httpx.Timeout(5.0, connect=10.0)
response = httpx.get("https://api.example.com/data", timeout=timeout)
```

### 重试策略

`httpx` 不直接支持重试机制，但可以通过自定义来实现：

```python
async def fetch_with_retries(url, retries=3):
 for i in range(retries):
 try:
 async with httpx.AsyncClient() as client:
 response = await client.get(url)
 return response
 except httpx.RequestError:
 if i == retries - 1:
 raise

# 异步调用
asyncio.run(fetch_with_retries("https://api.example.com"))
```

### 设置代理

同步和异步操作均支持代理配置：

```python
# 同步代理
response = httpx.get("https://api.example.com", proxies="http://proxyserver:port")

# 异步代理
async with httpx.AsyncClient(proxies="http://proxyserver:port") as client:
 response = await client.get("https://api.example.com")
```

httpx模块使用

`BeautifulSoup` 是解析 HTML 和 XML 数据的强大工具：

### 0.安装

```bash
pip install bs4 lxml
```


### 1. 导入并初始化解析器

```python
from bs4 import BeautifulSoup

html_data = '''<html><head><title>Example</title></head>
<body>
Example Page
This is an example page.
<a href="http://example.com/page1" class="link">Page 1</a>
<a href="http://example.com/page2" class="link">Page 2</a>
</body></html>'''

soup = BeautifulSoup(html_data, 'html.parser') # 可用 'lxml' 或 'xml' 来处理 XML
```
### 2. 基本操作

#### 获取标签内容

```python
title = soup.title.text # 获取 <title> 标签的文本内容
print(title) # 输出: Example
```

#### 获取第一个匹配的标签

```python
first_paragraph = soup.find("p")
print(first_paragraph) # 输出第一个 标签的内容
```

#### 获取所有匹配的标签

```python
all_links = soup.find_all("a")
for link in all_links:
 print(link) # 输出每个 <a> 标签的内容
```

### 3. 使用属性查找元素

#### 按属性查找

```python
link = soup.find("a", href="http://example.com/page1")
print(link) # 查找 href 为 http://example.com/page1 的 <a> 标签
```

#### 多属性查找

```python
link = soup.find("a", {"class": "link", "href": "http://example.com/page1"})
print(link) # 查找具有多个特定属性的标签
```

### 4. 获取标签属性

```python
for link in all_links:
 print(link["href"]) # 输出每个 <a> 标签的 href 属性值
```

### 5. 查找特定类名或 ID 的元素

#### 按类名查找

```python
content = soup.find("p", class_="content")
print(content) # 输出 class 为 "content" 的 标签
```

#### 按 ID 查找

```python
# 假设 HTML 中有 <div id="main">...</div>
main_div = soup.find(id="main")
print(main_div)
```

### 6. 嵌套查找

```python
body = soup.body
content_paragraph = body.find("p", class_="content")
print(content_paragraph.text) # 输出嵌套查找的文本内容
```

### 7. 选择器语法

`BeautifulSoup` 支持 CSS 选择器。

```python
# 选择第一个 class="title" 的 标签
title = soup.select_one("p.title")
print(title.text)

# 选择所有 class="link" 的 <a> 标签
links = soup.select("a.link")
for link in links:
 print(link["href"])
```

### 8. 兄弟和父子节点导航

```python
# 获取兄弟标签
first_link = soup.find("a")
next_link = first_link.find_next_sibling("a")
print(next_link) # 获取下一个兄弟 <a> 标签

# 获取父标签
parent = first_paragraph.parent
print(parent) # 获取第一个 标签的父标签
```

### 9. 获取标签文本内容

- **所有文本**：使用 `.get_text()` 或 `.text`
- **指定分隔符**：使用 `.get_text(separator=", ")`

```python
all_text = soup.get_text(separator=" | ")
print(all_text) # 输出整个文档的文本内容，使用 | 分隔
```

### 10. 清理 HTML

`BeautifulSoup` 还能清理并格式化 HTML，方便输出整洁的结果。

```python
print(soup.prettify()) # 输出格式化的 HTML
```

BeautifulSoup模块使用

`datetime` 模块在 Python 中非常实用，尤其是在处理日期和时间时。以下是 `datetime` 模块的一些常用方法：

### 1. 导入模块

```python
from datetime import datetime, timedelta, date, time
```

### 2. 获取当前日期和时间

- **当前日期时间**：`datetime.now()` 
- **当前日期**：`date.today()`
- **当前时间**：`datetime.now().time()`

```python
print(datetime.now()) # 当前日期和时间
print(date.today()) # 当前日期
print(datetime.now().time()) # 当前时间
```

### 3. 创建指定日期和时间

- **创建日期时间**：`datetime(year, month, day, hour, minute, second)`
- **创建日期**：`date(year, month, day)`
- **创建时间**：`time(hour, minute, second)`

```python
dt = datetime(2024, 1, 12, 14, 15, 0)
d = date(2024, 1, 12)
t = time(14, 15, 0)
print(dt)
print(d)
print(t)
```

### 4. 字符串和日期之间的转换

- **字符串转日期**：`datetime.strptime(date_string, format)`
- **日期转字符串**：`datetime.strftime(format)`

```python
# 字符串转日期
dt = datetime.strptime('2024-01-12 14:15', '%Y-%m-%d %H:%M')

# 日期转字符串
date_str = dt.strftime('%Y-%m-%d %H:%M')
print(dt)
print(date_str)
```

### 5. 日期加减操作

- 使用 `timedelta` 可以对日期进行加减操作：

```python
# 日期加减
today = date.today()
yesterday = today - timedelta(days=1)
tomorrow = today + timedelta(days=1)
print(yesterday, tomorrow)
```

### 6. 日期时间的属性

- **年份**：`datetime.year`
- **月份**：`datetime.month`
- **日期**：`datetime.day`
- **小时**：`datetime.hour`
- **分钟**：`datetime.minute`
- **秒**：`datetime.second`

```python
now = datetime.now()
print(now.year, now.month, now.day, now.hour, now.minute, now.second)
```

### 7. 比较日期和时间

可以使用运算符 `==`, `!=`, `<`, `>`, `<=`, `>=` 进行日期和时间的比较：

```python
date1 = datetime(2024, 1, 12)
date2 = datetime(2023, 12, 31)
print(date1 > date2) # True
```

### 8. 获取星期几

- 使用 `weekday()` 获取星期几（周一为 0，周日为 6）
- 使用 `isoweekday()` 获取星期几（周一为 1，周日为 7）

```python
today = date.today()
print(today.weekday()) # 0-6，0表示周一
print(today.isoweekday()) # 1-7，1表示周一
```

### 9. 时间戳与日期时间转换

- **时间戳转日期时间**：`datetime.fromtimestamp(timestamp)`
- **日期时间转时间戳**：`datetime.timestamp()`

```python
# 时间戳转日期时间
timestamp = 1609459200 # 对应2021-01-01 00:00:00
dt = datetime.fromtimestamp(timestamp)

# 日期时间转时间戳
timestamp = datetime.now().timestamp()
print(dt)
print(timestamp)
```

### 10. 获取日期差

- 可以直接相减，得到 `timedelta` 对象。

```python
date1 = datetime(2024, 1, 12)
date2 = datetime(2023, 12, 31)
delta = date1 - date2
print(delta.days) # 差几天
```

### 11.获取开始时间到结束时间内所有的月份

要获取从 `start_date` 到 `end_date` 的所有月份，可以使用 `datetime` 模块循环生成每个月的日期。以下是一个示例代码：

```python
from datetime import datetime, timedelta

start_date = datetime.strptime('2017-09', '%Y-%m')
end_date = datetime.today()

# 创建一个列表保存月份
months = []

# 使用循环获取每个月份
current_date = start_date
while current_date <= end_date:
 months.append(current_date.strftime('%Y%m'))
 # 增加一个月
 if current_date.month == 12:
 current_date = current_date.replace(year=current_date.year + 1, month=1)
 else:
 current_date = current_date.replace(month=current_date.month + 1)

print(months)
```

#### 解释

- 代码从 `start_date` 开始，每次增加一个月，直到 `end_date`。
- 如果当前月份是 12 月，则年份加 1 并将月份设置为 1 月；否则直接加 1 个月。
 
#### 输出示例

```python
['201709', '201710', '201711', ..., '202411']
```

1. 安装 httpx

0.安装

1. 导入模块

1. 安装 `httpx`