`Click` 是一个用于创建命令行接口（CLI）的 Python 包。



它设计得非常简单易用，同时提供了强大的功能，如自动生成帮助信息、支持子命令、参数解析等。`Click` 使得编写复杂的命令行工具变得轻而易举。

### 安装

首先，你需要安装 `click` 包。可以通过 pip 来安装：

```bash
pip install click
```

### 基本使用示例

以下是一些具体的示例，展示了如何使用 `Click` 创建命令行工具。

#### 1. 创建一个简单的命令行工具

下面是一个最基本的 `Click` 应用程序示例：

```python
import click

@click.command()
def hello():
 """这是一个简单的命令行工具示例"""
 click.echo('Hello, World!')

if __name__ == '__main__':
 hello()
```

保存上述代码到一个文件中，例如 `hello.py`，然后在终端中运行：

```bash
python hello.py
```

输出将是：

```
Hello, World!
```

#### 2. 添加选项和参数

你可以通过装饰器为命令添加选项和参数：

```python
import click

@click.command()
@click.option('--count', default=1, help='打印次数')
@click.option('--name', prompt='你的名字', help='输入你的名字')
def greet(count, name):
 """根据提供的选项向用户问好"""
 for _ in range(count):
 click.echo(f'你好, {name}!')

if __name__ == '__main__':
 greet()
```

在这个例子中，`--count` 是一个可选参数，默认值为 1，而 `--name` 则是一个需要用户输入的参数。如果你不提供 `--name` 参数，程序会提示你输入。

运行命令：

```bash
python greet.py --count=3
```

输出将是：

```
你的名字: Alice
你好, Alice!
你好, Alice!
你好, Alice!
```

#### 3. 处理多个参数

你可以通过 `@click.argument` 装饰器来处理位置参数：

```python
import click

@click.command()
@click.argument('filename')
@click.option('--count', default=1, help='打印次数')
def print_file_content(filename, count):
 """读取并打印文件内容"""
 with open(filename, 'r') as f:
 content = f.read()
 
 for _ in range(count):
 click.echo(content)

if __name__ == '__main__':
 print_file_content()
```

在这个例子中，`filename` 是一个必需的位置参数。运行命令时需要提供文件名：

```bash
python print_file_content.py example.txt --count=2
```

假设 `example.txt` 文件的内容是 `Hello, Click!`，输出将是：

```
Hello, Click!
Hello, Click!
```

#### 4. 子命令

`Click` 支持定义子命令，这使得你可以构建复杂的命令行工具：

```python
import click

@click.group()
def cli():
 pass

@click.command()
def initdb():
 """初始化数据库"""
 click.echo('Initialized the database')

@click.command()
def dropdb():
 """删除数据库"""
 click.echo('Dropped the database')

cli.add_command(initdb)
cli.add_command(dropdb)

if __name__ == '__main__':
 cli()
```

在这个例子中，我们定义了一个名为 `cli` 的主命令，并添加了两个子命令 `initdb` 和 `dropdb`。运行命令：

```bash
python cli.py initdb
```

输出将是：

```
Initialized the database
```

同样地，运行：

```bash
python cli.py dropdb
```

输出将是：

```
Dropped the database
```

#### 5. 自定义帮助信息

`Click` 自动生成的帮助信息非常有用，但有时你可能希望自定义它。你可以通过 `help` 参数或 `@click.pass_context` 装饰器来实现：

```python
import click

@click.command()
@click.option('--name', help='输入你的名字')
@click.option('--age', help='输入你的年龄')
@click.pass_context
def user_info(ctx, name, age):
 """显示用户信息"""
 if not name or not age:
 ctx.fail('必须提供 --name 和 --age 参数')
 else:
 click.echo(f'姓名: {name}, 年龄: {age}')

if __name__ == '__main__':
 user_info()
```

在这个例子中，如果用户没有提供 `--name` 或 `--age` 参数，程序将显示一条错误消息并退出。

#### 6. 处理复杂类型

`Click` 支持多种复杂的数据类型，如文件、路径、布尔值等：

```python
import click

@click.command()
@click.option('--path', type=click.Path(exists=True), help='文件路径')
@click.option('--verbose', is_flag=True, help='详细模式')
def process_file(path, verbose):
 """处理指定路径下的文件"""
 if verbose:
 click.echo(f'正在处理文件: {path}')
 with open(path, 'r') as f:
 content = f.read()
 click.echo(content)

if __name__ == '__main__':
 process_file()
```

在这个例子中，`--path` 参数要求用户提供一个存在的文件路径，而 `--verbose` 是一个标志选项，表示是否启用详细模式。

#### 7. 错误处理

`Click` 提供了内置的错误处理机制，你可以通过 `ctx.fail()` 方法手动抛出错误：

```python
import click

@click.command()
@click.argument('number', type=int)
@click.pass_context
def divide_by_two(ctx, number):
 """将数字除以二"""
 if number % 2 != 0:
 ctx.fail('提供的数字不是偶数')
 else:
 result = number // 2
 click.echo(f'{number} 除以 2 等于 {result}')

if __name__ == '__main__':
 divide_by_two()
```

在这个例子中，如果用户提供的数字不是偶数，程序将抛出一个错误并显示相应的消息。

Click包

`Paramiko` 是一个用于 Python 的 SSHv2 协议的实现，它允许你通过 SSH 连接到远程服务器，并执行命令、传输文件等操作。





它非常适合需要自动化远程服务器管理任务的应用场景。

### 安装

首先，你需要安装 `paramiko` 包。可以通过 pip 来安装：

```bash
pip install paramiko
```

### 基本使用示例

以下是一些具体的示例，展示了如何使用 `Paramiko` 进行基本的 SSH 操作，如连接到远程服务器、执行命令和传输文件。

#### 1. 连接到远程服务器

要连接到远程服务器，可以使用 `paramiko.SSHClient` 类：

```python
import paramiko

# 创建 SSH 客户端对象
ssh = paramiko.SSHClient()

# 自动添加主机密钥（避免手动确认）
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

# 连接到远程服务器
ssh.connect(hostname='your.server.example.com', username='user', password='password')

# 执行命令
stdin, stdout, stderr = ssh.exec_command('ls -l')

# 输出结果
print(stdout.read().decode())
print(stderr.read().decode())

# 关闭连接
ssh.close()
```

#### 2. 使用私钥进行身份验证

如果你使用私钥而不是密码进行身份验证，可以这样操作：

```python
import paramiko

# 创建 SSH 客户端对象
ssh = paramiko.SSHClient()

# 自动添加主机密钥
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

# 加载私钥
private_key_path = '/path/to/private/key'
private_key = paramiko.RSAKey.from_private_key_file(private_key_path)

# 连接到远程服务器
ssh.connect(hostname='your.server.example.com', username='user', pkey=private_key)

# 执行命令
stdin, stdout, stderr = ssh.exec_command('ls -l')

# 输出结果
print(stdout.read().decode())
print(stderr.read().decode())

# 关闭连接
ssh.close()
```

#### 3. 传输文件

`Paramiko` 提供了 `SFTPClient` 类来传输文件。你可以使用 `SSHClient` 对象的 `open_sftp()` 方法来创建 SFTP 客户端：

```python
import paramiko

# 创建 SSH 客户端对象
ssh = paramiko.SSHClient()

# 自动添加主机密钥
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

# 连接到远程服务器
ssh.connect(hostname='your.server.example.com', username='user', password='password')

# 创建 SFTP 客户端
sftp = ssh.open_sftp()

# 上传文件
local_file_path = '/path/to/local/file.txt'
remote_file_path = '/path/to/remote/file.txt'
sftp.put(local_file_path, remote_file_path)

# 下载文件
sftp.get(remote_file_path, local_file_path)

# 列出远程目录内容
for file in sftp.listdir('/path/to/remote/directory'):
 print(file)

# 关闭 SFTP 和 SSH 连接
sftp.close()
ssh.close()
```

#### 4. 处理长时间运行的命令

对于需要较长时间才能完成的命令，你可以使用 `exec_command` 的 `get_pty=True` 参数来获取伪终端，并逐行读取输出：

```python
import paramiko
import time

# 创建 SSH 客户端对象
ssh = paramiko.SSHClient()

# 自动添加主机密钥
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

# 连接到远程服务器
ssh.connect(hostname='your.server.example.com', username='user', password='password')

# 执行长时间运行的命令
stdin, stdout, stderr = ssh.exec_command('ping -c 4 www.google.com', get_pty=True)

# 实时读取输出
for line in stdout:
 print(line.strip('\n'))
 time.sleep(0.1) # 等待一段时间以模拟实时输出

# 关闭连接
ssh.close()
```

#### 5. 使用上下文管理器

为了确保资源被正确释放，你可以使用上下文管理器来处理连接：

```python
import paramiko

with paramiko.SSHClient() as ssh:
 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
 ssh.connect(hostname='your.server.example.com', username='user', password='password')

 stdin, stdout, stderr = ssh.exec_command('ls -l')
 print(stdout.read().decode())
 print(stderr.read().decode())
```

#### 6. 错误处理

在实际应用中，网络请求可能会失败，因此需要进行适当的错误处理：

```python
import paramiko
from paramiko.ssh_exception import SSHException

try:
 # 创建 SSH 客户端对象
 ssh = paramiko.SSHClient()
 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

 # 连接到远程服务器
 ssh.connect(hostname='your.server.example.com', username='user', password='password')

 # 执行命令
 stdin, stdout, stderr = ssh.exec_command('ls -l')
 print(stdout.read().decode())
 print(stderr.read().decode())

except SSHException as e:
 print(f"SSH 错误: {e}")
except Exception as e:
 print(f"其他错误: {e}")
finally:
 # 确保连接被关闭
 ssh.close()
```

### 总结

`Paramiko` 是一个功能强大且灵活的库，适用于通过 SSH 连接到远程服务器并执行各种操作。

Paramiko包

`BeautifulSoup` 是一个用于解析 HTML 和 XML 文档的 Python 库。





它提供了简洁的接口和强大的功能，使得从网页中提取信息变得非常容易。`BeautifulSoup` 通常与 `requests` 库结合使用，用于抓取网页内容并解析它们。

### 安装

首先，你需要安装 `beautifulsoup4` 包以及常用的解析器库（如 `lxml` 或 `html5lib`）。可以通过 pip 来安装：

```bash
pip install beautifulsoup4
```

### 解析器安装（提升效率）

**下载 `lxml` 解析器：**
```bash
pip install lxml
```

**或者如果你更喜欢 `html5lib` 解析器：**

```bash
pip install html5lib
```

### 基本使用示例

以下是一些具体的示例，展示了如何使用 `BeautifulSoup` 进行网页解析和数据提取。

#### 1. 解析 HTML 内容

假设我们有一个简单的 HTML 文档，并希望通过 `BeautifulSoup` 解析它：

```python
from bs4 import BeautifulSoup

html_doc = """
<html>
<head><title>The Dormouse's story</title></head>
<body>
The Dormouse's story

Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.

...
"""

# 创建 BeautifulSoup 对象
soup = BeautifulSoup(html_doc, 'html.parser')

# 输出美化后的 HTML
print(soup.prettify())
```

#### 2. 提取标签

你可以通过标签名来查找文档中的特定元素：

```python
# 查找第一个 <title> 标签
title_tag = soup.title
print(title_tag)

# 查找所有 标签
p_tags = soup.find_all('p')
for p in p_tags:
 print(p)
```

#### 3. 提取属性

你可以轻松地访问标签的属性，比如 `<a>` 标签的 `href` 属性：

```python
# 查找所有的 <a> 标签
a_tags = soup.find_all('a')
for tag in a_tags:
 # 打印链接文本和 href 属性
 print(f"{tag.get_text()} -> {tag['href']}")
```

#### 4. 提取类和 ID

你可以根据类名或 ID 来查找特定的元素：

```python
# 查找所有 class="sister" 的标签
sister_tags = soup.find_all(class_='sister')
for tag in sister_tags:
 print(tag)

# 查找 ID 为 "link1" 的标签
link1_tag = soup.find(id='link1')
print(link1_tag)
```

#### 5. 遍历树结构

`BeautifulSoup` 提供了多种方式来遍历文档树：

```python
# 获取 <body> 标签下的所有直接子标签
for child in soup.body.children:
 if child.name is not None: # 确保是标签而不是字符串
 print(child)

# 获取 <body> 标签下的所有后代标签
for descendant in soup.body.descendants:
 if descendant.name is not None:
 print(descendant)
```

#### 6. 使用 CSS 选择器

`BeautifulSoup` 支持 CSS 选择器语法，使查找元素更加直观：

```python
# 使用 CSS 选择器查找所有 class="sister" 的 <a> 标签
sister_links = soup.select('a.sister')
for link in sister_links:
 print(link)

# 使用 CSS 选择器查找 ID 为 "link1" 的 <a> 标签
link1 = soup.select_one('#link1')
print(link1)
```

#### 7. 修改文档

你还可以修改文档的内容、属性等：

```python
# 修改 <title> 标签的内容
soup.title.string = "New Title"
print(soup.title)

# 修改 <a> 标签的 href 属性
for tag in soup.find_all('a'):
 tag['href'] = "https://new.example.com"
 print(tag)
```

### 结合 `requests` 抓取网页

通常我们会结合 `requests` 库来抓取网页内容，然后使用 `BeautifulSoup` 进行解析：

```python
import requests
from bs4 import BeautifulSoup

# 发送 GET 请求获取网页内容
url = 'https://example.com'
response = requests.get(url)

# 检查请求是否成功
if response.status_code == 200:
 # 创建 BeautifulSoup 对象
 soup = BeautifulSoup(response.text, 'html.parser')

 # 查找所有的 <a> 标签
 links = soup.find_all('a')
 for link in links:
 print(f"{link.get_text()} -> {link['href']}")
else:
 print(f"请求失败，状态码: {response.status_code}")
```

### 错误处理

在实际应用中，网络请求可能会失败，因此需要进行适当的错误处理：

```python
import requests
from bs4 import BeautifulSoup
from requests.exceptions import RequestException

try:
 url = 'https://example.com'
 response = requests.get(url)
 response.raise_for_status() # 如果响应状态码不是成功的代码，则引发 HTTPError 异常

 soup = BeautifulSoup(response.text, 'html.parser')

 # 查找所有的 <a> 标签
 links = soup.find_all('a')
 for link in links:
 print(f"{link.get_text()} -> {link['href']}")

except RequestException as e:
 print(f"请求错误: {e}")
except Exception as e:
 print(f"其他错误: {e}")
```

BeautifulSoup包

`SQLAlchemy` 是一个功能强大的 Python SQL 工具包和对象关系映射（ORM）库。



它提供了灵活的、高性能的数据库访问功能。无论是简单的查询还是复杂的事务处理，`SQLAlchemy` 都能提供全面的支持。它允许开发者以面向对象的方式操作数据库，而不需要直接编写 SQL 语句。

### 安装

首先，你需要安装 `SQLAlchemy`。可以通过 pip 来安装：

```bash
pip install sqlalchemy
```

如果你还需要连接到特定类型的数据库（如 PostgreSQL、MySQL 等），你可能需要安装相应的数据库驱动程序。例如：

- PostgreSQL: `psycopg2`
- MySQL: `mysqlclient` 或 `PyMySQL`
- SQLite: 内置支持，无需额外安装

### 基本概念

在使用 `SQLAlchemy` 之前，了解一些基本概念是非常有帮助的：

1. **Engine**: 数据库连接池。
2. **Session**: 用于执行数据库操作的对象。
3. **Metadata**: 数据库结构描述，包括表、列等信息。
4. **Table**: 表定义。
5. **Mapper**: 将 Python 类映射到数据库表的机制。
6. **Query**: 构建和执行查询的对象。

### 使用示例

以下是一些具体的示例，展示了如何使用 `SQLAlchemy` 进行数据库操作。

#### 1. 创建引擎并连接到数据库

```python
from sqlalchemy import create_engine

# 创建一个 SQLite 内存数据库引擎
engine = create_engine('sqlite:///:memory:', echo=True)

# 如果你想连接到一个本地的 SQLite 文件数据库
# engine = create_engine('sqlite:///example.db')

# 对于 PostgreSQL
# engine = create_engine('postgresql+psycopg2://user:password@localhost/mydatabase')
```

#### 2. 定义表结构

使用 ORM 模式时，你需要定义 Python 类来表示数据库中的表。

```python
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String

Base = declarative_base()

class User(Base):
 __tablename__ = 'users'

 id = Column(Integer, primary_key=True)
 name = Column(String)
 age = Column(Integer)

 def __repr__(self):
 return f"<User(name='{self.name}', age={self.age})>"
```

#### 3. 创建表

使用 `Base.metadata.create_all()` 方法创建表。

```python
# 创建所有定义的表
Base.metadata.create_all(engine)
```

#### 4. 创建会话

会话是与数据库进行交互的主要方式。

```python
from sqlalchemy.orm import sessionmaker

Session = sessionmaker(bind=engine)
session = Session()
```

#### 5. 插入数据

你可以通过实例化类来创建新记录，并使用会话将其添加到数据库中。

```python
# 创建新用户
new_user = User(name='Alice', age=30)

# 添加到会话
session.add(new_user)

# 提交会话
session.commit()
```

#### 6. 查询数据

`SQLAlchemy` 提供了多种方式来查询数据。

```python
# 查询所有用户
users = session.query(User).all()
for user in users:
 print(user)

# 查询特定条件的用户
specific_user = session.query(User).filter_by(name='Alice').first()
print(specific_user)
```

#### 7. 更新数据

更新记录也非常简单。

```python
# 查找用户
user_to_update = session.query(User).filter_by(name='Alice').first()

# 修改用户信息
user_to_update.age = 31

# 提交会话
session.commit()
```

#### 8. 删除数据

删除记录同样容易。

```python
# 查找要删除的用户
user_to_delete = session.query(User).filter_by(name='Alice').first()

# 删除用户
session.delete(user_to_delete)

# 提交会话
session.commit()
```

### 更多功能

#### 关联关系

`SQLAlchemy` 支持多种关联关系，如一对一、一对多、多对多等。

```python
from sqlalchemy import ForeignKey
from sqlalchemy.orm import relationship

class Address(Base):
 __tablename__ = 'addresses'
 
 id = Column(Integer, primary_key=True)
 email_address = Column(String, nullable=False)
 user_id = Column(Integer, ForeignKey('users.id'))

 user = relationship("User", back_populates="addresses")

User.addresses = relationship("Address", order_by=Address.id, back_populates="user")
```

#### 事务管理

你可以使用 `session.begin()` 显式地管理事务。

```python
with session.begin():
 new_user = User(name='Bob', age=25)
 session.add(new_user)
 # 自动提交或回滚
```

SQLAlchemy包

`requests` 是一个非常流行的 Python HTTP 库，它使得发送 HTTP/1.1 请求变得非常简单。无论你需要执行 GET、POST、PUT 或 DELETE 等操作，`requests` 都能以一种直观且易于使用的方式帮助你完成任务。它支持复杂的用例，如通过 multipart 文件上传、流式传输大型下载、会话保持（cookies）、HTTP(S) 代理支持等。




### 1. 安装

首先，你需要安装 `requests` 包。可以通过 pip 来安装：

```bash
pip install requests
```

### 2. 发送网络请求
#### 2.1 发送 GET 请求
这是最基本的用法，用于从指定 URL 获取数据。

```python
import requests

response = requests.get('https://api.github.com')

# 输出状态码
print(response.status_code)

# 输出响应内容
print(response.text)
```
##### 添加查询参数

在 GET 请求中，经常需要添加查询参数：

```python
import requests

# URL 和查询参数
url = 'https://httpbin.org/get'
params = {'key1': 'value1', 'key2': 'value2'}

# 发送 GET 请求并附带查询参数
response = requests.get(url, params=params)

# 输出完整的请求 URL
print(f"完整URL: {response.url}")

# 输出响应内容
print(f"响应内容: {response.text}")
```

#### 2.2 发送 POST 请求

当你需要向服务器提交数据时，可以使用 POST 方法。

```python
import requests

url = 'https://httpbin.org/post'
data = {'key': 'value'}

response = requests.post(url, data=data)

# 输出响应内容
print(response.text)
```
### 3. 详细操作

#### 3.1使用代理
使用 `requests` 库通过代理发送 HTTP 请求非常简单。你可以通过设置 `proxies` 参数来指定代理服务器。

##### 使用 HTTP 代理

假设你有一个 HTTP 代理服务器，地址为 `http://10.10.1.10:3128`，你可以这样设置：

```python
import requests

# 定义代理
proxies = {
 'http': 'http://10.10.1.10:3128',
 'https': 'http://10.10.1.10:3128',
}

# 发送 GET 请求并使用代理
response = requests.get('http://httpbin.org/ip', proxies=proxies)

# 输出响应内容
print(f"您的 IP 地址是: {response.text}")
```

##### 使用带认证的代理

如果你的代理服务器需要用户名和密码进行认证，可以在代理 URL 中包含这些信息：

```python
import requests

# 定义带认证的代理
proxies = {
 'http': 'http://user:password@10.10.1.10:3128',
 'https': 'http://user:password@10.10.1.10:3128',
}

# 发送 GET 请求并使用带认证的代理
response = requests.get('http://httpbin.org/ip', proxies=proxies)

# 输出响应内容
print(f"您的 IP 地址是: {response.text}")
```

##### 使用环境变量设置代理

你还可以通过环境变量来设置代理，`requests` 会自动读取这些环境变量：

```bash
export HTTP_PROXY="http://10.10.1.10:3128"
export HTTPS_PROXY="http://10.10.1.10:3128"
```

在 Python 脚本中无需显式传递 `proxies` 参数：

```python
import requests

# 环境变量已设置，直接发送请求
response = requests.get('http://httpbin.org/ip')

# 输出响应内容
print(f"您的 IP 地址是: {response.text}")
```

##### 忽略 SSL 验证（不推荐用于生产环境）

有时你可能需要忽略 SSL 验证（例如，当使用自签名证书时）。可以通过设置 `verify` 参数为 `False` 来实现：

```python
import requests

# 定义代理
proxies = {
 'http': 'http://10.10.1.10:3128',
 'https': 'http://10.10.1.10:3128',
}

# 发送 GET 请求并使用代理，忽略 SSL 验证
response = requests.get('https://httpbin.org/ip', proxies=proxies, verify=False)

# 输出响应内容
print(f"您的 IP 地址是: {response.text}")
```

注意：忽略 SSL 验证可能会导致安全风险，请仅在测试环境中使用此选项。



#### 3.2使用 Headers 和 Params

有时，你可能需要添加自定义的 headers 或者 URL 参数。

```python
import requests

url = 'https://httpbin.org/get'
headers = {'user-agent': 'my-app/0.0.1'}
params = {'key1': 'value1', 'key2': 'value2'}

response = requests.get(url, headers=headers, params=params)

# 输出响应内容
print(response.text)
```
#### 3.2使用 data(post)
get请求不能携带参数

```python
import requests

url = 'https://httpbin.org/get'
headers = {'user-agent': 'my-app/0.0.1'}
data = {'key1': 'value1', 'key2': 'value2'}

response = requests.get(url, headers=headers, data=data)

# 输出响应内容
print(response.text)
```

#### 3.4 使用 Session 对象

对于需要保持会话状态的操作（如登录后访问页面），可以使用 `Session` 对象：

```python
import requests

# 创建一个会话对象
session = requests.Session()

# 登录请求
login_url = 'https://httpbin.org/basic-auth/user/passwd'
auth = ('user', 'passwd')
session.auth = auth

# 发送登录请求
response = session.get(login_url)

# 输出响应内容
print(f"登录响应: {response.text}")

# 访问需要登录的页面
protected_url = 'https://httpbin.org/basic-auth/user/passwd'
response = session.get(protected_url)

# 输出响应内容
print(f"受保护页面响应: {response.text}")

# 关闭会话
session.close()
```

#### 3.5 处理 JSON 响应

许多现代 API 返回 JSON 格式的响应，`requests` 提供了方便的方法来处理这些响应。

```python
import requests

response = requests.get('https://api.github.com')

# 将响应内容解析为 JSON
json_response = response.json()

# 输出 JSON 内容
print(json_response)
```

#### 3.6 错误和异常处理

在进行网络请求时，错误是不可避免的。`requests` 提供了异常处理机制来捕获这些错误。

```python
import requests
from requests.exceptions import HTTPError

try:
 response = requests.get('https://api.github.com')
 # 如果响应状态码不是成功的代码，则引发 HTTPError 异常
 response.raise_for_status()
except HTTPError as http_err:
 print(f'HTTP error occurred: {http_err}')
except Exception as err:
 print(f'Other error occurred: {err}')
else:
 print('Success!')
```

#### 3.7 文件上传

你可以轻松地使用 `requests` 上传文件：

```python
import requests

# URL 和文件路径
url = 'https://httpbin.org/post'
files = {'file': open('example.txt', 'rb')}

# 发送 POST 请求并上传文件
response = requests.post(url, files=files)

# 输出响应内容
print(f"响应内容: {response.text}")
```

注意：确保你有一个名为 `example.txt` 的文件存在于当前工作目录中。



#### 3.8 流式请求

当你需要处理大文件下载时，可以使用流式请求：

```python
import requests

url = 'https://speed.hetzner.de/100MB.bin'

with requests.get(url, stream=True) as r:
 r.raise_for_status()
 with open('large_file.bin', 'wb') as f:
 for chunk in r.iter_content(chunk_size=8192):
 if chunk: # 过滤掉 keep-alive 新块
 f.write(chunk)
```
#### 3.9 处理超时

为了防止请求长时间挂起，可以设置超时参数：

```python
import requests

# 定义代理

try:
 # 发送 GET 请求并使用代理，设置超时时间为5秒
 response = requests.get('http://httpbin.org/ip', timeout=5)
 
 # 输出响应内容
 print(f"您的 IP 地址是: {response.text}")
except requests.Timeout as e:
 print(f"请求超时: {e}")
except requests.RequestException as e:
 print(f"请求错误: {e}")
```