2025 新版 Python 编程教程：算法解析 + LeetCode 实战案例详解

def two_sum(nums, target):
    num_map = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in num_map:
            return [num_map[complement], i]
        num_map[num] = i
    return []

def max_area(height):
    left, right = , len(height) - 
    max_water = 
    while left < right:
        current_width = right - left
        current_height = min(height[left], height[right])
        current_water = current_width * current_height
        if current_water > max_water:
            max_water = current_water
        if height[left] < height[right]:
            left += 
        else:
            right -= 
    return max_water

class ListNode:
    def __init__(self, key=, val=):
        self.key = key
        self.val = val
        self.prev = None
        self.next = None

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = {}
        self.head = ListNode()
        self.tail = ListNode()
        self.head.next = self.tail
        self.tail.prev = self.head

    def get(self, key):
        if key in self.cache:
            node = self.cache[key]
            self._move_to_head(node)
            return node.val
        return -

    def put(self, key, value):
        if key in self.cache:
            node = self.cache[key]
            node.val = value
            self._move_to_head(node)
        else:
            new_node = ListNode(key, value)
            self.cache[key] = new_node
            self._add_to_head(new_node)
            if len(self.cache) > self.capacity:
                removed_node = self.tail.prev
                self._remove_node(removed_node)
                del self.cache[removed_node.key]

    def _move_to_head(self, node):
        self._remove_node(node)
        self._add_to_head(node)

    def _add_to_head(self, node):
        node.prev = self.head
        node.next = self.head.next
        self.head.next.prev = node
        self.head.next = node

    def _remove_node(self, node):
        node.prev.next = node.next
        node.next.prev = node.prev

from sklearn.linear_model import LogisticRegression
from sklearn.feature_extraction.text import TfidfVectorizer

# 训练数据
emails = ["buy now", "hello friend", "spam offer"]
labels = [, , ]

# 特征提取
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(emails)

# 模型训练
model = LogisticRegression()
model.fit(X, labels)

# 预测
new_email = ["win money"]
X_new = vectorizer.transform([new_email])
print(model.predict(X_new))  # 输出 [1]

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

# 数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=, shuffle=True)

# 定义模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(, , )
        self.pool = nn.MaxPool2d(, )
        self.conv2 = nn.Conv2d(, , )
        self.fc1 = nn.Linear( *  * , )
        self.fc2 = nn.Linear(, )
        self.fc3 = nn.Linear(, )

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-,  *  * )
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# 初始化模型与优化器
model = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

# 训练模型
for epoch in range():
    running_loss = 0.0
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f'Epoch {epoch+}, Loss: {running_loss / len(train_loader):.3f}')