Python 网络访问是指通过 Python 代码与网络中的其他设备（如服务器、客户端）进行数据交互的过程，涵盖 HTTP/HTTPS 请求、TCP/UDP 通信、网络服务端开发、爬虫 等核心场景。以下是更详细的分类及实现方式：

一、HTTP/HTTPS 请求（应用层）

HTTP/HTTPS 是最常用的网络协议，用于访问网页、调用 API 等。Python 中主要通过 requests（第三方库）和 urllib（标准库）实现。

1. requests 库（推荐）

requests 简化了 HTTP 请求流程，支持自动处理 Cookie、会话、SSL 验证等。

高级特性：

• 会话保持：使用 requests.Session() 维持会话（如登录后保持登录状态）。
• 文件上传：支持上传本地文件到服务器。
• 代理设置：通过代理服务器访问网络（如爬虫防封禁）。
• SSL 验证：控制是否验证服务器 SSL 证书（默认验证）。

示例：

import requests

# 会话保持（登录后访问需要登录的页面）
session = requests.Session()
login_url = "https://example.com/login"
session.post(login_url, data={"username": "user", "password": "pass"})

# 访问需要登录的页面（自动携带 Cookie）
profile_url = "https://example.com/profile"
response = session.get(profile_url)
print(response.text)

# 文件上传
upload_url = "https://example.com/upload"
files = {"file": open("test.txt", "rb")}  # 打开文件
response = requests.post(upload_url, files=files)
print(response.json())

# 代理设置
proxies = {
    "http": "http://127.0.0.1:8080",
    "https": "https://127.0.0.1:8080"
}
response = requests.get("https://api.ipify.org", proxies=proxies)
print("代理 IP：", response.text)

# 禁用 SSL 验证（不推荐，仅用于测试）
response = requests.get("https://self-signed.badssl.com", verify=False)

2. urllib 库（标准库）

urllib 是 Python 内置的 HTTP 工具，功能全面但语法较繁琐，适合简单场景或无第三方库环境。

示例：

from urllib import request, parse
import ssl

# 忽略 SSL 证书验证（用于自签名证书）
ssl_context = ssl.create_default_context()
ssl_context.check_hostname = False
ssl_context.verify_mode = ssl.CERT_NONE

# 带代理的请求
proxy_handler = request.ProxyHandler({"http": "http://127.0.0.1:8080"})
opener = request.build_opener(proxy_handler)
request.install_opener(opener)

# 发送请求
url = "https://api.ipify.org"
response = request.urlopen(url, context=ssl_context)
print("IP：", response.read().decode("utf-8"))

二、TCP/UDP 通信（传输层）

TCP 和 UDP 是传输层协议，适用于需要直接数据传输的场景（如即时通讯、文件传输）。

1. TCP 通信

TCP 是面向连接的可靠协议，支持数据重传和顺序保证。

高级示例（多客户端并发）：

# TCP 多线程服务端
import socket
import threading

def handle_client(client_socket, client_addr):
    """处理单个客户端请求"""
    print(f"客户端 {client_addr} 连接成功")
    while True:
        try:
            # 接收数据（1024 字节）
            data = client_socket.recv(1024).decode("utf-8")
            if not data:  # 客户端断开连接
                break
            print(f"收到 {client_addr} 消息：{data}")
            # 回复客户端
            client_socket.send(f"已收到：{data}".encode("utf-8"))
        except Exception as e:
            print(f"客户端 {client_addr} 异常：{e}")
            break
    client_socket.close()
    print(f"客户端 {client_addr} 断开连接")

# 启动服务端
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  # 允许端口复用
server_socket.bind(("0.0.0.0", 9999))  # 监听所有网卡
server_socket.listen(5)
print("TCP 服务端启动，监听端口 9999")

while True:
    # 接受客户端连接（阻塞）
    client_socket, client_addr = server_socket.accept()
    # 开启线程处理客户端
    thread = threading.Thread(target=handle_client, args=(client_socket, client_addr))
    thread.daemon = True  # 主线程退出时，子线程也退出
    thread.start()

TCP 客户端：

import socket

client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect(("localhost", 9999))

while True:
    message = input("请输入消息（输入 q 退出）：")
    if message == "q":
        break
    client_socket.send(message.encode("utf-8"))
    # 接收服务端回复
    response = client_socket.recv(1024).decode("utf-8")
    print(f"服务端回复：{response}")

client_socket.close()

2. UDP 通信

UDP 是无连接协议，传输速度快但不保证数据可靠，适合实时数据传输（如语音、视频）。

示例：

# UDP 服务端
import socket

server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server_socket.bind(("0.0.0.0", 9999))
print("UDP 服务端启动，监听端口 9999")

while True:
    # 接收数据（阻塞）
    data, client_addr = server_socket.recvfrom(1024)
    print(f"收到 {client_addr} 消息：{data.decode('utf-8')}")
    # 回复客户端
    server_socket.sendto(f"已收到（UDP）：{data.decode('utf-8')}".encode("utf-8"), client_addr)

UDP 客户端：

import socket

client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server_addr = ("localhost", 9999)

while True:
    message = input("请输入消息（输入 q 退出）：")
    if message == "q":
        break
    client_socket.sendto(message.encode("utf-8"), server_addr)
    # 接收服务端回复
    response, _ = client_socket.recvfrom(1024)
    print(f"服务端回复：{response.decode('utf-8')}")

client_socket.close()

三、网络服务端开发

Python 可搭建 Web 服务端，接收 HTTP 请求并返回响应，常用框架有 Flask（轻量）、Django（全功能）和 FastAPI（高性能）。

1. FastAPI（现代高性能 API 框架）

FastAPI 基于 Starlette 和 Pydantic，支持异步、自动生成 API 文档，适合构建 RESTful API。

示例：

from fastapi import FastAPI
from pydantic import BaseModel

# 创建 FastAPI 实例
app = FastAPI()

# 定义请求体模型（自动校验数据）
class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None

# 定义路由（GET 请求）
@app.get("/")
def read_root():
    return {"message": "Hello, FastAPI!"}

# 带路径参数的路由
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

# 带请求体的路由（POST 请求）
@app.post("/items/")
def create_item(item: Item):
    return {"item_name": item.name, "item_price": item.price}

# 运行服务（命令行：uvicorn main:app --reload）

安装：

bash

运行

pip install fastapi uvicorn

2. Django（全功能 Web 框架）

Django 内置 ORM、admin 后台、用户认证等功能，适合复杂 Web 应用。

快速入门：

# 创建项目
django-admin startproject myproject
cd myproject

# 创建应用
python manage.py startapp myapp

# 编写视图（myapp/views.py）
from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, Django!")

# 配置 URL（myproject/urls.py）
from django.contrib import admin
from django.urls import path
from myapp.views import index

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', index),
]

# 运行服务
python manage.py runserver

四、网络爬虫

网络爬虫是自动化获取网页数据的工具，核心步骤为 请求网页、解析数据、存储结果。

1. 爬虫工具链

• 请求库：requests、aiohttp（异步）。
• 解析库：BeautifulSoup4（HTML/XML 解析）、lxml（高效解析）、pyquery（jQuery 语法）。
• 爬虫框架：Scrapy（分布式爬虫）、Playwright（模拟浏览器）。

2. 示例：使用 Scrapy 爬取网页

# 创建 Scrapy 项目
scrapy startproject myspider
cd myspider

# 创建爬虫
scrapy genspider quotes http://quotes.toscrape.com

# 编写爬虫（myspider/spiders/quotes_spider.py）
import scrapy

class QuotesSpider(scrapy.Spider):
    name = 'quotes'
    allowed_domains = ['quotes.toscrape.com']
    start_urls = ['http://quotes.toscrape.com/']

    def parse(self, response):
        # 提取数据
        quotes = response.css('div.quote')
        for quote in quotes:
            yield {
                'text': quote.css('span.text::text').get(),
                'author': quote.css('small.author::text').get(),
                'tags': quote.css('div.tags a.tag::text').getall(),
            }

        # 翻页
        next_page = response.css('li.next a::attr(href)').get()
        if next_page:
            yield response.follow(next_page, self.parse)

# 运行爬虫（保存到 JSON 文件）
scrapy crawl quotes -o quotes.json

五、网络安全与最佳实践

1. 数据加密：

   • 使用 HTTPS/TLS 传输敏感数据。
   • 对密码等敏感信息进行加密存储（如使用 bcrypt 库）。

2. 防爬虫措施：

   • 设置合理的请求间隔（time.sleep()）。
   • 模拟浏览器 User-Agent，避免被识别为爬虫。
   • 使用代理 IP 池（如 proxy_pool 库）。

3. 并发与性能：

   • 异步请求：使用 aiohttp、httpx（异步版 requests）。
   • 多线程 / 多进程：使用 threading、multiprocessing 处理并发任务。

4. 异常处理：

   • 捕获网络超时、连接错误等异常。
   • 对爬虫添加重试机制（如 tenacity 库）。

六、常用网络工具库

场景	推荐库
HTTP 请求	requests、httpx、aiohttp
Web 服务端	Flask、FastAPI、Django
TCP/UDP 通信	socket、asyncio（异步）
爬虫	Scrapy、BeautifulSoup4、Playwright
数据解析	lxml、pyquery
网络安全	cryptography、bcrypt
代理 IP 池	proxy_pool、requests-proxy

总结

Python 网络访问覆盖从应用层到传输层的全场景，选择合适的库和框架可大幅提升开发效率：

• 简单 HTTP 请求：用 requests。
• 高性能 API 服务：用 FastAPI。
• 复杂 Web 应用：用 Django。
• 底层通信：用 socket。
• 大规模爬虫：用 Scrapy。

根据实际需求选择工具，并注意网络安全和性能优化。